From 7f19262acd712b356710898ecd89fb2d1c161c50 Mon Sep 17 00:00:00 2001 From: Elastic Machine Date: Fri, 5 Apr 2024 06:06:07 +0000 Subject: [PATCH] Auto-generated API code --- elasticsearch/_async/client/__init__.py | 21 +++++++++++++++++++++ elasticsearch/_async/client/security.py | 5 +++++ elasticsearch/_sync/client/__init__.py | 21 +++++++++++++++++++++ elasticsearch/_sync/client/security.py | 5 +++++ 4 files changed, 52 insertions(+) diff --git a/elasticsearch/_async/client/__init__.py b/elasticsearch/_async/client/__init__.py index 01bfa04fd..65398a9db 100644 --- a/elasticsearch/_async/client/__init__.py +++ b/elasticsearch/_async/client/__init__.py @@ -1936,6 +1936,7 @@ async def get( id: str, error_trace: t.Optional[bool] = None, filter_path: t.Optional[t.Union[str, t.Sequence[str]]] = None, + force_synthetic_source: t.Optional[bool] = None, human: t.Optional[bool] = None, preference: t.Optional[str] = None, pretty: t.Optional[bool] = None, @@ -1958,6 +1959,10 @@ async def get( :param index: Name of the index that contains the document. :param id: Unique identifier of the document. + :param force_synthetic_source: Should this request force synthetic _source? Use + this to test if the mapping supports synthetic _source and to get a sense + of the worst case performance. Fetches with this enabled will be slower the + enabling synthetic source natively in the index. :param preference: Specifies the node or shard the operation should be performed on. Random by default. :param realtime: If `true`, the request is real-time as opposed to near-real-time. @@ -1989,6 +1994,8 @@ async def get( __query["error_trace"] = error_trace if filter_path is not None: __query["filter_path"] = filter_path + if force_synthetic_source is not None: + __query["force_synthetic_source"] = force_synthetic_source if human is not None: __query["human"] = human if preference is not None: @@ -2578,6 +2585,7 @@ async def mget( docs: t.Optional[t.Sequence[t.Mapping[str, t.Any]]] = None, error_trace: t.Optional[bool] = None, filter_path: t.Optional[t.Union[str, t.Sequence[str]]] = None, + force_synthetic_source: t.Optional[bool] = None, human: t.Optional[bool] = None, ids: t.Optional[t.Union[str, t.Sequence[str]]] = None, preference: t.Optional[str] = None, @@ -2600,6 +2608,10 @@ async def mget( or when a document in the `docs` array does not specify an index. :param docs: The documents you want to retrieve. Required if no index is specified in the request URI. + :param force_synthetic_source: Should this request force synthetic _source? Use + this to test if the mapping supports synthetic _source and to get a sense + of the worst case performance. Fetches with this enabled will be slower the + enabling synthetic source natively in the index. :param ids: The IDs of the documents you want to retrieve. Allowed when the index is specified in the request URI. :param preference: Specifies the node or shard the operation should be performed @@ -2634,6 +2646,8 @@ async def mget( __query["error_trace"] = error_trace if filter_path is not None: __query["filter_path"] = filter_path + if force_synthetic_source is not None: + __query["force_synthetic_source"] = force_synthetic_source if human is not None: __query["human"] = human if preference is not None: @@ -3677,6 +3691,7 @@ async def search( ext: t.Optional[t.Mapping[str, t.Any]] = None, fields: t.Optional[t.Sequence[t.Mapping[str, t.Any]]] = None, filter_path: t.Optional[t.Union[str, t.Sequence[str]]] = None, + force_synthetic_source: t.Optional[bool] = None, from_: t.Optional[int] = None, highlight: t.Optional[t.Mapping[str, t.Any]] = None, human: t.Optional[bool] = None, @@ -3793,6 +3808,10 @@ async def search( :param fields: Array of wildcard (`*`) patterns. The request returns values for field names matching these patterns in the `hits.fields` property of the response. + :param force_synthetic_source: Should this request force synthetic _source? Use + this to test if the mapping supports synthetic _source and to get a sense + of the worst case performance. Fetches with this enabled will be slower the + enabling synthetic source natively in the index. :param from_: Starting document offset. Needs to be non-negative. By default, you cannot page through more than 10,000 hits using the `from` and `size` parameters. To page through more hits, use the `search_after` parameter. @@ -3972,6 +3991,8 @@ async def search( __query["expand_wildcards"] = expand_wildcards if filter_path is not None: __query["filter_path"] = filter_path + if force_synthetic_source is not None: + __query["force_synthetic_source"] = force_synthetic_source if human is not None: __query["human"] = human if ignore_throttled is not None: diff --git a/elasticsearch/_async/client/security.py b/elasticsearch/_async/client/security.py index 0a30d376b..350a73524 100644 --- a/elasticsearch/_async/client/security.py +++ b/elasticsearch/_async/client/security.py @@ -2375,6 +2375,7 @@ async def query_api_keys( t.Union[str, t.Mapping[str, t.Any]], ] ] = None, + typed_keys: t.Optional[bool] = None, with_limited_by: t.Optional[bool] = None, body: t.Optional[t.Dict[str, t.Any]] = None, ) -> ObjectApiResponse[t.Any]: @@ -2412,6 +2413,8 @@ async def query_api_keys( :param sort: Other than `id`, all public fields of an API key are eligible for sorting. In addition, sort can also be applied to the `_doc` field to sort by index order. + :param typed_keys: Determines whether aggregation names are prefixed by their + respective types in the response. :param with_limited_by: Return the snapshot of the owner user's role descriptors associated with the API key. An API key's actual permission is the intersection of its assigned role descriptors and the owner user's role descriptors. @@ -2439,6 +2442,8 @@ async def query_api_keys( __query["human"] = human if pretty is not None: __query["pretty"] = pretty + if typed_keys is not None: + __query["typed_keys"] = typed_keys if with_limited_by is not None: __query["with_limited_by"] = with_limited_by if not __body: diff --git a/elasticsearch/_sync/client/__init__.py b/elasticsearch/_sync/client/__init__.py index 457853455..42f2381a1 100644 --- a/elasticsearch/_sync/client/__init__.py +++ b/elasticsearch/_sync/client/__init__.py @@ -1934,6 +1934,7 @@ def get( id: str, error_trace: t.Optional[bool] = None, filter_path: t.Optional[t.Union[str, t.Sequence[str]]] = None, + force_synthetic_source: t.Optional[bool] = None, human: t.Optional[bool] = None, preference: t.Optional[str] = None, pretty: t.Optional[bool] = None, @@ -1956,6 +1957,10 @@ def get( :param index: Name of the index that contains the document. :param id: Unique identifier of the document. + :param force_synthetic_source: Should this request force synthetic _source? Use + this to test if the mapping supports synthetic _source and to get a sense + of the worst case performance. Fetches with this enabled will be slower the + enabling synthetic source natively in the index. :param preference: Specifies the node or shard the operation should be performed on. Random by default. :param realtime: If `true`, the request is real-time as opposed to near-real-time. @@ -1987,6 +1992,8 @@ def get( __query["error_trace"] = error_trace if filter_path is not None: __query["filter_path"] = filter_path + if force_synthetic_source is not None: + __query["force_synthetic_source"] = force_synthetic_source if human is not None: __query["human"] = human if preference is not None: @@ -2576,6 +2583,7 @@ def mget( docs: t.Optional[t.Sequence[t.Mapping[str, t.Any]]] = None, error_trace: t.Optional[bool] = None, filter_path: t.Optional[t.Union[str, t.Sequence[str]]] = None, + force_synthetic_source: t.Optional[bool] = None, human: t.Optional[bool] = None, ids: t.Optional[t.Union[str, t.Sequence[str]]] = None, preference: t.Optional[str] = None, @@ -2598,6 +2606,10 @@ def mget( or when a document in the `docs` array does not specify an index. :param docs: The documents you want to retrieve. Required if no index is specified in the request URI. + :param force_synthetic_source: Should this request force synthetic _source? Use + this to test if the mapping supports synthetic _source and to get a sense + of the worst case performance. Fetches with this enabled will be slower the + enabling synthetic source natively in the index. :param ids: The IDs of the documents you want to retrieve. Allowed when the index is specified in the request URI. :param preference: Specifies the node or shard the operation should be performed @@ -2632,6 +2644,8 @@ def mget( __query["error_trace"] = error_trace if filter_path is not None: __query["filter_path"] = filter_path + if force_synthetic_source is not None: + __query["force_synthetic_source"] = force_synthetic_source if human is not None: __query["human"] = human if preference is not None: @@ -3675,6 +3689,7 @@ def search( ext: t.Optional[t.Mapping[str, t.Any]] = None, fields: t.Optional[t.Sequence[t.Mapping[str, t.Any]]] = None, filter_path: t.Optional[t.Union[str, t.Sequence[str]]] = None, + force_synthetic_source: t.Optional[bool] = None, from_: t.Optional[int] = None, highlight: t.Optional[t.Mapping[str, t.Any]] = None, human: t.Optional[bool] = None, @@ -3791,6 +3806,10 @@ def search( :param fields: Array of wildcard (`*`) patterns. The request returns values for field names matching these patterns in the `hits.fields` property of the response. + :param force_synthetic_source: Should this request force synthetic _source? Use + this to test if the mapping supports synthetic _source and to get a sense + of the worst case performance. Fetches with this enabled will be slower the + enabling synthetic source natively in the index. :param from_: Starting document offset. Needs to be non-negative. By default, you cannot page through more than 10,000 hits using the `from` and `size` parameters. To page through more hits, use the `search_after` parameter. @@ -3970,6 +3989,8 @@ def search( __query["expand_wildcards"] = expand_wildcards if filter_path is not None: __query["filter_path"] = filter_path + if force_synthetic_source is not None: + __query["force_synthetic_source"] = force_synthetic_source if human is not None: __query["human"] = human if ignore_throttled is not None: diff --git a/elasticsearch/_sync/client/security.py b/elasticsearch/_sync/client/security.py index 958b0fa36..b88e5645a 100644 --- a/elasticsearch/_sync/client/security.py +++ b/elasticsearch/_sync/client/security.py @@ -2375,6 +2375,7 @@ def query_api_keys( t.Union[str, t.Mapping[str, t.Any]], ] ] = None, + typed_keys: t.Optional[bool] = None, with_limited_by: t.Optional[bool] = None, body: t.Optional[t.Dict[str, t.Any]] = None, ) -> ObjectApiResponse[t.Any]: @@ -2412,6 +2413,8 @@ def query_api_keys( :param sort: Other than `id`, all public fields of an API key are eligible for sorting. In addition, sort can also be applied to the `_doc` field to sort by index order. + :param typed_keys: Determines whether aggregation names are prefixed by their + respective types in the response. :param with_limited_by: Return the snapshot of the owner user's role descriptors associated with the API key. An API key's actual permission is the intersection of its assigned role descriptors and the owner user's role descriptors. @@ -2439,6 +2442,8 @@ def query_api_keys( __query["human"] = human if pretty is not None: __query["pretty"] = pretty + if typed_keys is not None: + __query["typed_keys"] = typed_keys if with_limited_by is not None: __query["with_limited_by"] = with_limited_by if not __body: