elasticsearch9 9.2.1__py3-none-any.whl → 9.3.0__py3-none-any.whl

elasticsearch9/_sync/client/cat.py

@@ -328,6 +328,149 @@ class CatClient(NamespacedClient):
             path_parts=__path_parts,
         )
 
+    @_rewrite_parameters()
+    def circuit_breaker(
+        self,
+        *,
+        circuit_breaker_patterns: t.Optional[t.Union[str, t.Sequence[str]]] = None,
+        bytes: t.Optional[
+            t.Union[str, t.Literal["b", "gb", "kb", "mb", "pb", "tb"]]
+        ] = None,
+        error_trace: t.Optional[bool] = None,
+        filter_path: t.Optional[t.Union[str, t.Sequence[str]]] = None,
+        format: t.Optional[str] = None,
+        h: t.Optional[
+            t.Union[
+                t.Sequence[
+                    t.Union[
+                        str,
+                        t.Literal[
+                            "breaker",
+                            "estimated",
+                            "estimated_bytes",
+                            "limit",
+                            "limit_bytes",
+                            "node_id",
+                            "node_name",
+                            "overhead",
+                            "tripped",
+                        ],
+                    ]
+                ],
+                t.Union[
+                    str,
+                    t.Literal[
+                        "breaker",
+                        "estimated",
+                        "estimated_bytes",
+                        "limit",
+                        "limit_bytes",
+                        "node_id",
+                        "node_name",
+                        "overhead",
+                        "tripped",
+                    ],
+                ],
+            ]
+        ] = None,
+        help: t.Optional[bool] = None,
+        human: t.Optional[bool] = None,
+        local: t.Optional[bool] = None,
+        master_timeout: t.Optional[t.Union[str, t.Literal[-1], t.Literal[0]]] = None,
+        pretty: t.Optional[bool] = None,
+        s: t.Optional[t.Union[str, t.Sequence[str]]] = None,
+        time: t.Optional[
+            t.Union[str, t.Literal["d", "h", "m", "micros", "ms", "nanos", "s"]]
+        ] = None,
+        v: t.Optional[bool] = None,
+    ) -> t.Union[ObjectApiResponse[t.Any], TextApiResponse]:
+        """
+        .. raw:: html
+
+          <p>Get circuit breakers statistics.</p>
+          <p>IMPORTANT: CAT APIs are only intended for human consumption using the command line or Kibana console. They are not intended for use by applications.</p>
+
+
+        `<https://www.elastic.co/docs/api/doc/elasticsearch#TODO>`_
+
+        :param circuit_breaker_patterns: A comma-separated list of regular-expressions
+            to filter the circuit breakers in the output
+        :param bytes: Sets the units for columns that contain a byte-size value. Note
+            that byte-size value units work in terms of powers of 1024. For instance
+            `1kb` means 1024 bytes, not 1000 bytes. If omitted, byte-size values are
+            rendered with a suffix such as `kb`, `mb`, or `gb`, chosen such that the
+            numeric value of the column is as small as possible whilst still being at
+            least `1.0`. If given, byte-size values are rendered as an integer with no
+            suffix, representing the value of the column in the chosen unit. Values that
+            are not an exact multiple of the chosen unit are rounded down.
+        :param format: Specifies the format to return the columnar data in, can be set
+            to `text`, `json`, `cbor`, `yaml`, or `smile`.
+        :param h: A comma-separated list of columns names to display. It supports simple
+            wildcards.
+        :param help: When set to `true` will output available columns. This option can't
+            be combined with any other query string option.
+        :param local: If `true`, the request computes the list of selected nodes from
+            the local cluster state. If `false` the list of selected nodes are computed
+            from the cluster state of the master node. In both cases the coordinating
+            node will send requests for further information to each selected node.
+        :param master_timeout: Period to wait for a connection to the master node.
+        :param s: List of columns that determine how the table should be sorted. Sorting
+            defaults to ascending and can be changed by setting `:asc` or `:desc` as
+            a suffix to the column name.
+        :param time: Sets the units for columns that contain a time duration. If omitted,
+            time duration values are rendered with a suffix such as `ms`, `s`, `m` or
+            `h`, chosen such that the numeric value of the column is as small as possible
+            whilst still being at least `1.0`. If given, time duration values are rendered
+            as an integer with no suffix. Values that are not an exact multiple of the
+            chosen unit are rounded down.
+        :param v: When set to `true` will enable verbose output.
+        """
+        __path_parts: t.Dict[str, str]
+        if circuit_breaker_patterns not in SKIP_IN_PATH:
+            __path_parts = {
+                "circuit_breaker_patterns": _quote(circuit_breaker_patterns)
+            }
+            __path = f'/_cat/circuit_breaker/{__path_parts["circuit_breaker_patterns"]}'
+        else:
+            __path_parts = {}
+            __path = "/_cat/circuit_breaker"
+        __query: t.Dict[str, t.Any] = {}
+        if bytes is not None:
+            __query["bytes"] = bytes
+        if error_trace is not None:
+            __query["error_trace"] = error_trace
+        if filter_path is not None:
+            __query["filter_path"] = filter_path
+        if format is not None:
+            __query["format"] = format
+        if h is not None:
+            __query["h"] = h
+        if help is not None:
+            __query["help"] = help
+        if human is not None:
+            __query["human"] = human
+        if local is not None:
+            __query["local"] = local
+        if master_timeout is not None:
+            __query["master_timeout"] = master_timeout
+        if pretty is not None:
+            __query["pretty"] = pretty
+        if s is not None:
+            __query["s"] = s
+        if time is not None:
+            __query["time"] = time
+        if v is not None:
+            __query["v"] = v
+        __headers = {"accept": "text/plain,application/json"}
+        return self.perform_request(  # type: ignore[return-value]
+            "GET",
+            __path,
+            params=__query,
+            headers=__headers,
+            endpoint_id="cat.circuit_breaker",
+            path_parts=__path_parts,
+        )
+
     @_rewrite_parameters()
     def component_templates(
         self,
@@ -468,7 +611,9 @@ class CatClient(NamespacedClient):
             path_parts=__path_parts,
         )
 
-    @_rewrite_parameters()
+    @_rewrite_parameters(
+        body_fields=("project_routing",),
+    )
     def count(
         self,
         *,
@@ -494,6 +639,7 @@ class CatClient(NamespacedClient):
             t.Union[str, t.Literal["d", "h", "m", "micros", "ms", "nanos", "s"]]
         ] = None,
         v: t.Optional[bool] = None,
+        body: t.Optional[t.Dict[str, t.Any]] = None,
     ) -> t.Union[ObjectApiResponse[t.Any], TextApiResponse]:
         """
         .. raw:: html
@@ -524,10 +670,10 @@ class CatClient(NamespacedClient):
             wildcards.
         :param help: When set to `true` will output available columns. This option can't
             be combined with any other query string option.
-        :param project_routing: Specifies a subset of projects to target for the search
-            using project metadata tags in a subset of Lucene query syntax. Allowed Lucene
-            queries: the _alias tag and a single value (possibly wildcarded). Examples:
-            _alias:my-project _alias:_origin _alias:*pr* Supported in serverless only.
+        :param project_routing: Specifies a subset of projects to target using project
+            metadata tags in a subset of Lucene query syntax. Allowed Lucene queries:
+            the _alias tag and a single value (possibly wildcarded). Examples: _alias:my-project
+            _alias:_origin _alias:*pr* Supported in serverless only.
         :param s: List of columns that determine how the table should be sorted. Sorting
             defaults to ascending and can be changed by setting `:asc` or `:desc` as
             a suffix to the column name.
@@ -547,6 +693,7 @@ class CatClient(NamespacedClient):
             __path_parts = {}
             __path = "/_cat/count"
         __query: t.Dict[str, t.Any] = {}
+        __body: t.Dict[str, t.Any] = body if body is not None else {}
         if bytes is not None:
             __query["bytes"] = bytes
         if error_trace is not None:
@@ -563,20 +710,26 @@ class CatClient(NamespacedClient):
             __query["human"] = human
         if pretty is not None:
             __query["pretty"] = pretty
-        if project_routing is not None:
-            __query["project_routing"] = project_routing
         if s is not None:
             __query["s"] = s
         if time is not None:
             __query["time"] = time
         if v is not None:
             __query["v"] = v
+        if not __body:
+            if project_routing is not None:
+                __body["project_routing"] = project_routing
+        if not __body:
+            __body = None  # type: ignore[assignment]
         __headers = {"accept": "text/plain,application/json"}
+        if __body is not None:
+            __headers["content-type"] = "application/json"
         return self.perform_request(  # type: ignore[return-value]
-            "GET",
+            "POST",
             __path,
             params=__query,
             headers=__headers,
+            body=__body,
             endpoint_id="cat.count",
             path_parts=__path_parts,
         )
@@ -2516,6 +2669,7 @@ class CatClient(NamespacedClient):
                     t.Union[
                         str,
                         t.Literal[
+                            "available_processors",
                             "build",
                             "completion.size",
                             "cpu",
@@ -2611,6 +2765,7 @@ class CatClient(NamespacedClient):
                 t.Union[
                     str,
                     t.Literal[
+                        "available_processors",
                         "build",
                         "completion.size",
                         "cpu",

elasticsearch9/_sync/client/cluster.py

@@ -302,8 +302,8 @@ class ClusterClient(NamespacedClient):
 
         `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-cluster-put-component-template>`_
 
-        :param name: Comma-separated list of component template names used to limit the
-            request. Wildcard (`*`) expressions are supported.
+        :param name: Name of component template to retrieve. Wildcard (`*`) expressions
+            are supported.
         :param flat_settings: If `true`, returns settings in flat format.
         :param include_defaults: Return all default configurations for the component
             template
@@ -470,39 +470,38 @@ class ClusterClient(NamespacedClient):
 
         `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-cluster-health>`_
 
-        :param index: Comma-separated list of data streams, indices, and index aliases
-            used to limit the request. Wildcard expressions (`*`) are supported. To target
+        :param index: A comma-separated list of data streams, indices, and index aliases
+            that limit the request. Wildcard expressions (`*`) are supported. To target
             all data streams and indices in a cluster, omit this parameter or use _all
             or `*`.
-        :param expand_wildcards: Whether to expand wildcard expression to concrete indices
-            that are open, closed or both.
-        :param level: Can be one of cluster, indices or shards. Controls the details
-            level of the health information returned.
-        :param local: If true, the request retrieves information from the local node
-            only. Defaults to false, which means information is retrieved from the master
-            node.
-        :param master_timeout: Period to wait for a connection to the master node. If
-            no response is received before the timeout expires, the request fails and
-            returns an error.
-        :param timeout: Period to wait for a response. If no response is received before
-            the timeout expires, the request fails and returns an error.
-        :param wait_for_active_shards: A number controlling to how many active shards
-            to wait for, all to wait for all shards in the cluster to be active, or 0
-            to not wait.
-        :param wait_for_events: Can be one of immediate, urgent, high, normal, low, languid.
-            Wait until all currently queued events with the given priority are processed.
-        :param wait_for_no_initializing_shards: A boolean value which controls whether
-            to wait (until the timeout provided) for the cluster to have no shard initializations.
-            Defaults to false, which means it will not wait for initializing shards.
-        :param wait_for_no_relocating_shards: A boolean value which controls whether
-            to wait (until the timeout provided) for the cluster to have no shard relocations.
-            Defaults to false, which means it will not wait for relocating shards.
-        :param wait_for_nodes: The request waits until the specified number N of nodes
-            is available. It also accepts >=N, <=N, >N and <N. Alternatively, it is possible
-            to use ge(N), le(N), gt(N) and lt(N) notation.
-        :param wait_for_status: One of green, yellow or red. Will wait (until the timeout
-            provided) until the status of the cluster changes to the one provided or
-            better, i.e. green > yellow > red. By default, will not wait for any status.
+        :param expand_wildcards: Expand wildcard expression to concrete indices that
+            are open, closed or both.
+        :param level: Return health information at a specific level of detail.
+        :param local: If true, retrieve information from the local node only. If false,
+            retrieve information from the master node.
+        :param master_timeout: The period to wait for a connection to the master node.
+            If no response is received before the timeout expires, the request fails
+            and returns an error.
+        :param timeout: The period to wait for a response. If no response is received
+            before the timeout expires, the request fails and returns an error.
+        :param wait_for_active_shards: Wait for the specified number of active shards.
+            Use `all` to wait for all shards in the cluster to be active. Use `0` to
+            not wait.
+        :param wait_for_events: Wait until all currently queued events with the given
+            priority are processed.
+        :param wait_for_no_initializing_shards: Wait (until the timeout expires) for
+            the cluster to have no shard initializations. If false, the request does
+            not wait for initializing shards.
+        :param wait_for_no_relocating_shards: Wait (until the timeout expires) for the
+            cluster to have no shard relocations. If false, the request not wait for
+            relocating shards.
+        :param wait_for_nodes: Wait until the specified number (N) of nodes is available.
+            It also accepts `>=N`, `<=N`, `>N` and `<N`. Alternatively, use the notations
+            `ge(N)`, `le(N)`, `gt(N)`, and `lt(N)`.
+        :param wait_for_status: Wait (until the timeout expires) for the cluster to reach
+            a specific health status (or a better status). A green status is better than
+            yellow and yellow is better than red. By default, the request does not wait
+            for a particular status.
         """
         __path_parts: t.Dict[str, str]
         if index not in SKIP_IN_PATH:
@@ -1068,7 +1067,40 @@ class ClusterClient(NamespacedClient):
     def state(
         self,
         *,
-        metric: t.Optional[t.Union[str, t.Sequence[str]]] = None,
+        metric: t.Optional[
+            t.Union[
+                t.Sequence[
+                    t.Union[
+                        str,
+                        t.Literal[
+                            "_all",
+                            "blocks",
+                            "customs",
+                            "master_node",
+                            "metadata",
+                            "nodes",
+                            "routing_nodes",
+                            "routing_table",
+                            "version",
+                        ],
+                    ]
+                ],
+                t.Union[
+                    str,
+                    t.Literal[
+                        "_all",
+                        "blocks",
+                        "customs",
+                        "master_node",
+                        "metadata",
+                        "nodes",
+                        "routing_nodes",
+                        "routing_table",
+                        "version",
+                    ],
+                ],
+            ]
+        ] = None,
         index: t.Optional[t.Union[str, t.Sequence[str]]] = None,
         allow_no_indices: t.Optional[bool] = None,
         error_trace: t.Optional[bool] = None,

elasticsearch9/_sync/client/eql.py

@@ -187,6 +187,7 @@ class EqlClient(NamespacedClient):
             "keep_alive",
             "keep_on_completion",
             "max_samples_per_key",
+            "project_routing",
             "result_position",
             "runtime_mappings",
             "size",
@@ -286,10 +287,10 @@ class EqlClient(NamespacedClient):
             `size` parameter to get a smaller or larger set of samples. To retrieve more
             than one sample per set of join keys, use the `max_samples_per_key` parameter.
             Pipes are not supported for sample queries.
-        :param project_routing: Specifies a subset of projects to target for the search
-            using project metadata tags in a subset of Lucene query syntax. Allowed Lucene
-            queries: the _alias tag and a single value (possibly wildcarded). Examples:
-            _alias:my-project _alias:_origin _alias:*pr* Supported in serverless only.
+        :param project_routing: Specifies a subset of projects to target using project
+            metadata tags in a subset of Lucene query syntax. Allowed Lucene queries:
+            the _alias tag and a single value (possibly wildcarded). Examples: _alias:my-project
+            _alias:_origin _alias:*pr* Supported in serverless only.
         :param result_position:
         :param runtime_mappings:
         :param size: For basic queries, the maximum number of matching events to return.
@@ -323,8 +324,6 @@ class EqlClient(NamespacedClient):
             __query["ignore_unavailable"] = ignore_unavailable
         if pretty is not None:
             __query["pretty"] = pretty
-        if project_routing is not None:
-            __query["project_routing"] = project_routing
         if not __body:
             if query is not None:
                 __body["query"] = query
@@ -350,6 +349,8 @@ class EqlClient(NamespacedClient):
                 __body["keep_on_completion"] = keep_on_completion
             if max_samples_per_key is not None:
                 __body["max_samples_per_key"] = max_samples_per_key
+            if project_routing is not None:
+                __body["project_routing"] = project_routing
             if result_position is not None:
                 __body["result_position"] = result_position
             if runtime_mappings is not None:

elasticsearch9/_sync/client/esql.py

@@ -126,10 +126,10 @@ class EsqlClient(NamespacedClient):
             query, the response will include an extra `_clusters` object with information
             about the clusters that participated in the search along with info such as
             shards count.
-        :param include_execution_metadata: When set to `true` and performing a cross-cluster/cross-project
-            query, the response will include an extra `_clusters` object with information
-            about the clusters that participated in the search along with info such as
-            shards count.
+        :param include_execution_metadata: When set to `true`, the response will include
+            an extra `_clusters` object with information about the clusters that participated
+            in the search along with info such as shards count. This is similar to `include_ccs_metadata`,
+            but it also returns metadata when the query is not CCS/CPS
         :param keep_alive: The period for which the query and its results are stored
             in the cluster. The default period is five days. When this period expires,
             the query and its results are deleted, even if the query is still ongoing.
@@ -403,6 +403,51 @@ class EsqlClient(NamespacedClient):
             path_parts=__path_parts,
         )
 
+    @_rewrite_parameters()
+    @_availability_warning(Stability.EXPERIMENTAL)
+    def delete_view(
+        self,
+        *,
+        name: str,
+        error_trace: t.Optional[bool] = None,
+        filter_path: t.Optional[t.Union[str, t.Sequence[str]]] = None,
+        human: t.Optional[bool] = None,
+        pretty: t.Optional[bool] = None,
+    ) -> ObjectApiResponse[t.Any]:
+        """
+        .. raw:: html
+
+          <p>Delete an ES|QL view.</p>
+          <p>Deletes a stored ES|QL view.</p>
+
+
+        `<https://www.elastic.co/docs/api/doc/elasticsearch#TODO>`_
+
+        :param name: The view name to remove.
+        """
+        if name in SKIP_IN_PATH:
+            raise ValueError("Empty value passed for parameter 'name'")
+        __path_parts: t.Dict[str, str] = {"name": _quote(name)}
+        __path = f'/_query/view/{__path_parts["name"]}'
+        __query: t.Dict[str, t.Any] = {}
+        if error_trace is not None:
+            __query["error_trace"] = error_trace
+        if filter_path is not None:
+            __query["filter_path"] = filter_path
+        if human is not None:
+            __query["human"] = human
+        if pretty is not None:
+            __query["pretty"] = pretty
+        __headers = {"accept": "application/json"}
+        return self.perform_request(  # type: ignore[return-value]
+            "DELETE",
+            __path,
+            params=__query,
+            headers=__headers,
+            endpoint_id="esql.delete_view",
+            path_parts=__path_parts,
+        )
+
     @_rewrite_parameters()
     @_availability_warning(Stability.EXPERIMENTAL)
     def get_query(
@@ -448,6 +493,54 @@ class EsqlClient(NamespacedClient):
             path_parts=__path_parts,
         )
 
+    @_rewrite_parameters()
+    @_availability_warning(Stability.EXPERIMENTAL)
+    def get_view(
+        self,
+        *,
+        name: t.Optional[str] = None,
+        error_trace: t.Optional[bool] = None,
+        filter_path: t.Optional[t.Union[str, t.Sequence[str]]] = None,
+        human: t.Optional[bool] = None,
+        pretty: t.Optional[bool] = None,
+    ) -> ObjectApiResponse[t.Any]:
+        """
+        .. raw:: html
+
+          <p>Get an ES|QL view.</p>
+          <p>Returns a stored ES|QL view.</p>
+
+
+        `<https://www.elastic.co/docs/api/doc/elasticsearch#TODO>`_
+
+        :param name: The comma-separated view names to retrieve.
+        """
+        __path_parts: t.Dict[str, str]
+        if name not in SKIP_IN_PATH:
+            __path_parts = {"name": _quote(name)}
+            __path = f'/_query/view/{__path_parts["name"]}'
+        else:
+            __path_parts = {}
+            __path = "/_query/view"
+        __query: t.Dict[str, t.Any] = {}
+        if error_trace is not None:
+            __query["error_trace"] = error_trace
+        if filter_path is not None:
+            __query["filter_path"] = filter_path
+        if human is not None:
+            __query["human"] = human
+        if pretty is not None:
+            __query["pretty"] = pretty
+        __headers = {"accept": "application/json"}
+        return self.perform_request(  # type: ignore[return-value]
+            "GET",
+            __path,
+            params=__query,
+            headers=__headers,
+            endpoint_id="esql.get_view",
+            path_parts=__path_parts,
+        )
+
     @_rewrite_parameters()
     @_availability_warning(Stability.EXPERIMENTAL)
     def list_queries(
@@ -488,6 +581,62 @@ class EsqlClient(NamespacedClient):
             path_parts=__path_parts,
         )
 
+    @_rewrite_parameters(
+        body_fields=("query",),
+    )
+    @_availability_warning(Stability.EXPERIMENTAL)
+    def put_view(
+        self,
+        *,
+        name: str,
+        query: t.Optional[t.Union[str, "ESQLBase"]] = None,
+        error_trace: t.Optional[bool] = None,
+        filter_path: t.Optional[t.Union[str, t.Sequence[str]]] = None,
+        human: t.Optional[bool] = None,
+        pretty: t.Optional[bool] = None,
+        body: t.Optional[t.Dict[str, t.Any]] = None,
+    ) -> ObjectApiResponse[t.Any]:
+        """
+        .. raw:: html
+
+          <p>Create or update an ES|QL view.</p>
+
+
+        `<https://www.elastic.co/docs/api/doc/elasticsearch#TODO>`_
+
+        :param name: The view name to create or update.
+        :param query: The ES|QL query string from which to create a view.
+        """
+        if name in SKIP_IN_PATH:
+            raise ValueError("Empty value passed for parameter 'name'")
+        if query is None and body is None:
+            raise ValueError("Empty value passed for parameter 'query'")
+        __path_parts: t.Dict[str, str] = {"name": _quote(name)}
+        __path = f'/_query/view/{__path_parts["name"]}'
+        __query: t.Dict[str, t.Any] = {}
+        __body: t.Dict[str, t.Any] = body if body is not None else {}
+        if error_trace is not None:
+            __query["error_trace"] = error_trace
+        if filter_path is not None:
+            __query["filter_path"] = filter_path
+        if human is not None:
+            __query["human"] = human
+        if pretty is not None:
+            __query["pretty"] = pretty
+        if not __body:
+            if query is not None:
+                __body["query"] = str(query)
+        __headers = {"accept": "application/json", "content-type": "application/json"}
+        return self.perform_request(  # type: ignore[return-value]
+            "PUT",
+            __path,
+            params=__query,
+            headers=__headers,
+            body=__body,
+            endpoint_id="esql.put_view",
+            path_parts=__path_parts,
+        )
+
     @_rewrite_parameters(
         body_fields=(
             "query",
@@ -575,10 +724,10 @@ class EsqlClient(NamespacedClient):
             query, the response will include an extra `_clusters` object with information
             about the clusters that participated in the search along with info such as
             shards count.
-        :param include_execution_metadata: When set to `true` and performing a cross-cluster/cross-project
-            query, the response will include an extra `_clusters` object with information
-            about the clusters that participated in the search along with info such as
-            shards count.
+        :param include_execution_metadata: When set to `true`, the response will include
+            an extra `_clusters` object with information about the clusters that participated
+            in the search along with info such as shards count. This is similar to `include_ccs_metadata`,
+            but it also returns metadata when the query is not CCS/CPS
         :param locale:
         :param params: To avoid any attempts of hacking or code injection, extract the
             values in a separate list of parameters. Use question mark placeholders (?)

elasticsearch9/_sync/client/fleet.py

@@ -345,7 +345,7 @@ class FleetClient(NamespacedClient):
             t.Union[t.Mapping[str, t.Any], t.Sequence[t.Mapping[str, t.Any]]]
         ] = None,
         rest_total_hits_as_int: t.Optional[bool] = None,
-        routing: t.Optional[str] = None,
+        routing: t.Optional[t.Union[str, t.Sequence[str]]] = None,
         runtime_mappings: t.Optional[t.Mapping[str, t.Mapping[str, t.Any]]] = None,
         script_fields: t.Optional[t.Mapping[str, t.Mapping[str, t.Any]]] = None,
         scroll: t.Optional[t.Union[str, t.Literal[-1], t.Literal[0]]] = None,

elasticsearch9/_sync/client/graph.py

@@ -39,7 +39,7 @@ class GraphClient(NamespacedClient):
         human: t.Optional[bool] = None,
         pretty: t.Optional[bool] = None,
         query: t.Optional[t.Mapping[str, t.Any]] = None,
-        routing: t.Optional[str] = None,
+        routing: t.Optional[t.Union[str, t.Sequence[str]]] = None,
         timeout: t.Optional[t.Union[str, t.Literal[-1], t.Literal[0]]] = None,
         vertices: t.Optional[t.Sequence[t.Mapping[str, t.Any]]] = None,
         body: t.Optional[t.Dict[str, t.Any]] = None,