elasticsearch/dsl/types.py

# Licensed to Elasticsearch B.V. under one or more contributor # license agreements. See the NOTICE file distributed with # this work for additional information regarding copyright # ownership. Elasticsearch B.V. licenses this file to you under # the Apache License, Version 2.0 (the "License"); you may # not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, # software distributed under the License is distributed on an # "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY # KIND, either express or implied. See the License for the # specific language governing permissions and limitations # under the License. from typing import Any, Dict, Literal, Mapping, Sequence, Union from elastic_transport.client_utils import DEFAULT, DefaultType from . import Query from .document_base import InstrumentedField from .utils import AttrDict PipeSeparatedFlags = str class BucketCorrelationFunction(AttrDict[Any]): """ :arg count_correlation: (required) The configuration to calculate a count correlation. This function is designed for determining the correlation of a term value and a given metric. """ count_correlation: Union[ "BucketCorrelationFunctionCountCorrelation", Dict[str, Any], DefaultType ] def __init__( self, *, count_correlation: Union[ "BucketCorrelationFunctionCountCorrelation", Dict[str, Any], DefaultType ] = DEFAULT, **kwargs: Any, ): if count_correlation is not DEFAULT: kwargs["count_correlation"] = count_correlation super().__init__(kwargs) class BucketCorrelationFunctionCountCorrelation(AttrDict[Any]): """ :arg indicator: (required) The indicator with which to correlate the configured `bucket_path` values. """ indicator: Union[ "BucketCorrelationFunctionCountCorrelationIndicator", Dict[str, Any], DefaultType, ] def __init__( self, *, indicator: Union[ "BucketCorrelationFunctionCountCorrelationIndicator", Dict[str, Any], DefaultType, ] = DEFAULT, **kwargs: Any, ): if indicator is not DEFAULT: kwargs["indicator"] = indicator super().__init__(kwargs) class BucketCorrelationFunctionCountCorrelationIndicator(AttrDict[Any]): """ :arg doc_count: (required) The total number of documents that initially created the expectations. It’s required to be greater than or equal to the sum of all values in the buckets_path as this is the originating superset of data to which the term values are correlated. :arg expectations: (required) An array of numbers with which to correlate the configured `bucket_path` values. The length of this value must always equal the number of buckets returned by the `bucket_path`. :arg fractions: An array of fractions to use when averaging and calculating variance. This should be used if the pre-calculated data and the buckets_path have known gaps. The length of fractions, if provided, must equal expectations. """ doc_count: Union[int, DefaultType] expectations: Union[Sequence[float], DefaultType] fractions: Union[Sequence[float], DefaultType] def __init__( self, *, doc_count: Union[int, DefaultType] = DEFAULT, expectations: Union[Sequence[float], DefaultType] = DEFAULT, fractions: Union[Sequence[float], DefaultType] = DEFAULT, **kwargs: Any, ): if doc_count is not DEFAULT: kwargs["doc_count"] = doc_count if expectations is not DEFAULT: kwargs["expectations"] = expectations if fractions is not DEFAULT: kwargs["fractions"] = fractions super().__init__(kwargs) class ChiSquareHeuristic(AttrDict[Any]): """ :arg background_is_superset: (required) Set to `false` if you defined a custom background filter that represents a different set of documents that you want to compare to. :arg include_negatives: (required) Set to `false` to filter out the terms that appear less often in the subset than in documents outside the subset. """ background_is_superset: Union[bool, DefaultType] include_negatives: Union[bool, DefaultType] def __init__( self, *, background_is_superset: Union[bool, DefaultType] = DEFAULT, include_negatives: Union[bool, DefaultType] = DEFAULT, **kwargs: Any, ): if background_is_superset is not DEFAULT: kwargs["background_is_superset"] = background_is_superset if include_negatives is not DEFAULT: kwargs["include_negatives"] = include_negatives super().__init__(kwargs) class ClassificationInferenceOptions(AttrDict[Any]): """ :arg num_top_classes: Specifies the number of top class predictions to return. Defaults to 0. :arg num_top_feature_importance_values: Specifies the maximum number of feature importance values per document. :arg prediction_field_type: Specifies the type of the predicted field to write. Acceptable values are: string, number, boolean. When boolean is provided 1.0 is transformed to true and 0.0 to false. :arg results_field: The field that is added to incoming documents to contain the inference prediction. Defaults to predicted_value. :arg top_classes_results_field: Specifies the field to which the top classes are written. Defaults to top_classes. """ num_top_classes: Union[int, DefaultType] num_top_feature_importance_values: Union[int, DefaultType] prediction_field_type: Union[str, DefaultType] results_field: Union[str, DefaultType] top_classes_results_field: Union[str, DefaultType] def __init__( self, *, num_top_classes: Union[int, DefaultType] = DEFAULT, num_top_feature_importance_values: Union[int, DefaultType] = DEFAULT, prediction_field_type: Union[str, DefaultType] = DEFAULT, results_field: Union[str, DefaultType] = DEFAULT, top_classes_results_field: Union[str, DefaultType] = DEFAULT, **kwargs: Any, ): if num_top_classes is not DEFAULT: kwargs["num_top_classes"] = num_top_classes if num_top_feature_importance_values is not DEFAULT: kwargs["num_top_feature_importance_values"] = ( num_top_feature_importance_values ) if prediction_field_type is not DEFAULT: kwargs["prediction_field_type"] = prediction_field_type if results_field is not DEFAULT: kwargs["results_field"] = results_field if top_classes_results_field is not DEFAULT: kwargs["top_classes_results_field"] = top_classes_results_field super().__init__(kwargs) class CommonTermsQuery(AttrDict[Any]): """ :arg query: (required) :arg analyzer: :arg cutoff_frequency: :arg high_freq_operator: :arg low_freq_operator: :arg minimum_should_match: :arg boost: Floating point number used to decrease or increase the relevance scores of the query. Boost values are relative to the default value of 1.0. A boost value between 0 and 1.0 decreases the relevance score. A value greater than 1.0 increases the relevance score. Defaults to `1` if omitted. :arg _name: """ query: Union[str, DefaultType] analyzer: Union[str, DefaultType] cutoff_frequency: Union[float, DefaultType] high_freq_operator: Union[Literal["and", "or"], DefaultType] low_freq_operator: Union[Literal["and", "or"], DefaultType] minimum_should_match: Union[int, str, DefaultType] boost: Union[float, DefaultType] _name: Union[str, DefaultType] def __init__( self, *, query: Union[str, DefaultType] = DEFAULT, analyzer: Union[str, DefaultType] = DEFAULT, cutoff_frequency: Union[float, DefaultType] = DEFAULT, high_freq_operator: Union[Literal["and", "or"], DefaultType] = DEFAULT, low_freq_operator: Union[Literal["and", "or"], DefaultType] = DEFAULT, minimum_should_match: Union[int, str, DefaultType] = DEFAULT, boost: Union[float, DefaultType] = DEFAULT, _name: Union[str, DefaultType] = DEFAULT, **kwargs: Any, ): if query is not DEFAULT: kwargs["query"] = query if analyzer is not DEFAULT: kwargs["analyzer"] = analyzer if cutoff_frequency is not DEFAULT: kwargs["cutoff_frequency"] = cutoff_frequency if high_freq_operator is not DEFAULT: kwargs["high_freq_operator"] = high_freq_operator if low_freq_operator is not DEFAULT: kwargs["low_freq_operator"] = low_freq_operator if minimum_should_match is not DEFAULT: kwargs["minimum_should_match"] = minimum_should_match if boost is not DEFAULT: kwargs["boost"] = boost if _name is not DEFAULT: kwargs["_name"] = _name super().__init__(kwargs) class CoordsGeoBounds(AttrDict[Any]): """ :arg top: (required) :arg bottom: (required) :arg left: (required) :arg right: (required) """ top: Union[float, DefaultType] bottom: Union[float, DefaultType] left: Union[float, DefaultType] right: Union[float, DefaultType] def __init__( self, *, top: Union[float, DefaultType] = DEFAULT, bottom: Union[float, DefaultType] = DEFAULT, left: Union[float, DefaultType] = DEFAULT, right: Union[float, DefaultType] = DEFAULT, **kwargs: Any, ): if top is not DEFAULT: kwargs["top"] = top if bottom is not DEFAULT: kwargs["bottom"] = bottom if left is not DEFAULT: kwargs["left"] = left if right is not DEFAULT: kwargs["right"] = right super().__init__(kwargs) class CustomCategorizeTextAnalyzer(AttrDict[Any]): """ :arg char_filter: :arg tokenizer: :arg filter: """ char_filter: Union[Sequence[str], DefaultType] tokenizer: Union[str, DefaultType] filter: Union[Sequence[str], DefaultType] def __init__( self, *, char_filter: Union[Sequence[str], DefaultType] = DEFAULT, tokenizer: Union[str, DefaultType] = DEFAULT, filter: Union[Sequence[str], DefaultType] = DEFAULT, **kwargs: Any, ): if char_filter is not DEFAULT: kwargs["char_filter"] = char_filter if tokenizer is not DEFAULT: kwargs["tokenizer"] = tokenizer if filter is not DEFAULT: kwargs["filter"] = filter super().__init__(kwargs) class DenseVectorIndexOptions(AttrDict[Any]): """ :arg type: (required) The type of kNN algorithm to use. :arg confidence_interval: The confidence interval to use when quantizing the vectors. Can be any value between and including `0.90` and `1.0` or exactly `0`. When the value is `0`, this indicates that dynamic quantiles should be calculated for optimized quantization. When between `0.90` and `1.0`, this value restricts the values used when calculating the quantization thresholds. For example, a value of `0.95` will only use the middle `95%` of the values when calculating the quantization thresholds (e.g. the highest and lowest `2.5%` of values will be ignored). Defaults to `1/(dims + 1)` for `int8` quantized vectors and `0` for `int4` for dynamic quantile calculation. Only applicable to `int8_hnsw`, `int4_hnsw`, `int8_flat`, and `int4_flat` index types. :arg ef_construction: The number of candidates to track while assembling the list of nearest neighbors for each new node. Only applicable to `hnsw`, `int8_hnsw`, `bbq_hnsw`, and `int4_hnsw` index types. Defaults to `100` if omitted. :arg m: The number of neighbors each node will be connected to in the HNSW graph. Only applicable to `hnsw`, `int8_hnsw`, `bbq_hnsw`, and `int4_hnsw` index types. Defaults to `16` if omitted. :arg rescore_vector: The rescore vector options. This is only applicable to `bbq_hnsw`, `int4_hnsw`, `int8_hnsw`, `bbq_flat`, `int4_flat`, and `int8_flat` index types. """ type: Union[ Literal[ "bbq_flat", "bbq_hnsw", "flat", "hnsw", "int4_flat", "int4_hnsw", "int8_flat", "int8_hnsw", ], DefaultType, ] confidence_interval: Union[float, DefaultType] ef_construction: Union[int, DefaultType] m: Union[int, DefaultType] rescore_vector: Union[ "DenseVectorIndexOptionsRescoreVector", Dict[str, Any], DefaultType ] def __init__( self, *, type: Union[ Literal[ "bbq_flat", "bbq_hnsw", "flat", "hnsw", "int4_flat", "int4_hnsw", "int8_flat", "int8_hnsw", ], DefaultType, ] = DEFAULT, confidence_interval: Union[float, DefaultType] = DEFAULT, ef_construction: Union[int, DefaultType] = DEFAULT, m: Union[int, DefaultType] = DEFAULT, rescore_vector: Union[ "DenseVectorIndexOptionsRescoreVector", Dict[str, Any], DefaultType ] = DEFAULT, **kwargs: Any, ): if type is not DEFAULT: kwargs["type"] = type if confidence_interval is not DEFAULT: kwargs["confidence_interval"] = confidence_interval if ef_construction is not DEFAULT: kwargs["ef_construction"] = ef_construction if m is not DEFAULT: kwargs["m"] = m if rescore_vector is not DEFAULT: kwargs["rescore_vector"] = rescore_vector super().__init__(kwargs) class DenseVectorIndexOptionsRescoreVector(AttrDict[Any]): """ :arg oversample: (required) The oversampling factor to use when searching for the nearest neighbor. This is only applicable to the quantized formats: `bbq_*`, `int4_*`, and `int8_*`. When provided, `oversample * k` vectors will be gathered and then their scores will be re-computed with the original vectors. valid values are between `1.0` and `10.0` (inclusive), or `0` exactly to disable oversampling. """ oversample: Union[float, DefaultType] def __init__( self, *, oversample: Union[float, DefaultType] = DEFAULT, **kwargs: Any ): if oversample is not DEFAULT: kwargs["oversample"] = oversample super().__init__(kwargs) class EmptyObject(AttrDict[Any]): """ For empty Class assignments """ def __init__(self, **kwargs: Any): super().__init__(kwargs) class EwmaModelSettings(AttrDict[Any]): """ :arg alpha: """ alpha: Union[float, DefaultType] def __init__(self, *, alpha: Union[float, DefaultType] = DEFAULT, **kwargs: Any): if alpha is not DEFAULT: kwargs["alpha"] = alpha super().__init__(kwargs) class ExtendedBounds(AttrDict[Any]): """ :arg max: Maximum value for the bound. :arg min: Minimum value for the bound. """ max: Any min: Any def __init__(self, *, max: Any = DEFAULT, min: Any = DEFAULT, **kwargs: Any): if max is not DEFAULT: kwargs["max"] = max if min is not DEFAULT: kwargs["min"] = min super().__init__(kwargs) class FieldAndFormat(AttrDict[Any]): """ A reference to a field with formatting instructions on how to return the value :arg field: (required) A wildcard pattern. The request returns values for field names matching this pattern. :arg format: The format in which the values are returned. :arg include_unmapped: """ field: Union[str, InstrumentedField, DefaultType] format: Union[str, DefaultType] include_unmapped: Union[bool, DefaultType] def __init__( self, *, field: Union[str, InstrumentedField, DefaultType] = DEFAULT, format: Union[str, DefaultType] = DEFAULT, include_unmapped: Union[bool, DefaultType] = DEFAULT, **kwargs: Any, ): if field is not DEFAULT: kwargs["field"] = str(field) if format is not DEFAULT: kwargs["format"] = format if include_unmapped is not DEFAULT: kwargs["include_unmapped"] = include_unmapped super().__init__(kwargs) class FieldCollapse(AttrDict[Any]): """ :arg field: (required) The field to collapse the result set on :arg inner_hits: The number of inner hits and their sort order :arg max_concurrent_group_searches: The number of concurrent requests allowed to retrieve the inner_hits per group :arg collapse: """ field: Union[str, InstrumentedField, DefaultType] inner_hits: Union[ "InnerHits", Sequence["InnerHits"], Sequence[Dict[str, Any]], DefaultType ] max_concurrent_group_searches: Union[int, DefaultType] collapse: Union["FieldCollapse", Dict[str, Any], DefaultType] def __init__( self, *, field: Union[str, InstrumentedField, DefaultType] = DEFAULT, inner_hits: Union[ "InnerHits", Sequence["InnerHits"], Sequence[Dict[str, Any]], DefaultType ] = DEFAULT, max_concurrent_group_searches: Union[int, DefaultType] = DEFAULT, collapse: Union["FieldCollapse", Dict[str, Any], DefaultType] = DEFAULT, **kwargs: Any, ): if field is not DEFAULT: kwargs["field"] = str(field) if inner_hits is not DEFAULT: kwargs["inner_hits"] = inner_hits if max_concurrent_group_searches is not DEFAULT: kwargs["max_concurrent_group_searches"] = max_concurrent_group_searches if collapse is not DEFAULT: kwargs["collapse"] = collapse super().__init__(kwargs) class FieldLookup(AttrDict[Any]): """ :arg id: (required) `id` of the document. :arg index: Index from which to retrieve the document. :arg path: Name of the field. :arg routing: Custom routing value. """ id: Union[str, DefaultType] index: Union[str, DefaultType] path: Union[str, InstrumentedField, DefaultType] routing: Union[str, DefaultType] def __init__( self, *, id: Union[str, DefaultType] = DEFAULT, index: Union[str, DefaultType] = DEFAULT, path: Union[str, InstrumentedField, DefaultType] = DEFAULT, routing: Union[str, DefaultType] = DEFAULT, **kwargs: Any, ): if id is not DEFAULT: kwargs["id"] = id if index is not DEFAULT: kwargs["index"] = index if path is not DEFAULT: kwargs["path"] = str(path) if routing is not DEFAULT: kwargs["routing"] = routing super().__init__(kwargs) class FieldSort(AttrDict[Any]): """ :arg missing: :arg mode: :arg nested: :arg order: :arg unmapped_type: :arg numeric_type: :arg format: """ missing: Union[str, int, float, bool, DefaultType] mode: Union[Literal["min", "max", "sum", "avg", "median"], DefaultType] nested: Union["NestedSortValue", Dict[str, Any], DefaultType] order: Union[Literal["asc", "desc"], DefaultType] unmapped_type: Union[ Literal[ "none", "geo_point", "geo_shape", "ip", "binary", "keyword", "text", "search_as_you_type", "date", "date_nanos", "boolean", "completion", "nested", "object", "passthrough", "version", "murmur3", "token_count", "percolator", "integer", "long", "short", "byte", "float", "half_float", "scaled_float", "double", "integer_range", "float_range", "long_range", "double_range", "date_range", "ip_range", "alias", "join", "rank_feature", "rank_features", "flattened", "shape", "histogram", "constant_keyword", "counted_keyword", "aggregate_metric_double", "dense_vector", "semantic_text", "sparse_vector", "match_only_text", "icu_collation_keyword", ], DefaultType, ] numeric_type: Union[Literal["long", "double", "date", "date_nanos"], DefaultType] format: Union[str, DefaultType] def __init__( self, *, missing: Union[str, int, float, bool, DefaultType] = DEFAULT, mode: Union[ Literal["min", "max", "sum", "avg", "median"], DefaultType ] = DEFAULT, nested: Union["NestedSortValue", Dict[str, Any], DefaultType] = DEFAULT, order: Union[Literal["asc", "desc"], DefaultType] = DEFAULT, unmapped_type: Union[ Literal[ "none", "geo_point", "geo_shape", "ip", "binary", "keyword", "text", "search_as_you_type", "date", "date_nanos", "boolean", "completion", "nested", "object", "passthrough", "version", "murmur3", "token_count", "percolator", "integer", "long", "short", "byte", "float", "half_float", "scaled_float", "double", "integer_range", "float_range", "long_range", "double_range", "date_range", "ip_range", "alias", "join", "rank_feature", "rank_features", "flattened", "shape", "histogram", "constant_keyword", "counted_keyword", "aggregate_metric_double", "dense_vector", "semantic_text", "sparse_vector", "match_only_text", "icu_collation_keyword", ], DefaultType, ] = DEFAULT, numeric_type: Union[ Literal["long", "double", "date", "date_nanos"], DefaultType ] = DEFAULT, format: Union[str, DefaultType] = DEFAULT, **kwargs: Any, ): if missing is not DEFAULT: kwargs["missing"] = missing if mode is not DEFAULT: kwargs["mode"] = mode if nested is not DEFAULT: kwargs["nested"] = nested if order is not DEFAULT: kwargs["order"] = order if unmapped_type is not DEFAULT: kwargs["unmapped_type"] = unmapped_type if numeric_type is not DEFAULT: kwargs["numeric_type"] = numeric_type if format is not DEFAULT: kwargs["format"] = format super().__init__(kwargs) class FielddataFrequencyFilter(AttrDict[Any]): """ :arg max: (required) :arg min: (required) :arg min_segment_size: (required) """ max: Union[float, DefaultType] min: Union[float, DefaultType] min_segment_size: Union[int, DefaultType] def __init__( self, *, max: Union[float, DefaultType] = DEFAULT, min: Union[float, DefaultType] = DEFAULT, min_segment_size: Union[int, DefaultType] = DEFAULT, **kwargs: Any, ): if max is not DEFAULT: kwargs["max"] = max if min is not DEFAULT: kwargs["min"] = min if min_segment_size is not DEFAULT: kwargs["min_segment_size"] = min_segment_size super().__init__(kwargs) class FrequentItemSetsField(AttrDict[Any]): """ :arg field: (required) :arg exclude: Values to exclude. Can be regular expression strings or arrays of strings of exact terms. :arg include: Values to include. Can be regular expression strings or arrays of strings of exact terms. """ field: Union[str, InstrumentedField, DefaultType] exclude: Union[str, Sequence[str], DefaultType] include: Union[str, Sequence[str], "TermsPartition", Dict[str, Any], DefaultType] def __init__( self, *, field: Union[str, InstrumentedField, DefaultType] = DEFAULT, exclude: Union[str, Sequence[str], DefaultType] = DEFAULT, include: Union[ str, Sequence[str], "TermsPartition", Dict[str, Any], DefaultType ] = DEFAULT, **kwargs: Any, ): if field is not DEFAULT: kwargs["field"] = str(field) if exclude is not DEFAULT: kwargs["exclude"] = exclude if include is not DEFAULT: kwargs["include"] = include super().__init__(kwargs) class FuzzyQuery(AttrDict[Any]): """ :arg value: (required) Term you wish to find in the provided field. :arg max_expansions: Maximum number of variations created. Defaults to `50` if omitted. :arg prefix_length: Number of beginning characters left unchanged when creating expansions. :arg rewrite: Number of beginning characters left unchanged when creating expansions. Defaults to `constant_score` if omitted. :arg transpositions: Indicates whether edits include transpositions of two adjacent characters (for example `ab` to `ba`). Defaults to `True` if omitted. :arg fuzziness: Maximum edit distance allowed for matching. :arg boost: Floating point number used to decrease or increase the relevance scores of the query. Boost values are relative to the default value of 1.0. A boost value between 0 and 1.0 decreases the relevance score. A value greater than 1.0 increases the relevance score. Defaults to `1` if omitted. :arg _name: """ value: Union[str, float, bool, DefaultType] max_expansions: Union[int, DefaultType] prefix_length: Union[int, DefaultType] rewrite: Union[str, DefaultType] transpositions: Union[bool, DefaultType] fuzziness: Union[str, int, DefaultType] boost: Union[float, DefaultType] _name: Union[str, DefaultType] def __init__( self, *, value: Union[str, float, bool, DefaultType] = DEFAULT, max_expansions: Union[int, DefaultType] = DEFAULT, prefix_length: Union[int, DefaultType] = DEFAULT, rewrite: Union[str, DefaultType] = DEFAULT, transpositions: Union[bool, DefaultType] = DEFAULT, fuzziness: Union[str, int, DefaultType] = DEFAULT, boost: Union[float, DefaultType] = DEFAULT, _name: Union[str, DefaultType] = DEFAULT, **kwargs: Any, ): if value is not DEFAULT: kwargs["value"] = value if max_expansions is not DEFAULT: kwargs["max_expansions"] = max_expansions if prefix_length is not DEFAULT: kwargs["prefix_length"] = prefix_length if rewrite is not DEFAULT: kwargs["rewrite"] = rewrite if transpositions is not DEFAULT: kwargs["transpositions"] = transpositions if fuzziness is not DEFAULT: kwargs["fuzziness"] = fuzziness if boost is not DEFAULT: kwargs["boost"] = boost if _name is not DEFAULT: kwargs["_name"] = _name super().__init__(kwargs) class GeoDistanceSort(AttrDict[Any]): """ :arg _field: The field to use in this query. :arg _value: The query value for the field. :arg mode: :arg distance_type: :arg ignore_unmapped: :arg order: :arg unit: :arg nested: """ _field: Union[str, "InstrumentedField", "DefaultType"] _value: Union[ Union["LatLonGeoLocation", "GeoHashLocation", Sequence[float], str], Sequence[Union["LatLonGeoLocation", "GeoHashLocation", Sequence[float], str]], Dict[str, Any], "DefaultType", ] mode: Union[Literal["min", "max", "sum", "avg", "median"], DefaultType] distance_type: Union[Literal["arc", "plane"], DefaultType] ignore_unmapped: Union[bool, DefaultType] order: Union[Literal["asc", "desc"], DefaultType] unit: Union[ Literal["in", "ft", "yd", "mi", "nmi", "km", "m", "cm", "mm"], DefaultType ] nested: Union["NestedSortValue", Dict[str, Any], DefaultType] def __init__( self, _field: Union[str, "InstrumentedField", "DefaultType"] = DEFAULT, _value: Union[ Union["LatLonGeoLocation", "GeoHashLocation", Sequence[float], str], Sequence[ Union["LatLonGeoLocation", "GeoHashLocation", Sequence[float], str] ], Dict[str, Any], "DefaultType", ] = DEFAULT, *, mode: Union[ Literal["min", "max", "sum", "avg", "median"], DefaultType ] = DEFAULT, distance_type: Union[Literal["arc", "plane"], DefaultType] = DEFAULT, ignore_unmapped: Union[bool, DefaultType] = DEFAULT, order: Union[Literal["asc", "desc"], DefaultType] = DEFAULT, unit: Union[ Literal["in", "ft", "yd", "mi", "nmi", "km", "m", "cm", "mm"], DefaultType ] = DEFAULT, nested: Union["NestedSortValue", Dict[str, Any], DefaultType] = DEFAULT, **kwargs: Any, ): if _field is not DEFAULT: kwargs[str(_field)] = _value if mode is not DEFAULT: kwargs["mode"] = mode if distance_type is not DEFAULT: kwargs["distance_type"] = distance_type if ignore_unmapped is not DEFAULT: kwargs["ignore_unmapped"] = ignore_unmapped if order is not DEFAULT: kwargs["order"] = order if unit is not DEFAULT: kwargs["unit"] = unit if nested is not DEFAULT: kwargs["nested"] = nested super().__init__(kwargs) class GeoGridQuery(AttrDict[Any]): """ :arg geogrid: :arg geohash: :arg geohex: :arg boost: Floating point number used to decrease or increase the relevance scores of the query. Boost values are relative to the default value of 1.0. A boost value between 0 and 1.0 decreases the relevance score. A value greater than 1.0 increases the relevance score. Defaults to `1` if omitted. :arg _name: """ geogrid: Union[str, DefaultType] geohash: Union[str, DefaultType] geohex: Union[str, DefaultType] boost: Union[float, DefaultType] _name: Union[str, DefaultType] def __init__( self, *, geogrid: Union[str, DefaultType] = DEFAULT, geohash: Union[str, DefaultType] = DEFAULT, geohex: Union[str, DefaultType] = DEFAULT, boost: Union[float, DefaultType] = DEFAULT, _name: Union[str, DefaultType] = DEFAULT, **kwargs: Any, ): if geogrid is not DEFAULT: kwargs["geogrid"] = geogrid if geohash is not DEFAULT: kwargs["geohash"] = geohash if geohex is not DEFAULT: kwargs["geohex"] = geohex if boost is not DEFAULT: kwargs["boost"] = boost if _name is not DEFAULT: kwargs["_name"] = _name super().__init__(kwargs) class GeoHashLocation(AttrDict[Any]): """ :arg geohash: (required) """ geohash: Union[str, DefaultType] def __init__(self, *, geohash: Union[str, DefaultType] = DEFAULT, **kwargs: Any): if geohash is not DEFAULT: kwargs["geohash"] = geohash super().__init__(kwargs) class GeoLinePoint(AttrDict[Any]): """ :arg field: (required) The name of the geo_point field. """ field: Union[str, InstrumentedField, DefaultType] def __init__( self, *, field: Union[str, InstrumentedField, DefaultType] = DEFAULT, **kwargs: Any, ): if field is not DEFAULT: kwargs["field"] = str(field) super().__init__(kwargs) class GeoLineSort(AttrDict[Any]): """ :arg field: (required) The name of the numeric field to use as the sort key for ordering the points. """ field: Union[str, InstrumentedField, DefaultType] def __init__( self, *, field: Union[str, InstrumentedField, DefaultType] = DEFAULT, **kwargs: Any, ): if field is not DEFAULT: kwargs["field"] = str(field) super().__init__(kwargs) class GeoPolygonPoints(AttrDict[Any]): """ :arg points: (required) """ points: Union[ Sequence[Union["LatLonGeoLocation", "GeoHashLocation", Sequence[float], str]], Dict[str, Any], DefaultType, ] def __init__( self, *, points: Union[ Sequence[ Union["LatLonGeoLocation", "GeoHashLocation", Sequence[float], str] ], Dict[str, Any], DefaultType, ] = DEFAULT, **kwargs: Any, ): if points is not DEFAULT: kwargs["points"] = points super().__init__(kwargs) class GeoShapeFieldQuery(AttrDict[Any]): """ :arg shape: :arg indexed_shape: Query using an indexed shape retrieved from the the specified document and path. :arg relation: Spatial relation operator used to search a geo field. Defaults to `intersects` if omitted. """ shape: Any indexed_shape: Union["FieldLookup", Dict[str, Any], DefaultType] relation: Union[ Literal["intersects", "disjoint", "within", "contains"], DefaultType ] def __init__( self, *, shape: Any = DEFAULT, indexed_shape: Union["FieldLookup", Dict[str, Any], DefaultType] = DEFAULT, relation: Union[ Literal["intersects", "disjoint", "within", "contains"], DefaultType ] = DEFAULT, **kwargs: Any, ): if shape is not DEFAULT: kwargs["shape"] = shape if indexed_shape is not DEFAULT: kwargs["indexed_shape"] = indexed_shape if relation is not DEFAULT: kwargs["relation"] = relation super().__init__(kwargs) class GoogleNormalizedDistanceHeuristic(AttrDict[Any]): """ :arg background_is_superset: Set to `false` if you defined a custom background filter that represents a different set of documents that you want to compare to. """ background_is_superset: Union[bool, DefaultType] def __init__( self, *, background_is_superset: Union[bool, DefaultType] = DEFAULT, **kwargs: Any, ): if background_is_superset is not DEFAULT: kwargs["background_is_superset"] = background_is_superset super().__init__(kwargs) class HdrMethod(AttrDict[Any]): """ :arg number_of_significant_value_digits: Specifies the resolution of values for the histogram in number of significant digits. """ number_of_significant_value_digits: Union[int, DefaultType] def __init__( self, *, number_of_significant_value_digits: Union[int, DefaultType] = DEFAULT, **kwargs: Any, ): if number_of_significant_value_digits is not DEFAULT: kwargs["number_of_significant_value_digits"] = ( number_of_significant_value_digits ) super().__init__(kwargs) class Highlight(AttrDict[Any]): """ :arg fields: (required) :arg encoder: :arg type: :arg boundary_chars: A string that contains each boundary character. Defaults to `.,!? \t\n` if omitted. :arg boundary_max_scan: How far to scan for boundary characters. Defaults to `20` if omitted. :arg boundary_scanner: Specifies how to break the highlighted fragments: chars, sentence, or word. Only valid for the unified and fvh highlighters. Defaults to `sentence` for the `unified` highlighter. Defaults to `chars` for the `fvh` highlighter. :arg boundary_scanner_locale: Controls which locale is used to search for sentence and word boundaries. This parameter takes a form of a language tag, for example: `"en-US"`, `"fr-FR"`, `"ja-JP"`. Defaults to `Locale.ROOT` if omitted. :arg force_source: :arg fragmenter: Specifies how text should be broken up in highlight snippets: `simple` or `span`. Only valid for the `plain` highlighter. Defaults to `span` if omitted. :arg fragment_size: The size of the highlighted fragment in characters. Defaults to `100` if omitted. :arg highlight_filter: :arg highlight_query: Highlight matches for a query other than the search query. This is especially useful if you use a rescore query because those are not taken into account by highlighting by default. :arg max_fragment_length: :arg max_analyzed_offset: If set to a non-negative value, highlighting stops at this defined maximum limit. The rest of the text is not processed, thus not highlighted and no error is returned The `max_analyzed_offset` query setting does not override the `index.highlight.max_analyzed_offset` setting, which prevails when it’s set to lower value than the query setting. :arg no_match_size: The amount of text you want to return from the beginning of the field if there are no matching fragments to highlight. :arg number_of_fragments: The maximum number of fragments to return. If the number of fragments is set to `0`, no fragments are returned. Instead, the entire field contents are highlighted and returned. This can be handy when you need to highlight short texts such as a title or address, but fragmentation is not required. If `number_of_fragments` is `0`, `fragment_size` is ignored. Defaults to `5` if omitted. :arg options: :arg order: Sorts highlighted fragments by score when set to `score`. By default, fragments will be output in the order they appear in the field (order: `none`). Setting this option to `score` will output the most relevant fragments first. Each highlighter applies its own logic to compute relevancy scores. Defaults to `none` if omitted. :arg phrase_limit: Controls the number of matching phrases in a document that are considered. Prevents the `fvh` highlighter from analyzing too many phrases and consuming too much memory. When using `matched_fields`, `phrase_limit` phrases per matched field are considered. Raising the limit increases query time and consumes more memory. Only supported by the `fvh` highlighter. Defaults to `256` if omitted. :arg post_tags: Use in conjunction with `pre_tags` to define the HTML tags to use for the highlighted text. By default, highlighted text is wrapped in `` and `` tags. :arg pre_tags: Use in conjunction with `post_tags` to define the HTML tags to use for the highlighted text. By default, highlighted text is wrapped in `` and `` tags. :arg require_field_match: By default, only fields that contains a query match are highlighted. Set to `false` to highlight all fields. Defaults to `True` if omitted. :arg tags_schema: Set to `styled` to use the built-in tag schema. """ fields: Union[ Mapping[Union[str, InstrumentedField], "HighlightField"], Dict[str, Any], DefaultType, ] encoder: Union[Literal["default", "html"], DefaultType] type: Union[Literal["plain", "fvh", "unified"], DefaultType] boundary_chars: Union[str, DefaultType] boundary_max_scan: Union[int, DefaultType] boundary_scanner: Union[Literal["chars", "sentence", "word"], DefaultType] boundary_scanner_locale: Union[str, DefaultType] force_source: Union[bool, DefaultType] fragmenter: Union[Literal["simple", "span"], DefaultType] fragment_size: Union[int, DefaultType] highlight_filter: Union[bool, DefaultType] highlight_query: Union[Query, DefaultType] max_fragment_length: Union[int, DefaultType] max_analyzed_offset: Union[int, DefaultType] no_match_size: Union[int, DefaultType] number_of_fragments: Union[int, DefaultType] options: Union[Mapping[str, Any], DefaultType] order: Union[Literal["score"], DefaultType] phrase_limit: Union[int, DefaultType] post_tags: Union[Sequence[str], DefaultType] pre_tags: Union[Sequence[str], DefaultType] require_field_match: Union[bool, DefaultType] tags_schema: Union[Literal["styled"], DefaultType] def __init__( self, *, fields: Union[ Mapping[Union[str, InstrumentedField], "HighlightField"], Dict[str, Any], DefaultType, ] = DEFAULT, encoder: Union[Literal["default", "html"], DefaultType] = DEFAULT, type: Union[Literal["plain", "fvh", "unified"], DefaultType] = DEFAULT, boundary_chars: Union[str, DefaultType] = DEFAULT, boundary_max_scan: Union[int, DefaultType] = DEFAULT, boundary_scanner: Union[ Literal["chars", "sentence", "word"], DefaultType ] = DEFAULT, boundary_scanner_locale: Union[str, DefaultType] = DEFAULT, force_source: Union[bool, DefaultType] = DEFAULT, fragmenter: Union[Literal["simple", "span"], DefaultType] = DEFAULT, fragment_size: Union[int, DefaultType] = DEFAULT, highlight_filter: Union[bool, DefaultType] = DEFAULT, highlight_query: Union[Query, DefaultType] = DEFAULT, max_fragment_length: Union[int, DefaultType] = DEFAULT, max_analyzed_offset: Union[int, DefaultType] = DEFAULT, no_match_size: Union[int, DefaultType] = DEFAULT, number_of_fragments: Union[int, DefaultType] = DEFAULT, options: Union[Mapping[str, Any], DefaultType] = DEFAULT, order: Union[Literal["score"], DefaultType] = DEFAULT, phrase_limit: Union[int, DefaultType] = DEFAULT, post_tags: Union[Sequence[str], DefaultType] = DEFAULT, pre_tags: Union[Sequence[str], DefaultType] = DEFAULT, require_field_match: Union[bool, DefaultType] = DEFAULT, tags_schema: Union[Literal["styled"], DefaultType] = DEFAULT, **kwargs: Any, ): if fields is not DEFAULT: kwargs["fields"] = str(fields) if encoder is not DEFAULT: kwargs["encoder"] = encoder if type is not DEFAULT: kwargs["type"] = type if boundary_chars is not DEFAULT: kwargs["boundary_chars"] = boundary_chars if boundary_max_scan is not DEFAULT: kwargs["boundary_max_scan"] = boundary_max_scan if boundary_scanner is not DEFAULT: kwargs["boundary_scanner"] = boundary_scanner if boundary_scanner_locale is not DEFAULT: kwargs["boundary_scanner_locale"] = boundary_scanner_locale if force_source is not DEFAULT: kwargs["force_source"] = force_source if fragmenter is not DEFAULT: kwargs["fragmenter"] = fragmenter if fragment_size is not DEFAULT: kwargs["fragment_size"] = fragment_size if highlight_filter is not DEFAULT: kwargs["highlight_filter"] = highlight_filter if highlight_query is not DEFAULT: kwargs["highlight_query"] = highlight_query if max_fragment_length is not DEFAULT: kwargs["max_fragment_length"] = max_fragment_length if max_analyzed_offset is not DEFAULT: kwargs["max_analyzed_offset"] = max_analyzed_offset if no_match_size is not DEFAULT: kwargs["no_match_size"] = no_match_size if number_of_fragments is not DEFAULT: kwargs["number_of_fragments"] = number_of_fragments if options is not DEFAULT: kwargs["options"] = options if order is not DEFAULT: kwargs["order"] = order if phrase_limit is not DEFAULT: kwargs["phrase_limit"] = phrase_limit if post_tags is not DEFAULT: kwargs["post_tags"] = post_tags if pre_tags is not DEFAULT: kwargs["pre_tags"] = pre_tags if require_field_match is not DEFAULT: kwargs["require_field_match"] = require_field_match if tags_schema is not DEFAULT: kwargs["tags_schema"] = tags_schema super().__init__(kwargs) class HighlightField(AttrDict[Any]): """ :arg fragment_offset: :arg matched_fields: :arg type: :arg boundary_chars: A string that contains each boundary character. Defaults to `.,!? \t\n` if omitted. :arg boundary_max_scan: How far to scan for boundary characters. Defaults to `20` if omitted. :arg boundary_scanner: Specifies how to break the highlighted fragments: chars, sentence, or word. Only valid for the unified and fvh highlighters. Defaults to `sentence` for the `unified` highlighter. Defaults to `chars` for the `fvh` highlighter. :arg boundary_scanner_locale: Controls which locale is used to search for sentence and word boundaries. This parameter takes a form of a language tag, for example: `"en-US"`, `"fr-FR"`, `"ja-JP"`. Defaults to `Locale.ROOT` if omitted. :arg force_source: :arg fragmenter: Specifies how text should be broken up in highlight snippets: `simple` or `span`. Only valid for the `plain` highlighter. Defaults to `span` if omitted. :arg fragment_size: The size of the highlighted fragment in characters. Defaults to `100` if omitted. :arg highlight_filter: :arg highlight_query: Highlight matches for a query other than the search query. This is especially useful if you use a rescore query because those are not taken into account by highlighting by default. :arg max_fragment_length: :arg max_analyzed_offset: If set to a non-negative value, highlighting stops at this defined maximum limit. The rest of the text is not processed, thus not highlighted and no error is returned The `max_analyzed_offset` query setting does not override the `index.highlight.max_analyzed_offset` setting, which prevails when it’s set to lower value than the query setting. :arg no_match_size: The amount of text you want to return from the beginning of the field if there are no matching fragments to highlight. :arg number_of_fragments: The maximum number of fragments to return. If the number of fragments is set to `0`, no fragments are returned. Instead, the entire field contents are highlighted and returned. This can be handy when you need to highlight short texts such as a title or address, but fragmentation is not required. If `number_of_fragments` is `0`, `fragment_size` is ignored. Defaults to `5` if omitted. :arg options: :arg order: Sorts highlighted fragments by score when set to `score`. By default, fragments will be output in the order they appear in the field (order: `none`). Setting this option to `score` will output the most relevant fragments first. Each highlighter applies its own logic to compute relevancy scores. Defaults to `none` if omitted. :arg phrase_limit: Controls the number of matching phrases in a document that are considered. Prevents the `fvh` highlighter from analyzing too many phrases and consuming too much memory. When using `matched_fields`, `phrase_limit` phrases per matched field are considered. Raising the limit increases query time and consumes more memory. Only supported by the `fvh` highlighter. Defaults to `256` if omitted. :arg post_tags: Use in conjunction with `pre_tags` to define the HTML tags to use for the highlighted text. By default, highlighted text is wrapped in `` and `` tags. :arg pre_tags: Use in conjunction with `post_tags` to define the HTML tags to use for the highlighted text. By default, highlighted text is wrapped in `` and `` tags. :arg require_field_match: By default, only fields that contains a query match are highlighted. Set to `false` to highlight all fields. Defaults to `True` if omitted. :arg tags_schema: Set to `styled` to use the built-in tag schema. """ fragment_offset: Union[int, DefaultType] matched_fields: Union[ Union[str, InstrumentedField], Sequence[Union[str, InstrumentedField]], DefaultType, ] type: Union[Literal["plain", "fvh", "unified"], DefaultType] boundary_chars: Union[str, DefaultType] boundary_max_scan: Union[int, DefaultType] boundary_scanner: Union[Literal["chars", "sentence", "word"], DefaultType] boundary_scanner_locale: Union[str, DefaultType] force_source: Union[bool, DefaultType] fragmenter: Union[Literal["simple", "span"], DefaultType] fragment_size: Union[int, DefaultType] highlight_filter: Union[bool, DefaultType] highlight_query: Union[Query, DefaultType] max_fragment_length: Union[int, DefaultType] max_analyzed_offset: Union[int, DefaultType] no_match_size: Union[int, DefaultType] number_of_fragments: Union[int, DefaultType] options: Union[Mapping[str, Any], DefaultType] order: Union[Literal["score"], DefaultType] phrase_limit: Union[int, DefaultType] post_tags: Union[Sequence[str], DefaultType] pre_tags: Union[Sequence[str], DefaultType] require_field_match: Union[bool, DefaultType] tags_schema: Union[Literal["styled"], DefaultType] def __init__( self, *, fragment_offset: Union[int, DefaultType] = DEFAULT, matched_fields: Union[ Union[str, InstrumentedField], Sequence[Union[str, InstrumentedField]], DefaultType, ] = DEFAULT, type: Union[Literal["plain", "fvh", "unified"], DefaultType] = DEFAULT, boundary_chars: Union[str, DefaultType] = DEFAULT, boundary_max_scan: Union[int, DefaultType] = DEFAULT, boundary_scanner: Union[ Literal["chars", "sentence", "word"], DefaultType ] = DEFAULT, boundary_scanner_locale: Union[str, DefaultType] = DEFAULT, force_source: Union[bool, DefaultType] = DEFAULT, fragmenter: Union[Literal["simple", "span"], DefaultType] = DEFAULT, fragment_size: Union[int, DefaultType] = DEFAULT, highlight_filter: Union[bool, DefaultType] = DEFAULT, highlight_query: Union[Query, DefaultType] = DEFAULT, max_fragment_length: Union[int, DefaultType] = DEFAULT, max_analyzed_offset: Union[int, DefaultType] = DEFAULT, no_match_size: Union[int, DefaultType] = DEFAULT, number_of_fragments: Union[int, DefaultType] = DEFAULT, options: Union[Mapping[str, Any], DefaultType] = DEFAULT, order: Union[Literal["score"], DefaultType] = DEFAULT, phrase_limit: Union[int, DefaultType] = DEFAULT, post_tags: Union[Sequence[str], DefaultType] = DEFAULT, pre_tags: Union[Sequence[str], DefaultType] = DEFAULT, require_field_match: Union[bool, DefaultType] = DEFAULT, tags_schema: Union[Literal["styled"], DefaultType] = DEFAULT, **kwargs: Any, ): if fragment_offset is not DEFAULT: kwargs["fragment_offset"] = fragment_offset if matched_fields is not DEFAULT: kwargs["matched_fields"] = str(matched_fields) if type is not DEFAULT: kwargs["type"] = type if boundary_chars is not DEFAULT: kwargs["boundary_chars"] = boundary_chars if boundary_max_scan is not DEFAULT: kwargs["boundary_max_scan"] = boundary_max_scan if boundary_scanner is not DEFAULT: kwargs["boundary_scanner"] = boundary_scanner if boundary_scanner_locale is not DEFAULT: kwargs["boundary_scanner_locale"] = boundary_scanner_locale if force_source is not DEFAULT: kwargs["force_source"] = force_source if fragmenter is not DEFAULT: kwargs["fragmenter"] = fragmenter if fragment_size is not DEFAULT: kwargs["fragment_size"] = fragment_size if highlight_filter is not DEFAULT: kwargs["highlight_filter"] = highlight_filter if highlight_query is not DEFAULT: kwargs["highlight_query"] = highlight_query if max_fragment_length is not DEFAULT: kwargs["max_fragment_length"] = max_fragment_length if max_analyzed_offset is not DEFAULT: kwargs["max_analyzed_offset"] = max_analyzed_offset if no_match_size is not DEFAULT: kwargs["no_match_size"] = no_match_size if number_of_fragments is not DEFAULT: kwargs["number_of_fragments"] = number_of_fragments if options is not DEFAULT: kwargs["options"] = options if order is not DEFAULT: kwargs["order"] = order if phrase_limit is not DEFAULT: kwargs["phrase_limit"] = phrase_limit if post_tags is not DEFAULT: kwargs["post_tags"] = post_tags if pre_tags is not DEFAULT: kwargs["pre_tags"] = pre_tags if require_field_match is not DEFAULT: kwargs["require_field_match"] = require_field_match if tags_schema is not DEFAULT: kwargs["tags_schema"] = tags_schema super().__init__(kwargs) class HoltLinearModelSettings(AttrDict[Any]): """ :arg alpha: :arg beta: """ alpha: Union[float, DefaultType] beta: Union[float, DefaultType] def __init__( self, *, alpha: Union[float, DefaultType] = DEFAULT, beta: Union[float, DefaultType] = DEFAULT, **kwargs: Any, ): if alpha is not DEFAULT: kwargs["alpha"] = alpha if beta is not DEFAULT: kwargs["beta"] = beta super().__init__(kwargs) class HoltWintersModelSettings(AttrDict[Any]): """ :arg alpha: :arg beta: :arg gamma: :arg pad: :arg period: :arg type: """ alpha: Union[float, DefaultType] beta: Union[float, DefaultType] gamma: Union[float, DefaultType] pad: Union[bool, DefaultType] period: Union[int, DefaultType] type: Union[Literal["add", "mult"], DefaultType] def __init__( self, *, alpha: Union[float, DefaultType] = DEFAULT, beta: Union[float, DefaultType] = DEFAULT, gamma: Union[float, DefaultType] = DEFAULT, pad: Union[bool, DefaultType] = DEFAULT, period: Union[int, DefaultType] = DEFAULT, type: Union[Literal["add", "mult"], DefaultType] = DEFAULT, **kwargs: Any, ): if alpha is not DEFAULT: kwargs["alpha"] = alpha if beta is not DEFAULT: kwargs["beta"] = beta if gamma is not DEFAULT: kwargs["gamma"] = gamma if pad is not DEFAULT: kwargs["pad"] = pad if period is not DEFAULT: kwargs["period"] = period if type is not DEFAULT: kwargs["type"] = type super().__init__(kwargs) class InferenceConfigContainer(AttrDict[Any]): """ :arg regression: Regression configuration for inference. :arg classification: Classification configuration for inference. """ regression: Union["RegressionInferenceOptions", Dict[str, Any], DefaultType] classification: Union["ClassificationInferenceOptions", Dict[str, Any], DefaultType] def __init__( self, *, regression: Union[ "RegressionInferenceOptions", Dict[str, Any], DefaultType ] = DEFAULT, classification: Union[ "ClassificationInferenceOptions", Dict[str, Any], DefaultType ] = DEFAULT, **kwargs: Any, ): if regression is not DEFAULT: kwargs["regression"] = regression if classification is not DEFAULT: kwargs["classification"] = classification super().__init__(kwargs) class InnerHits(AttrDict[Any]): """ :arg name: The name for the particular inner hit definition in the response. Useful when a search request contains multiple inner hits. :arg size: The maximum number of hits to return per `inner_hits`. Defaults to `3` if omitted. :arg from: Inner hit starting document offset. :arg collapse: :arg docvalue_fields: :arg explain: :arg highlight: :arg ignore_unmapped: :arg script_fields: :arg seq_no_primary_term: :arg fields: :arg sort: How the inner hits should be sorted per `inner_hits`. By default, inner hits are sorted by score. :arg _source: :arg stored_fields: :arg track_scores: :arg version: """ name: Union[str, DefaultType] size: Union[int, DefaultType] from_: Union[int, DefaultType] collapse: Union["FieldCollapse", Dict[str, Any], DefaultType] docvalue_fields: Union[ Sequence["FieldAndFormat"], Sequence[Dict[str, Any]], DefaultType ] explain: Union[bool, DefaultType] highlight: Union["Highlight", Dict[str, Any], DefaultType] ignore_unmapped: Union[bool, DefaultType] script_fields: Union[ Mapping[Union[str, InstrumentedField], "ScriptField"], Dict[str, Any], DefaultType, ] seq_no_primary_term: Union[bool, DefaultType] fields: Union[ Union[str, InstrumentedField], Sequence[Union[str, InstrumentedField]], DefaultType, ] sort: Union[ Union[Union[str, InstrumentedField], "SortOptions"], Sequence[Union[Union[str, InstrumentedField], "SortOptions"]], Dict[str, Any], DefaultType, ] _source: Union[bool, "SourceFilter", Dict[str, Any], DefaultType] stored_fields: Union[ Union[str, InstrumentedField], Sequence[Union[str, InstrumentedField]], DefaultType, ] track_scores: Union[bool, DefaultType] version: Union[bool, DefaultType] def __init__( self, *, name: Union[str, DefaultType] = DEFAULT, size: Union[int, DefaultType] = DEFAULT, from_: Union[int, DefaultType] = DEFAULT, collapse: Union["FieldCollapse", Dict[str, Any], DefaultType] = DEFAULT, docvalue_fields: Union[ Sequence["FieldAndFormat"], Sequence[Dict[str, Any]], DefaultType ] = DEFAULT, explain: Union[bool, DefaultType] = DEFAULT, highlight: Union["Highlight", Dict[str, Any], DefaultType] = DEFAULT, ignore_unmapped: Union[bool, DefaultType] = DEFAULT, script_fields: Union[ Mapping[Union[str, InstrumentedField], "ScriptField"], Dict[str, Any], DefaultType, ] = DEFAULT, seq_no_primary_term: Union[bool, DefaultType] = DEFAULT, fields: Union[ Union[str, InstrumentedField], Sequence[Union[str, InstrumentedField]], DefaultType, ] = DEFAULT, sort: Union[ Union[Union[str, InstrumentedField], "SortOptions"], Sequence[Union[Union[str, InstrumentedField], "SortOptions"]], Dict[str, Any], DefaultType, ] = DEFAULT, _source: Union[bool, "SourceFilter", Dict[str, Any], DefaultType] = DEFAULT, stored_fields: Union[ Union[str, InstrumentedField], Sequence[Union[str, InstrumentedField]], DefaultType, ] = DEFAULT, track_scores: Union[bool, DefaultType] = DEFAULT, version: Union[bool, DefaultType] = DEFAULT, **kwargs: Any, ): if name is not DEFAULT: kwargs["name"] = name if size is not DEFAULT: kwargs["size"] = size if from_ is not DEFAULT: kwargs["from_"] = from_ if collapse is not DEFAULT: kwargs["collapse"] = collapse if docvalue_fields is not DEFAULT: kwargs["docvalue_fields"] = docvalue_fields if explain is not DEFAULT: kwargs["explain"] = explain if highlight is not DEFAULT: kwargs["highlight"] = highlight if ignore_unmapped is not DEFAULT: kwargs["ignore_unmapped"] = ignore_unmapped if script_fields is not DEFAULT: kwargs["script_fields"] = str(script_fields) if seq_no_primary_term is not DEFAULT: kwargs["seq_no_primary_term"] = seq_no_primary_term if fields is not DEFAULT: kwargs["fields"] = str(fields) if sort is not DEFAULT: kwargs["sort"] = str(sort) if _source is not DEFAULT: kwargs["_source"] = _source if stored_fields is not DEFAULT: kwargs["stored_fields"] = str(stored_fields) if track_scores is not DEFAULT: kwargs["track_scores"] = track_scores if version is not DEFAULT: kwargs["version"] = version super().__init__(kwargs) class IntervalsAllOf(AttrDict[Any]): """ :arg intervals: (required) An array of rules to combine. All rules must produce a match in a document for the overall source to match. :arg max_gaps: Maximum number of positions between the matching terms. Intervals produced by the rules further apart than this are not considered matches. Defaults to `-1` if omitted. :arg ordered: If `true`, intervals produced by the rules should appear in the order in which they are specified. :arg filter: Rule used to filter returned intervals. """ intervals: Union[ Sequence["IntervalsContainer"], Sequence[Dict[str, Any]], DefaultType ] max_gaps: Union[int, DefaultType] ordered: Union[bool, DefaultType] filter: Union["IntervalsFilter", Dict[str, Any], DefaultType] def __init__( self, *, intervals: Union[ Sequence["IntervalsContainer"], Sequence[Dict[str, Any]], DefaultType ] = DEFAULT, max_gaps: Union[int, DefaultType] = DEFAULT, ordered: Union[bool, DefaultType] = DEFAULT, filter: Union["IntervalsFilter", Dict[str, Any], DefaultType] = DEFAULT, **kwargs: Any, ): if intervals is not DEFAULT: kwargs["intervals"] = intervals if max_gaps is not DEFAULT: kwargs["max_gaps"] = max_gaps if ordered is not DEFAULT: kwargs["ordered"] = ordered if filter is not DEFAULT: kwargs["filter"] = filter super().__init__(kwargs) class IntervalsAnyOf(AttrDict[Any]): """ :arg intervals: (required) An array of rules to match. :arg filter: Rule used to filter returned intervals. """ intervals: Union[ Sequence["IntervalsContainer"], Sequence[Dict[str, Any]], DefaultType ] filter: Union["IntervalsFilter", Dict[str, Any], DefaultType] def __init__( self, *, intervals: Union[ Sequence["IntervalsContainer"], Sequence[Dict[str, Any]], DefaultType ] = DEFAULT, filter: Union["IntervalsFilter", Dict[str, Any], DefaultType] = DEFAULT, **kwargs: Any, ): if intervals is not DEFAULT: kwargs["intervals"] = intervals if filter is not DEFAULT: kwargs["filter"] = filter super().__init__(kwargs) class IntervalsContainer(AttrDict[Any]): """ :arg all_of: Returns matches that span a combination of other rules. :arg any_of: Returns intervals produced by any of its sub-rules. :arg fuzzy: Matches analyzed text. :arg match: Matches analyzed text. :arg prefix: Matches terms that start with a specified set of characters. :arg wildcard: Matches terms using a wildcard pattern. """ all_of: Union["IntervalsAllOf", Dict[str, Any], DefaultType] any_of: Union["IntervalsAnyOf", Dict[str, Any], DefaultType] fuzzy: Union["IntervalsFuzzy", Dict[str, Any], DefaultType] match: Union["IntervalsMatch", Dict[str, Any], DefaultType] prefix: Union["IntervalsPrefix", Dict[str, Any], DefaultType] wildcard: Union["IntervalsWildcard", Dict[str, Any], DefaultType] def __init__( self, *, all_of: Union["IntervalsAllOf", Dict[str, Any], DefaultType] = DEFAULT, any_of: Union["IntervalsAnyOf", Dict[str, Any], DefaultType] = DEFAULT, fuzzy: Union["IntervalsFuzzy", Dict[str, Any], DefaultType] = DEFAULT, match: Union["IntervalsMatch", Dict[str, Any], DefaultType] = DEFAULT, prefix: Union["IntervalsPrefix", Dict[str, Any], DefaultType] = DEFAULT, wildcard: Union["IntervalsWildcard", Dict[str, Any], DefaultType] = DEFAULT, **kwargs: Any, ): if all_of is not DEFAULT: kwargs["all_of"] = all_of if any_of is not DEFAULT: kwargs["any_of"] = any_of if fuzzy is not DEFAULT: kwargs["fuzzy"] = fuzzy if match is not DEFAULT: kwargs["match"] = match if prefix is not DEFAULT: kwargs["prefix"] = prefix if wildcard is not DEFAULT: kwargs["wildcard"] = wildcard super().__init__(kwargs) class IntervalsFilter(AttrDict[Any]): """ :arg after: Query used to return intervals that follow an interval from the `filter` rule. :arg before: Query used to return intervals that occur before an interval from the `filter` rule. :arg contained_by: Query used to return intervals contained by an interval from the `filter` rule. :arg containing: Query used to return intervals that contain an interval from the `filter` rule. :arg not_contained_by: Query used to return intervals that are **not** contained by an interval from the `filter` rule. :arg not_containing: Query used to return intervals that do **not** contain an interval from the `filter` rule. :arg not_overlapping: Query used to return intervals that do **not** overlap with an interval from the `filter` rule. :arg overlapping: Query used to return intervals that overlap with an interval from the `filter` rule. :arg script: Script used to return matching documents. This script must return a boolean value: `true` or `false`. """ after: Union["IntervalsContainer", Dict[str, Any], DefaultType] before: Union["IntervalsContainer", Dict[str, Any], DefaultType] contained_by: Union["IntervalsContainer", Dict[str, Any], DefaultType] containing: Union["IntervalsContainer", Dict[str, Any], DefaultType] not_contained_by: Union["IntervalsContainer", Dict[str, Any], DefaultType] not_containing: Union["IntervalsContainer", Dict[str, Any], DefaultType] not_overlapping: Union["IntervalsContainer", Dict[str, Any], DefaultType] overlapping: Union["IntervalsContainer", Dict[str, Any], DefaultType] script: Union["Script", Dict[str, Any], DefaultType] def __init__( self, *, after: Union["IntervalsContainer", Dict[str, Any], DefaultType] = DEFAULT, before: Union["IntervalsContainer", Dict[str, Any], DefaultType] = DEFAULT, contained_by: Union[ "IntervalsContainer", Dict[str, Any], DefaultType ] = DEFAULT, containing: Union["IntervalsContainer", Dict[str, Any], DefaultType] = DEFAULT, not_contained_by: Union[ "IntervalsContainer", Dict[str, Any], DefaultType ] = DEFAULT, not_containing: Union[ "IntervalsContainer", Dict[str, Any], DefaultType ] = DEFAULT, not_overlapping: Union[ "IntervalsContainer", Dict[str, Any], DefaultType ] = DEFAULT, overlapping: Union["IntervalsContainer", Dict[str, Any], DefaultType] = DEFAULT, script: Union["Script", Dict[str, Any], DefaultType] = DEFAULT, **kwargs: Any, ): if after is not DEFAULT: kwargs["after"] = after if before is not DEFAULT: kwargs["before"] = before if contained_by is not DEFAULT: kwargs["contained_by"] = contained_by if containing is not DEFAULT: kwargs["containing"] = containing if not_contained_by is not DEFAULT: kwargs["not_contained_by"] = not_contained_by if not_containing is not DEFAULT: kwargs["not_containing"] = not_containing if not_overlapping is not DEFAULT: kwargs["not_overlapping"] = not_overlapping if overlapping is not DEFAULT: kwargs["overlapping"] = overlapping if script is not DEFAULT: kwargs["script"] = script super().__init__(kwargs) class IntervalsFuzzy(AttrDict[Any]): """ :arg term: (required) The term to match. :arg analyzer: Analyzer used to normalize the term. :arg fuzziness: Maximum edit distance allowed for matching. Defaults to `auto` if omitted. :arg prefix_length: Number of beginning characters left unchanged when creating expansions. :arg transpositions: Indicates whether edits include transpositions of two adjacent characters (for example, `ab` to `ba`). Defaults to `True` if omitted. :arg use_field: If specified, match intervals from this field rather than the top-level field. The `term` is normalized using the search analyzer from this field, unless `analyzer` is specified separately. """ term: Union[str, DefaultType] analyzer: Union[str, DefaultType] fuzziness: Union[str, int, DefaultType] prefix_length: Union[int, DefaultType] transpositions: Union[bool, DefaultType] use_field: Union[str, InstrumentedField, DefaultType] def __init__( self, *, term: Union[str, DefaultType] = DEFAULT, analyzer: Union[str, DefaultType] = DEFAULT, fuzziness: Union[str, int, DefaultType] = DEFAULT, prefix_length: Union[int, DefaultType] = DEFAULT, transpositions: Union[bool, DefaultType] = DEFAULT, use_field: Union[str, InstrumentedField, DefaultType] = DEFAULT, **kwargs: Any, ): if term is not DEFAULT: kwargs["term"] = term if analyzer is not DEFAULT: kwargs["analyzer"] = analyzer if fuzziness is not DEFAULT: kwargs["fuzziness"] = fuzziness if prefix_length is not DEFAULT: kwargs["prefix_length"] = prefix_length if transpositions is not DEFAULT: kwargs["transpositions"] = transpositions if use_field is not DEFAULT: kwargs["use_field"] = str(use_field) super().__init__(kwargs) class IntervalsMatch(AttrDict[Any]): """ :arg query: (required) Text you wish to find in the provided field. :arg analyzer: Analyzer used to analyze terms in the query. :arg max_gaps: Maximum number of positions between the matching terms. Terms further apart than this are not considered matches. Defaults to `-1` if omitted. :arg ordered: If `true`, matching terms must appear in their specified order. :arg use_field: If specified, match intervals from this field rather than the top-level field. The `term` is normalized using the search analyzer from this field, unless `analyzer` is specified separately. :arg filter: An optional interval filter. """ query: Union[str, DefaultType] analyzer: Union[str, DefaultType] max_gaps: Union[int, DefaultType] ordered: Union[bool, DefaultType] use_field: Union[str, InstrumentedField, DefaultType] filter: Union["IntervalsFilter", Dict[str, Any], DefaultType] def __init__( self, *, query: Union[str, DefaultType] = DEFAULT, analyzer: Union[str, DefaultType] = DEFAULT, max_gaps: Union[int, DefaultType] = DEFAULT, ordered: Union[bool, DefaultType] = DEFAULT, use_field: Union[str, InstrumentedField, DefaultType] = DEFAULT, filter: Union["IntervalsFilter", Dict[str, Any], DefaultType] = DEFAULT, **kwargs: Any, ): if query is not DEFAULT: kwargs["query"] = query if analyzer is not DEFAULT: kwargs["analyzer"] = analyzer if max_gaps is not DEFAULT: kwargs["max_gaps"] = max_gaps if ordered is not DEFAULT: kwargs["ordered"] = ordered if use_field is not DEFAULT: kwargs["use_field"] = str(use_field) if filter is not DEFAULT: kwargs["filter"] = filter super().__init__(kwargs) class IntervalsPrefix(AttrDict[Any]): """ :arg prefix: (required) Beginning characters of terms you wish to find in the top-level field. :arg analyzer: Analyzer used to analyze the `prefix`. :arg use_field: If specified, match intervals from this field rather than the top-level field. The `prefix` is normalized using the search analyzer from this field, unless `analyzer` is specified separately. """ prefix: Union[str, DefaultType] analyzer: Union[str, DefaultType] use_field: Union[str, InstrumentedField, DefaultType] def __init__( self, *, prefix: Union[str, DefaultType] = DEFAULT, analyzer: Union[str, DefaultType] = DEFAULT, use_field: Union[str, InstrumentedField, DefaultType] = DEFAULT, **kwargs: Any, ): if prefix is not DEFAULT: kwargs["prefix"] = prefix if analyzer is not DEFAULT: kwargs["analyzer"] = analyzer if use_field is not DEFAULT: kwargs["use_field"] = str(use_field) super().__init__(kwargs) class IntervalsQuery(AttrDict[Any]): """ :arg all_of: Returns matches that span a combination of other rules. :arg any_of: Returns intervals produced by any of its sub-rules. :arg fuzzy: Matches terms that are similar to the provided term, within an edit distance defined by `fuzziness`. :arg match: Matches analyzed text. :arg prefix: Matches terms that start with a specified set of characters. :arg wildcard: Matches terms using a wildcard pattern. :arg boost: Floating point number used to decrease or increase the relevance scores of the query. Boost values are relative to the default value of 1.0. A boost value between 0 and 1.0 decreases the relevance score. A value greater than 1.0 increases the relevance score. Defaults to `1` if omitted. :arg _name: """ all_of: Union["IntervalsAllOf", Dict[str, Any], DefaultType] any_of: Union["IntervalsAnyOf", Dict[str, Any], DefaultType] fuzzy: Union["IntervalsFuzzy", Dict[str, Any], DefaultType] match: Union["IntervalsMatch", Dict[str, Any], DefaultType] prefix: Union["IntervalsPrefix", Dict[str, Any], DefaultType] wildcard: Union["IntervalsWildcard", Dict[str, Any], DefaultType] boost: Union[float, DefaultType] _name: Union[str, DefaultType] def __init__( self, *, all_of: Union["IntervalsAllOf", Dict[str, Any], DefaultType] = DEFAULT, any_of: Union["IntervalsAnyOf", Dict[str, Any], DefaultType] = DEFAULT, fuzzy: Union["IntervalsFuzzy", Dict[str, Any], DefaultType] = DEFAULT, match: Union["IntervalsMatch", Dict[str, Any], DefaultType] = DEFAULT, prefix: Union["IntervalsPrefix", Dict[str, Any], DefaultType] = DEFAULT, wildcard: Union["IntervalsWildcard", Dict[str, Any], DefaultType] = DEFAULT, boost: Union[float, DefaultType] = DEFAULT, _name: Union[str, DefaultType] = DEFAULT, **kwargs: Any, ): if all_of is not DEFAULT: kwargs["all_of"] = all_of if any_of is not DEFAULT: kwargs["any_of"] = any_of if fuzzy is not DEFAULT: kwargs["fuzzy"] = fuzzy if match is not DEFAULT: kwargs["match"] = match if prefix is not DEFAULT: kwargs["prefix"] = prefix if wildcard is not DEFAULT: kwargs["wildcard"] = wildcard if boost is not DEFAULT: kwargs["boost"] = boost if _name is not DEFAULT: kwargs["_name"] = _name super().__init__(kwargs) class IntervalsWildcard(AttrDict[Any]): """ :arg pattern: (required) Wildcard pattern used to find matching terms. :arg analyzer: Analyzer used to analyze the `pattern`. Defaults to the top-level field's analyzer. :arg use_field: If specified, match intervals from this field rather than the top-level field. The `pattern` is normalized using the search analyzer from this field, unless `analyzer` is specified separately. """ pattern: Union[str, DefaultType] analyzer: Union[str, DefaultType] use_field: Union[str, InstrumentedField, DefaultType] def __init__( self, *, pattern: Union[str, DefaultType] = DEFAULT, analyzer: Union[str, DefaultType] = DEFAULT, use_field: Union[str, InstrumentedField, DefaultType] = DEFAULT, **kwargs: Any, ): if pattern is not DEFAULT: kwargs["pattern"] = pattern if analyzer is not DEFAULT: kwargs["analyzer"] = analyzer if use_field is not DEFAULT: kwargs["use_field"] = str(use_field) super().__init__(kwargs) class IpRangeAggregationRange(AttrDict[Any]): """ :arg from: Start of the range. :arg mask: IP range defined as a CIDR mask. :arg to: End of the range. """ from_: Union[str, None, DefaultType] mask: Union[str, DefaultType] to: Union[str, None, DefaultType] def __init__( self, *, from_: Union[str, None, DefaultType] = DEFAULT, mask: Union[str, DefaultType] = DEFAULT, to: Union[str, None, DefaultType] = DEFAULT, **kwargs: Any, ): if from_ is not DEFAULT: kwargs["from_"] = from_ if mask is not DEFAULT: kwargs["mask"] = mask if to is not DEFAULT: kwargs["to"] = to super().__init__(kwargs) class LatLonGeoLocation(AttrDict[Any]): """ :arg lat: (required) Latitude :arg lon: (required) Longitude """ lat: Union[float, DefaultType] lon: Union[float, DefaultType] def __init__( self, *, lat: Union[float, DefaultType] = DEFAULT, lon: Union[float, DefaultType] = DEFAULT, **kwargs: Any, ): if lat is not DEFAULT: kwargs["lat"] = lat if lon is not DEFAULT: kwargs["lon"] = lon super().__init__(kwargs) class LikeDocument(AttrDict[Any]): """ :arg doc: A document not present in the index. :arg fields: :arg _id: ID of a document. :arg _index: Index of a document. :arg per_field_analyzer: Overrides the default analyzer. :arg routing: :arg version: :arg version_type: Defaults to `'internal'` if omitted. """ doc: Any fields: Union[Sequence[Union[str, InstrumentedField]], DefaultType] _id: Union[str, DefaultType] _index: Union[str, DefaultType] per_field_analyzer: Union[Mapping[Union[str, InstrumentedField], str], DefaultType] routing: Union[str, DefaultType] version: Union[int, DefaultType] version_type: Union[ Literal["internal", "external", "external_gte", "force"], DefaultType ] def __init__( self, *, doc: Any = DEFAULT, fields: Union[Sequence[Union[str, InstrumentedField]], DefaultType] = DEFAULT, _id: Union[str, DefaultType] = DEFAULT, _index: Union[str, DefaultType] = DEFAULT, per_field_analyzer: Union[ Mapping[Union[str, InstrumentedField], str], DefaultType ] = DEFAULT, routing: Union[str, DefaultType] = DEFAULT, version: Union[int, DefaultType] = DEFAULT, version_type: Union[ Literal["internal", "external", "external_gte", "force"], DefaultType ] = DEFAULT, **kwargs: Any, ): if doc is not DEFAULT: kwargs["doc"] = doc if fields is not DEFAULT: kwargs["fields"] = str(fields) if _id is not DEFAULT: kwargs["_id"] = _id if _index is not DEFAULT: kwargs["_index"] = _index if per_field_analyzer is not DEFAULT: kwargs["per_field_analyzer"] = str(per_field_analyzer) if routing is not DEFAULT: kwargs["routing"] = routing if version is not DEFAULT: kwargs["version"] = version if version_type is not DEFAULT: kwargs["version_type"] = version_type super().__init__(kwargs) class MatchBoolPrefixQuery(AttrDict[Any]): """ :arg query: (required) Terms you wish to find in the provided field. The last term is used in a prefix query. :arg analyzer: Analyzer used to convert the text in the query value into tokens. :arg fuzziness: Maximum edit distance allowed for matching. Can be applied to the term subqueries constructed for all terms but the final term. :arg fuzzy_rewrite: Method used to rewrite the query. Can be applied to the term subqueries constructed for all terms but the final term. :arg fuzzy_transpositions: If `true`, edits for fuzzy matching include transpositions of two adjacent characters (for example, `ab` to `ba`). Can be applied to the term subqueries constructed for all terms but the final term. Defaults to `True` if omitted. :arg max_expansions: Maximum number of terms to which the query will expand. Can be applied to the term subqueries constructed for all terms but the final term. Defaults to `50` if omitted. :arg minimum_should_match: Minimum number of clauses that must match for a document to be returned. Applied to the constructed bool query. :arg operator: Boolean logic used to interpret text in the query value. Applied to the constructed bool query. Defaults to `'or'` if omitted. :arg prefix_length: Number of beginning characters left unchanged for fuzzy matching. Can be applied to the term subqueries constructed for all terms but the final term. :arg boost: Floating point number used to decrease or increase the relevance scores of the query. Boost values are relative to the default value of 1.0. A boost value between 0 and 1.0 decreases the relevance score. A value greater than 1.0 increases the relevance score. Defaults to `1` if omitted. :arg _name: """ query: Union[str, DefaultType] analyzer: Union[str, DefaultType] fuzziness: Union[str, int, DefaultType] fuzzy_rewrite: Union[str, DefaultType] fuzzy_transpositions: Union[bool, DefaultType] max_expansions: Union[int, DefaultType] minimum_should_match: Union[int, str, DefaultType] operator: Union[Literal["and", "or"], DefaultType] prefix_length: Union[int, DefaultType] boost: Union[float, DefaultType] _name: Union[str, DefaultType] def __init__( self, *, query: Union[str, DefaultType] = DEFAULT, analyzer: Union[str, DefaultType] = DEFAULT, fuzziness: Union[str, int, DefaultType] = DEFAULT, fuzzy_rewrite: Union[str, DefaultType] = DEFAULT, fuzzy_transpositions: Union[bool, DefaultType] = DEFAULT, max_expansions: Union[int, DefaultType] = DEFAULT, minimum_should_match: Union[int, str, DefaultType] = DEFAULT, operator: Union[Literal["and", "or"], DefaultType] = DEFAULT, prefix_length: Union[int, DefaultType] = DEFAULT, boost: Union[float, DefaultType] = DEFAULT, _name: Union[str, DefaultType] = DEFAULT, **kwargs: Any, ): if query is not DEFAULT: kwargs["query"] = query if analyzer is not DEFAULT: kwargs["analyzer"] = analyzer if fuzziness is not DEFAULT: kwargs["fuzziness"] = fuzziness if fuzzy_rewrite is not DEFAULT: kwargs["fuzzy_rewrite"] = fuzzy_rewrite if fuzzy_transpositions is not DEFAULT: kwargs["fuzzy_transpositions"] = fuzzy_transpositions if max_expansions is not DEFAULT: kwargs["max_expansions"] = max_expansions if minimum_should_match is not DEFAULT: kwargs["minimum_should_match"] = minimum_should_match if operator is not DEFAULT: kwargs["operator"] = operator if prefix_length is not DEFAULT: kwargs["prefix_length"] = prefix_length if boost is not DEFAULT: kwargs["boost"] = boost if _name is not DEFAULT: kwargs["_name"] = _name super().__init__(kwargs) class MatchPhrasePrefixQuery(AttrDict[Any]): """ :arg query: (required) Text you wish to find in the provided field. :arg analyzer: Analyzer used to convert text in the query value into tokens. :arg max_expansions: Maximum number of terms to which the last provided term of the query value will expand. Defaults to `50` if omitted. :arg slop: Maximum number of positions allowed between matching tokens. :arg zero_terms_query: Indicates whether no documents are returned if the analyzer removes all tokens, such as when using a `stop` filter. Defaults to `none` if omitted. :arg boost: Floating point number used to decrease or increase the relevance scores of the query. Boost values are relative to the default value of 1.0. A boost value between 0 and 1.0 decreases the relevance score. A value greater than 1.0 increases the relevance score. Defaults to `1` if omitted. :arg _name: """ query: Union[str, DefaultType] analyzer: Union[str, DefaultType] max_expansions: Union[int, DefaultType] slop: Union[int, DefaultType] zero_terms_query: Union[Literal["all", "none"], DefaultType] boost: Union[float, DefaultType] _name: Union[str, DefaultType] def __init__( self, *, query: Union[str, DefaultType] = DEFAULT, analyzer: Union[str, DefaultType] = DEFAULT, max_expansions: Union[int, DefaultType] = DEFAULT, slop: Union[int, DefaultType] = DEFAULT, zero_terms_query: Union[Literal["all", "none"], DefaultType] = DEFAULT, boost: Union[float, DefaultType] = DEFAULT, _name: Union[str, DefaultType] = DEFAULT, **kwargs: Any, ): if query is not DEFAULT: kwargs["query"] = query if analyzer is not DEFAULT: kwargs["analyzer"] = analyzer if max_expansions is not DEFAULT: kwargs["max_expansions"] = max_expansions if slop is not DEFAULT: kwargs["slop"] = slop if zero_terms_query is not DEFAULT: kwargs["zero_terms_query"] = zero_terms_query if boost is not DEFAULT: kwargs["boost"] = boost if _name is not DEFAULT: kwargs["_name"] = _name super().__init__(kwargs) class MatchPhraseQuery(AttrDict[Any]): """ :arg query: (required) Query terms that are analyzed and turned into a phrase query. :arg analyzer: Analyzer used to convert the text in the query value into tokens. :arg slop: Maximum number of positions allowed between matching tokens. :arg zero_terms_query: Indicates whether no documents are returned if the `analyzer` removes all tokens, such as when using a `stop` filter. Defaults to `'none'` if omitted. :arg boost: Floating point number used to decrease or increase the relevance scores of the query. Boost values are relative to the default value of 1.0. A boost value between 0 and 1.0 decreases the relevance score. A value greater than 1.0 increases the relevance score. Defaults to `1` if omitted. :arg _name: """ query: Union[str, DefaultType] analyzer: Union[str, DefaultType] slop: Union[int, DefaultType] zero_terms_query: Union[Literal["all", "none"], DefaultType] boost: Union[float, DefaultType] _name: Union[str, DefaultType] def __init__( self, *, query: Union[str, DefaultType] = DEFAULT, analyzer: Union[str, DefaultType] = DEFAULT, slop: Union[int, DefaultType] = DEFAULT, zero_terms_query: Union[Literal["all", "none"], DefaultType] = DEFAULT, boost: Union[float, DefaultType] = DEFAULT, _name: Union[str, DefaultType] = DEFAULT, **kwargs: Any, ): if query is not DEFAULT: kwargs["query"] = query if analyzer is not DEFAULT: kwargs["analyzer"] = analyzer if slop is not DEFAULT: kwargs["slop"] = slop if zero_terms_query is not DEFAULT: kwargs["zero_terms_query"] = zero_terms_query if boost is not DEFAULT: kwargs["boost"] = boost if _name is not DEFAULT: kwargs["_name"] = _name super().__init__(kwargs) class MatchQuery(AttrDict[Any]): """ :arg query: (required) Text, number, boolean value or date you wish to find in the provided field. :arg analyzer: Analyzer used to convert the text in the query value into tokens. :arg auto_generate_synonyms_phrase_query: If `true`, match phrase queries are automatically created for multi-term synonyms. Defaults to `True` if omitted. :arg cutoff_frequency: :arg fuzziness: Maximum edit distance allowed for matching. :arg fuzzy_rewrite: Method used to rewrite the query. :arg fuzzy_transpositions: If `true`, edits for fuzzy matching include transpositions of two adjacent characters (for example, `ab` to `ba`). Defaults to `True` if omitted. :arg lenient: If `true`, format-based errors, such as providing a text query value for a numeric field, are ignored. :arg max_expansions: Maximum number of terms to which the query will expand. Defaults to `50` if omitted. :arg minimum_should_match: Minimum number of clauses that must match for a document to be returned. :arg operator: Boolean logic used to interpret text in the query value. Defaults to `'or'` if omitted. :arg prefix_length: Number of beginning characters left unchanged for fuzzy matching. :arg zero_terms_query: Indicates whether no documents are returned if the `analyzer` removes all tokens, such as when using a `stop` filter. Defaults to `'none'` if omitted. :arg boost: Floating point number used to decrease or increase the relevance scores of the query. Boost values are relative to the default value of 1.0. A boost value between 0 and 1.0 decreases the relevance score. A value greater than 1.0 increases the relevance score. Defaults to `1` if omitted. :arg _name: """ query: Union[str, float, bool, DefaultType] analyzer: Union[str, DefaultType] auto_generate_synonyms_phrase_query: Union[bool, DefaultType] cutoff_frequency: Union[float, DefaultType] fuzziness: Union[str, int, DefaultType] fuzzy_rewrite: Union[str, DefaultType] fuzzy_transpositions: Union[bool, DefaultType] lenient: Union[bool, DefaultType] max_expansions: Union[int, DefaultType] minimum_should_match: Union[int, str, DefaultType] operator: Union[Literal["and", "or"], DefaultType] prefix_length: Union[int, DefaultType] zero_terms_query: Union[Literal["all", "none"], DefaultType] boost: Union[float, DefaultType] _name: Union[str, DefaultType] def __init__( self, *, query: Union[str, float, bool, DefaultType] = DEFAULT, analyzer: Union[str, DefaultType] = DEFAULT, auto_generate_synonyms_phrase_query: Union[bool, DefaultType] = DEFAULT, cutoff_frequency: Union[float, DefaultType] = DEFAULT, fuzziness: Union[str, int, DefaultType] = DEFAULT, fuzzy_rewrite: Union[str, DefaultType] = DEFAULT, fuzzy_transpositions: Union[bool, DefaultType] = DEFAULT, lenient: Union[bool, DefaultType] = DEFAULT, max_expansions: Union[int, DefaultType] = DEFAULT, minimum_should_match: Union[int, str, DefaultType] = DEFAULT, operator: Union[Literal["and", "or"], DefaultType] = DEFAULT, prefix_length: Union[int, DefaultType] = DEFAULT, zero_terms_query: Union[Literal["all", "none"], DefaultType] = DEFAULT, boost: Union[float, DefaultType] = DEFAULT, _name: Union[str, DefaultType] = DEFAULT, **kwargs: Any, ): if query is not DEFAULT: kwargs["query"] = query if analyzer is not DEFAULT: kwargs["analyzer"] = analyzer if auto_generate_synonyms_phrase_query is not DEFAULT: kwargs["auto_generate_synonyms_phrase_query"] = ( auto_generate_synonyms_phrase_query ) if cutoff_frequency is not DEFAULT: kwargs["cutoff_frequency"] = cutoff_frequency if fuzziness is not DEFAULT: kwargs["fuzziness"] = fuzziness if fuzzy_rewrite is not DEFAULT: kwargs["fuzzy_rewrite"] = fuzzy_rewrite if fuzzy_transpositions is not DEFAULT: kwargs["fuzzy_transpositions"] = fuzzy_transpositions if lenient is not DEFAULT: kwargs["lenient"] = lenient if max_expansions is not DEFAULT: kwargs["max_expansions"] = max_expansions if minimum_should_match is not DEFAULT: kwargs["minimum_should_match"] = minimum_should_match if operator is not DEFAULT: kwargs["operator"] = operator if prefix_length is not DEFAULT: kwargs["prefix_length"] = prefix_length if zero_terms_query is not DEFAULT: kwargs["zero_terms_query"] = zero_terms_query if boost is not DEFAULT: kwargs["boost"] = boost if _name is not DEFAULT: kwargs["_name"] = _name super().__init__(kwargs) class MultiTermLookup(AttrDict[Any]): """ :arg field: (required) A fields from which to retrieve terms. :arg missing: The value to apply to documents that do not have a value. By default, documents without a value are ignored. """ field: Union[str, InstrumentedField, DefaultType] missing: Union[str, int, float, bool, DefaultType] def __init__( self, *, field: Union[str, InstrumentedField, DefaultType] = DEFAULT, missing: Union[str, int, float, bool, DefaultType] = DEFAULT, **kwargs: Any, ): if field is not DEFAULT: kwargs["field"] = str(field) if missing is not DEFAULT: kwargs["missing"] = missing super().__init__(kwargs) class MutualInformationHeuristic(AttrDict[Any]): """ :arg background_is_superset: Set to `false` if you defined a custom background filter that represents a different set of documents that you want to compare to. :arg include_negatives: Set to `false` to filter out the terms that appear less often in the subset than in documents outside the subset. """ background_is_superset: Union[bool, DefaultType] include_negatives: Union[bool, DefaultType] def __init__( self, *, background_is_superset: Union[bool, DefaultType] = DEFAULT, include_negatives: Union[bool, DefaultType] = DEFAULT, **kwargs: Any, ): if background_is_superset is not DEFAULT: kwargs["background_is_superset"] = background_is_superset if include_negatives is not DEFAULT: kwargs["include_negatives"] = include_negatives super().__init__(kwargs) class NestedSortValue(AttrDict[Any]): """ :arg path: (required) :arg filter: :arg max_children: :arg nested: """ path: Union[str, InstrumentedField, DefaultType] filter: Union[Query, DefaultType] max_children: Union[int, DefaultType] nested: Union["NestedSortValue", Dict[str, Any], DefaultType] def __init__( self, *, path: Union[str, InstrumentedField, DefaultType] = DEFAULT, filter: Union[Query, DefaultType] = DEFAULT, max_children: Union[int, DefaultType] = DEFAULT, nested: Union["NestedSortValue", Dict[str, Any], DefaultType] = DEFAULT, **kwargs: Any, ): if path is not DEFAULT: kwargs["path"] = str(path) if filter is not DEFAULT: kwargs["filter"] = filter if max_children is not DEFAULT: kwargs["max_children"] = max_children if nested is not DEFAULT: kwargs["nested"] = nested super().__init__(kwargs) class NumericFielddata(AttrDict[Any]): """ :arg format: (required) """ format: Union[Literal["array", "disabled"], DefaultType] def __init__( self, *, format: Union[Literal["array", "disabled"], DefaultType] = DEFAULT, **kwargs: Any, ): if format is not DEFAULT: kwargs["format"] = format super().__init__(kwargs) class PercentageScoreHeuristic(AttrDict[Any]): pass class PinnedDoc(AttrDict[Any]): """ :arg _id: (required) The unique document ID. :arg _index: The index that contains the document. """ _id: Union[str, DefaultType] _index: Union[str, DefaultType] def __init__( self, *, _id: Union[str, DefaultType] = DEFAULT, _index: Union[str, DefaultType] = DEFAULT, **kwargs: Any, ): if _id is not DEFAULT: kwargs["_id"] = _id if _index is not DEFAULT: kwargs["_index"] = _index super().__init__(kwargs) class PrefixQuery(AttrDict[Any]): """ :arg value: (required) Beginning characters of terms you wish to find in the provided field. :arg rewrite: Method used to rewrite the query. :arg case_insensitive: Allows ASCII case insensitive matching of the value with the indexed field values when set to `true`. Default is `false` which means the case sensitivity of matching depends on the underlying field’s mapping. :arg boost: Floating point number used to decrease or increase the relevance scores of the query. Boost values are relative to the default value of 1.0. A boost value between 0 and 1.0 decreases the relevance score. A value greater than 1.0 increases the relevance score. Defaults to `1` if omitted. :arg _name: """ value: Union[str, DefaultType] rewrite: Union[str, DefaultType] case_insensitive: Union[bool, DefaultType] boost: Union[float, DefaultType] _name: Union[str, DefaultType] def __init__( self, *, value: Union[str, DefaultType] = DEFAULT, rewrite: Union[str, DefaultType] = DEFAULT, case_insensitive: Union[bool, DefaultType] = DEFAULT, boost: Union[float, DefaultType] = DEFAULT, _name: Union[str, DefaultType] = DEFAULT, **kwargs: Any, ): if value is not DEFAULT: kwargs["value"] = value if rewrite is not DEFAULT: kwargs["rewrite"] = rewrite if case_insensitive is not DEFAULT: kwargs["case_insensitive"] = case_insensitive if boost is not DEFAULT: kwargs["boost"] = boost if _name is not DEFAULT: kwargs["_name"] = _name super().__init__(kwargs) class QueryVectorBuilder(AttrDict[Any]): """ :arg text_embedding: """ text_embedding: Union["TextEmbedding", Dict[str, Any], DefaultType] def __init__( self, *, text_embedding: Union["TextEmbedding", Dict[str, Any], DefaultType] = DEFAULT, **kwargs: Any, ): if text_embedding is not DEFAULT: kwargs["text_embedding"] = text_embedding super().__init__(kwargs) class RankFeatureFunctionLinear(AttrDict[Any]): pass class RankFeatureFunctionLogarithm(AttrDict[Any]): """ :arg scaling_factor: (required) Configurable scaling factor. """ scaling_factor: Union[float, DefaultType] def __init__( self, *, scaling_factor: Union[float, DefaultType] = DEFAULT, **kwargs: Any ): if scaling_factor is not DEFAULT: kwargs["scaling_factor"] = scaling_factor super().__init__(kwargs) class RankFeatureFunctionSaturation(AttrDict[Any]): """ :arg pivot: Configurable pivot value so that the result will be less than 0.5. """ pivot: Union[float, DefaultType] def __init__(self, *, pivot: Union[float, DefaultType] = DEFAULT, **kwargs: Any): if pivot is not DEFAULT: kwargs["pivot"] = pivot super().__init__(kwargs) class RankFeatureFunctionSigmoid(AttrDict[Any]): """ :arg pivot: (required) Configurable pivot value so that the result will be less than 0.5. :arg exponent: (required) Configurable Exponent. """ pivot: Union[float, DefaultType] exponent: Union[float, DefaultType] def __init__( self, *, pivot: Union[float, DefaultType] = DEFAULT, exponent: Union[float, DefaultType] = DEFAULT, **kwargs: Any, ): if pivot is not DEFAULT: kwargs["pivot"] = pivot if exponent is not DEFAULT: kwargs["exponent"] = exponent super().__init__(kwargs) class RegexpQuery(AttrDict[Any]): """ :arg value: (required) Regular expression for terms you wish to find in the provided field. :arg case_insensitive: Allows case insensitive matching of the regular expression value with the indexed field values when set to `true`. When `false`, case sensitivity of matching depends on the underlying field’s mapping. :arg flags: Enables optional operators for the regular expression. :arg max_determinized_states: Maximum number of automaton states required for the query. Defaults to `10000` if omitted. :arg rewrite: Method used to rewrite the query. :arg boost: Floating point number used to decrease or increase the relevance scores of the query. Boost values are relative to the default value of 1.0. A boost value between 0 and 1.0 decreases the relevance score. A value greater than 1.0 increases the relevance score. Defaults to `1` if omitted. :arg _name: """ value: Union[str, DefaultType] case_insensitive: Union[bool, DefaultType] flags: Union[str, DefaultType] max_determinized_states: Union[int, DefaultType] rewrite: Union[str, DefaultType] boost: Union[float, DefaultType] _name: Union[str, DefaultType] def __init__( self, *, value: Union[str, DefaultType] = DEFAULT, case_insensitive: Union[bool, DefaultType] = DEFAULT, flags: Union[str, DefaultType] = DEFAULT, max_determinized_states: Union[int, DefaultType] = DEFAULT, rewrite: Union[str, DefaultType] = DEFAULT, boost: Union[float, DefaultType] = DEFAULT, _name: Union[str, DefaultType] = DEFAULT, **kwargs: Any, ): if value is not DEFAULT: kwargs["value"] = value if case_insensitive is not DEFAULT: kwargs["case_insensitive"] = case_insensitive if flags is not DEFAULT: kwargs["flags"] = flags if max_determinized_states is not DEFAULT: kwargs["max_determinized_states"] = max_determinized_states if rewrite is not DEFAULT: kwargs["rewrite"] = rewrite if boost is not DEFAULT: kwargs["boost"] = boost if _name is not DEFAULT: kwargs["_name"] = _name super().__init__(kwargs) class RegressionInferenceOptions(AttrDict[Any]): """ :arg results_field: The field that is added to incoming documents to contain the inference prediction. Defaults to predicted_value. :arg num_top_feature_importance_values: Specifies the maximum number of feature importance values per document. """ results_field: Union[str, InstrumentedField, DefaultType] num_top_feature_importance_values: Union[int, DefaultType] def __init__( self, *, results_field: Union[str, InstrumentedField, DefaultType] = DEFAULT, num_top_feature_importance_values: Union[int, DefaultType] = DEFAULT, **kwargs: Any, ): if results_field is not DEFAULT: kwargs["results_field"] = str(results_field) if num_top_feature_importance_values is not DEFAULT: kwargs["num_top_feature_importance_values"] = ( num_top_feature_importance_values ) super().__init__(kwargs) class RescoreVector(AttrDict[Any]): """ :arg oversample: (required) Applies the specified oversample factor to k on the approximate kNN search """ oversample: Union[float, DefaultType] def __init__( self, *, oversample: Union[float, DefaultType] = DEFAULT, **kwargs: Any ): if oversample is not DEFAULT: kwargs["oversample"] = oversample super().__init__(kwargs) class ScoreSort(AttrDict[Any]): """ :arg order: """ order: Union[Literal["asc", "desc"], DefaultType] def __init__( self, *, order: Union[Literal["asc", "desc"], DefaultType] = DEFAULT, **kwargs: Any, ): if order is not DEFAULT: kwargs["order"] = order super().__init__(kwargs) class Script(AttrDict[Any]): """ :arg source: The script source. :arg id: The `id` for a stored script. :arg params: Specifies any named parameters that are passed into the script as variables. Use parameters instead of hard-coded values to decrease compile time. :arg lang: Specifies the language the script is written in. Defaults to `painless` if omitted. :arg options: """ source: Union[str, Dict[str, Any], DefaultType] id: Union[str, DefaultType] params: Union[Mapping[str, Any], DefaultType] lang: Union[Literal["painless", "expression", "mustache", "java"], DefaultType] options: Union[Mapping[str, str], DefaultType] def __init__( self, *, source: Union[str, Dict[str, Any], DefaultType] = DEFAULT, id: Union[str, DefaultType] = DEFAULT, params: Union[Mapping[str, Any], DefaultType] = DEFAULT, lang: Union[ Literal["painless", "expression", "mustache", "java"], DefaultType ] = DEFAULT, options: Union[Mapping[str, str], DefaultType] = DEFAULT, **kwargs: Any, ): if source is not DEFAULT: kwargs["source"] = source if id is not DEFAULT: kwargs["id"] = id if params is not DEFAULT: kwargs["params"] = params if lang is not DEFAULT: kwargs["lang"] = lang if options is not DEFAULT: kwargs["options"] = options super().__init__(kwargs) class ScriptField(AttrDict[Any]): """ :arg script: (required) :arg ignore_failure: """ script: Union["Script", Dict[str, Any], DefaultType] ignore_failure: Union[bool, DefaultType] def __init__( self, *, script: Union["Script", Dict[str, Any], DefaultType] = DEFAULT, ignore_failure: Union[bool, DefaultType] = DEFAULT, **kwargs: Any, ): if script is not DEFAULT: kwargs["script"] = script if ignore_failure is not DEFAULT: kwargs["ignore_failure"] = ignore_failure super().__init__(kwargs) class ScriptSort(AttrDict[Any]): """ :arg script: (required) :arg order: :arg type: :arg mode: :arg nested: """ script: Union["Script", Dict[str, Any], DefaultType] order: Union[Literal["asc", "desc"], DefaultType] type: Union[Literal["string", "number", "version"], DefaultType] mode: Union[Literal["min", "max", "sum", "avg", "median"], DefaultType] nested: Union["NestedSortValue", Dict[str, Any], DefaultType] def __init__( self, *, script: Union["Script", Dict[str, Any], DefaultType] = DEFAULT, order: Union[Literal["asc", "desc"], DefaultType] = DEFAULT, type: Union[Literal["string", "number", "version"], DefaultType] = DEFAULT, mode: Union[ Literal["min", "max", "sum", "avg", "median"], DefaultType ] = DEFAULT, nested: Union["NestedSortValue", Dict[str, Any], DefaultType] = DEFAULT, **kwargs: Any, ): if script is not DEFAULT: kwargs["script"] = script if order is not DEFAULT: kwargs["order"] = order if type is not DEFAULT: kwargs["type"] = type if mode is not DEFAULT: kwargs["mode"] = mode if nested is not DEFAULT: kwargs["nested"] = nested super().__init__(kwargs) class ScriptedHeuristic(AttrDict[Any]): """ :arg script: (required) """ script: Union["Script", Dict[str, Any], DefaultType] def __init__( self, *, script: Union["Script", Dict[str, Any], DefaultType] = DEFAULT, **kwargs: Any, ): if script is not DEFAULT: kwargs["script"] = script super().__init__(kwargs) class ShapeFieldQuery(AttrDict[Any]): """ :arg indexed_shape: Queries using a pre-indexed shape. :arg relation: Spatial relation between the query shape and the document shape. :arg shape: Queries using an inline shape definition in GeoJSON or Well Known Text (WKT) format. """ indexed_shape: Union["FieldLookup", Dict[str, Any], DefaultType] relation: Union[ Literal["intersects", "disjoint", "within", "contains"], DefaultType ] shape: Any def __init__( self, *, indexed_shape: Union["FieldLookup", Dict[str, Any], DefaultType] = DEFAULT, relation: Union[ Literal["intersects", "disjoint", "within", "contains"], DefaultType ] = DEFAULT, shape: Any = DEFAULT, **kwargs: Any, ): if indexed_shape is not DEFAULT: kwargs["indexed_shape"] = indexed_shape if relation is not DEFAULT: kwargs["relation"] = relation if shape is not DEFAULT: kwargs["shape"] = shape super().__init__(kwargs) class SortOptions(AttrDict[Any]): """ :arg _field: The field to use in this query. :arg _value: The query value for the field. :arg _score: :arg _doc: :arg _geo_distance: :arg _script: """ _field: Union[str, "InstrumentedField", "DefaultType"] _value: Union["FieldSort", Dict[str, Any], "DefaultType"] _score: Union["ScoreSort", Dict[str, Any], DefaultType] _doc: Union["ScoreSort", Dict[str, Any], DefaultType] _geo_distance: Union["GeoDistanceSort", Dict[str, Any], DefaultType] _script: Union["ScriptSort", Dict[str, Any], DefaultType] def __init__( self, _field: Union[str, "InstrumentedField", "DefaultType"] = DEFAULT, _value: Union["FieldSort", Dict[str, Any], "DefaultType"] = DEFAULT, *, _score: Union["ScoreSort", Dict[str, Any], DefaultType] = DEFAULT, _doc: Union["ScoreSort", Dict[str, Any], DefaultType] = DEFAULT, _geo_distance: Union["GeoDistanceSort", Dict[str, Any], DefaultType] = DEFAULT, _script: Union["ScriptSort", Dict[str, Any], DefaultType] = DEFAULT, **kwargs: Any, ): if _field is not DEFAULT: kwargs[str(_field)] = _value if _score is not DEFAULT: kwargs["_score"] = _score if _doc is not DEFAULT: kwargs["_doc"] = _doc if _geo_distance is not DEFAULT: kwargs["_geo_distance"] = _geo_distance if _script is not DEFAULT: kwargs["_script"] = _script super().__init__(kwargs) class SourceFilter(AttrDict[Any]): """ :arg excludes: :arg includes: """ excludes: Union[ Union[str, InstrumentedField], Sequence[Union[str, InstrumentedField]], DefaultType, ] includes: Union[ Union[str, InstrumentedField], Sequence[Union[str, InstrumentedField]], DefaultType, ] def __init__( self, *, excludes: Union[ Union[str, InstrumentedField], Sequence[Union[str, InstrumentedField]], DefaultType, ] = DEFAULT, includes: Union[ Union[str, InstrumentedField], Sequence[Union[str, InstrumentedField]], DefaultType, ] = DEFAULT, **kwargs: Any, ): if excludes is not DEFAULT: kwargs["excludes"] = str(excludes) if includes is not DEFAULT: kwargs["includes"] = str(includes) super().__init__(kwargs) class SpanContainingQuery(AttrDict[Any]): """ :arg big: (required) Can be any span query. Matching spans from `big` that contain matches from `little` are returned. :arg little: (required) Can be any span query. Matching spans from `big` that contain matches from `little` are returned. :arg boost: Floating point number used to decrease or increase the relevance scores of the query. Boost values are relative to the default value of 1.0. A boost value between 0 and 1.0 decreases the relevance score. A value greater than 1.0 increases the relevance score. Defaults to `1` if omitted. :arg _name: """ big: Union["SpanQuery", Dict[str, Any], DefaultType] little: Union["SpanQuery", Dict[str, Any], DefaultType] boost: Union[float, DefaultType] _name: Union[str, DefaultType] def __init__( self, *, big: Union["SpanQuery", Dict[str, Any], DefaultType] = DEFAULT, little: Union["SpanQuery", Dict[str, Any], DefaultType] = DEFAULT, boost: Union[float, DefaultType] = DEFAULT, _name: Union[str, DefaultType] = DEFAULT, **kwargs: Any, ): if big is not DEFAULT: kwargs["big"] = big if little is not DEFAULT: kwargs["little"] = little if boost is not DEFAULT: kwargs["boost"] = boost if _name is not DEFAULT: kwargs["_name"] = _name super().__init__(kwargs) class SpanFieldMaskingQuery(AttrDict[Any]): """ :arg field: (required) :arg query: (required) :arg boost: Floating point number used to decrease or increase the relevance scores of the query. Boost values are relative to the default value of 1.0. A boost value between 0 and 1.0 decreases the relevance score. A value greater than 1.0 increases the relevance score. Defaults to `1` if omitted. :arg _name: """ field: Union[str, InstrumentedField, DefaultType] query: Union["SpanQuery", Dict[str, Any], DefaultType] boost: Union[float, DefaultType] _name: Union[str, DefaultType] def __init__( self, *, field: Union[str, InstrumentedField, DefaultType] = DEFAULT, query: Union["SpanQuery", Dict[str, Any], DefaultType] = DEFAULT, boost: Union[float, DefaultType] = DEFAULT, _name: Union[str, DefaultType] = DEFAULT, **kwargs: Any, ): if field is not DEFAULT: kwargs["field"] = str(field) if query is not DEFAULT: kwargs["query"] = query if boost is not DEFAULT: kwargs["boost"] = boost if _name is not DEFAULT: kwargs["_name"] = _name super().__init__(kwargs) class SpanFirstQuery(AttrDict[Any]): """ :arg end: (required) Controls the maximum end position permitted in a match. :arg match: (required) Can be any other span type query. :arg boost: Floating point number used to decrease or increase the relevance scores of the query. Boost values are relative to the default value of 1.0. A boost value between 0 and 1.0 decreases the relevance score. A value greater than 1.0 increases the relevance score. Defaults to `1` if omitted. :arg _name: """ end: Union[int, DefaultType] match: Union["SpanQuery", Dict[str, Any], DefaultType] boost: Union[float, DefaultType] _name: Union[str, DefaultType] def __init__( self, *, end: Union[int, DefaultType] = DEFAULT, match: Union["SpanQuery", Dict[str, Any], DefaultType] = DEFAULT, boost: Union[float, DefaultType] = DEFAULT, _name: Union[str, DefaultType] = DEFAULT, **kwargs: Any, ): if end is not DEFAULT: kwargs["end"] = end if match is not DEFAULT: kwargs["match"] = match if boost is not DEFAULT: kwargs["boost"] = boost if _name is not DEFAULT: kwargs["_name"] = _name super().__init__(kwargs) class SpanMultiTermQuery(AttrDict[Any]): """ :arg match: (required) Should be a multi term query (one of `wildcard`, `fuzzy`, `prefix`, `range`, or `regexp` query). :arg boost: Floating point number used to decrease or increase the relevance scores of the query. Boost values are relative to the default value of 1.0. A boost value between 0 and 1.0 decreases the relevance score. A value greater than 1.0 increases the relevance score. Defaults to `1` if omitted. :arg _name: """ match: Union[Query, DefaultType] boost: Union[float, DefaultType] _name: Union[str, DefaultType] def __init__( self, *, match: Union[Query, DefaultType] = DEFAULT, boost: Union[float, DefaultType] = DEFAULT, _name: Union[str, DefaultType] = DEFAULT, **kwargs: Any, ): if match is not DEFAULT: kwargs["match"] = match if boost is not DEFAULT: kwargs["boost"] = boost if _name is not DEFAULT: kwargs["_name"] = _name super().__init__(kwargs) class SpanNearQuery(AttrDict[Any]): """ :arg clauses: (required) Array of one or more other span type queries. :arg in_order: Controls whether matches are required to be in-order. :arg slop: Controls the maximum number of intervening unmatched positions permitted. :arg boost: Floating point number used to decrease or increase the relevance scores of the query. Boost values are relative to the default value of 1.0. A boost value between 0 and 1.0 decreases the relevance score. A value greater than 1.0 increases the relevance score. Defaults to `1` if omitted. :arg _name: """ clauses: Union[Sequence["SpanQuery"], Sequence[Dict[str, Any]], DefaultType] in_order: Union[bool, DefaultType] slop: Union[int, DefaultType] boost: Union[float, DefaultType] _name: Union[str, DefaultType] def __init__( self, *, clauses: Union[ Sequence["SpanQuery"], Sequence[Dict[str, Any]], DefaultType ] = DEFAULT, in_order: Union[bool, DefaultType] = DEFAULT, slop: Union[int, DefaultType] = DEFAULT, boost: Union[float, DefaultType] = DEFAULT, _name: Union[str, DefaultType] = DEFAULT, **kwargs: Any, ): if clauses is not DEFAULT: kwargs["clauses"] = clauses if in_order is not DEFAULT: kwargs["in_order"] = in_order if slop is not DEFAULT: kwargs["slop"] = slop if boost is not DEFAULT: kwargs["boost"] = boost if _name is not DEFAULT: kwargs["_name"] = _name super().__init__(kwargs) class SpanNotQuery(AttrDict[Any]): """ :arg exclude: (required) Span query whose matches must not overlap those returned. :arg include: (required) Span query whose matches are filtered. :arg dist: The number of tokens from within the include span that can’t have overlap with the exclude span. Equivalent to setting both `pre` and `post`. :arg post: The number of tokens after the include span that can’t have overlap with the exclude span. :arg pre: The number of tokens before the include span that can’t have overlap with the exclude span. :arg boost: Floating point number used to decrease or increase the relevance scores of the query. Boost values are relative to the default value of 1.0. A boost value between 0 and 1.0 decreases the relevance score. A value greater than 1.0 increases the relevance score. Defaults to `1` if omitted. :arg _name: """ exclude: Union["SpanQuery", Dict[str, Any], DefaultType] include: Union["SpanQuery", Dict[str, Any], DefaultType] dist: Union[int, DefaultType] post: Union[int, DefaultType] pre: Union[int, DefaultType] boost: Union[float, DefaultType] _name: Union[str, DefaultType] def __init__( self, *, exclude: Union["SpanQuery", Dict[str, Any], DefaultType] = DEFAULT, include: Union["SpanQuery", Dict[str, Any], DefaultType] = DEFAULT, dist: Union[int, DefaultType] = DEFAULT, post: Union[int, DefaultType] = DEFAULT, pre: Union[int, DefaultType] = DEFAULT, boost: Union[float, DefaultType] = DEFAULT, _name: Union[str, DefaultType] = DEFAULT, **kwargs: Any, ): if exclude is not DEFAULT: kwargs["exclude"] = exclude if include is not DEFAULT: kwargs["include"] = include if dist is not DEFAULT: kwargs["dist"] = dist if post is not DEFAULT: kwargs["post"] = post if pre is not DEFAULT: kwargs["pre"] = pre if boost is not DEFAULT: kwargs["boost"] = boost if _name is not DEFAULT: kwargs["_name"] = _name super().__init__(kwargs) class SpanOrQuery(AttrDict[Any]): """ :arg clauses: (required) Array of one or more other span type queries. :arg boost: Floating point number used to decrease or increase the relevance scores of the query. Boost values are relative to the default value of 1.0. A boost value between 0 and 1.0 decreases the relevance score. A value greater than 1.0 increases the relevance score. Defaults to `1` if omitted. :arg _name: """ clauses: Union[Sequence["SpanQuery"], Sequence[Dict[str, Any]], DefaultType] boost: Union[float, DefaultType] _name: Union[str, DefaultType] def __init__( self, *, clauses: Union[ Sequence["SpanQuery"], Sequence[Dict[str, Any]], DefaultType ] = DEFAULT, boost: Union[float, DefaultType] = DEFAULT, _name: Union[str, DefaultType] = DEFAULT, **kwargs: Any, ): if clauses is not DEFAULT: kwargs["clauses"] = clauses if boost is not DEFAULT: kwargs["boost"] = boost if _name is not DEFAULT: kwargs["_name"] = _name super().__init__(kwargs) class SpanQuery(AttrDict[Any]): """ :arg span_containing: Accepts a list of span queries, but only returns those spans which also match a second span query. :arg span_field_masking: Allows queries like `span_near` or `span_or` across different fields. :arg span_first: Accepts another span query whose matches must appear within the first N positions of the field. :arg span_gap: :arg span_multi: Wraps a `term`, `range`, `prefix`, `wildcard`, `regexp`, or `fuzzy` query. :arg span_near: Accepts multiple span queries whose matches must be within the specified distance of each other, and possibly in the same order. :arg span_not: Wraps another span query, and excludes any documents which match that query. :arg span_or: Combines multiple span queries and returns documents which match any of the specified queries. :arg span_term: The equivalent of the `term` query but for use with other span queries. :arg span_within: The result from a single span query is returned as long is its span falls within the spans returned by a list of other span queries. """ span_containing: Union["SpanContainingQuery", Dict[str, Any], DefaultType] span_field_masking: Union["SpanFieldMaskingQuery", Dict[str, Any], DefaultType] span_first: Union["SpanFirstQuery", Dict[str, Any], DefaultType] span_gap: Union[Mapping[Union[str, InstrumentedField], int], DefaultType] span_multi: Union["SpanMultiTermQuery", Dict[str, Any], DefaultType] span_near: Union["SpanNearQuery", Dict[str, Any], DefaultType] span_not: Union["SpanNotQuery", Dict[str, Any], DefaultType] span_or: Union["SpanOrQuery", Dict[str, Any], DefaultType] span_term: Union[ Mapping[Union[str, InstrumentedField], "SpanTermQuery"], Dict[str, Any], DefaultType, ] span_within: Union["SpanWithinQuery", Dict[str, Any], DefaultType] def __init__( self, *, span_containing: Union[ "SpanContainingQuery", Dict[str, Any], DefaultType ] = DEFAULT, span_field_masking: Union[ "SpanFieldMaskingQuery", Dict[str, Any], DefaultType ] = DEFAULT, span_first: Union["SpanFirstQuery", Dict[str, Any], DefaultType] = DEFAULT, span_gap: Union[ Mapping[Union[str, InstrumentedField], int], DefaultType ] = DEFAULT, span_multi: Union["SpanMultiTermQuery", Dict[str, Any], DefaultType] = DEFAULT, span_near: Union["SpanNearQuery", Dict[str, Any], DefaultType] = DEFAULT, span_not: Union["SpanNotQuery", Dict[str, Any], DefaultType] = DEFAULT, span_or: Union["SpanOrQuery", Dict[str, Any], DefaultType] = DEFAULT, span_term: Union[ Mapping[Union[str, InstrumentedField], "SpanTermQuery"], Dict[str, Any], DefaultType, ] = DEFAULT, span_within: Union["SpanWithinQuery", Dict[str, Any], DefaultType] = DEFAULT, **kwargs: Any, ): if span_containing is not DEFAULT: kwargs["span_containing"] = span_containing if span_field_masking is not DEFAULT: kwargs["span_field_masking"] = span_field_masking if span_first is not DEFAULT: kwargs["span_first"] = span_first if span_gap is not DEFAULT: kwargs["span_gap"] = str(span_gap) if span_multi is not DEFAULT: kwargs["span_multi"] = span_multi if span_near is not DEFAULT: kwargs["span_near"] = span_near if span_not is not DEFAULT: kwargs["span_not"] = span_not if span_or is not DEFAULT: kwargs["span_or"] = span_or if span_term is not DEFAULT: kwargs["span_term"] = str(span_term) if span_within is not DEFAULT: kwargs["span_within"] = span_within super().__init__(kwargs) class SpanTermQuery(AttrDict[Any]): """ :arg value: (required) :arg boost: Floating point number used to decrease or increase the relevance scores of the query. Boost values are relative to the default value of 1.0. A boost value between 0 and 1.0 decreases the relevance score. A value greater than 1.0 increases the relevance score. Defaults to `1` if omitted. :arg _name: """ value: Union[int, float, str, bool, None, DefaultType] boost: Union[float, DefaultType] _name: Union[str, DefaultType] def __init__( self, *, value: Union[int, float, str, bool, None, DefaultType] = DEFAULT, boost: Union[float, DefaultType] = DEFAULT, _name: Union[str, DefaultType] = DEFAULT, **kwargs: Any, ): if value is not DEFAULT: kwargs["value"] = value if boost is not DEFAULT: kwargs["boost"] = boost if _name is not DEFAULT: kwargs["_name"] = _name super().__init__(kwargs) class SpanWithinQuery(AttrDict[Any]): """ :arg big: (required) Can be any span query. Matching spans from `little` that are enclosed within `big` are returned. :arg little: (required) Can be any span query. Matching spans from `little` that are enclosed within `big` are returned. :arg boost: Floating point number used to decrease or increase the relevance scores of the query. Boost values are relative to the default value of 1.0. A boost value between 0 and 1.0 decreases the relevance score. A value greater than 1.0 increases the relevance score. Defaults to `1` if omitted. :arg _name: """ big: Union["SpanQuery", Dict[str, Any], DefaultType] little: Union["SpanQuery", Dict[str, Any], DefaultType] boost: Union[float, DefaultType] _name: Union[str, DefaultType] def __init__( self, *, big: Union["SpanQuery", Dict[str, Any], DefaultType] = DEFAULT, little: Union["SpanQuery", Dict[str, Any], DefaultType] = DEFAULT, boost: Union[float, DefaultType] = DEFAULT, _name: Union[str, DefaultType] = DEFAULT, **kwargs: Any, ): if big is not DEFAULT: kwargs["big"] = big if little is not DEFAULT: kwargs["little"] = little if boost is not DEFAULT: kwargs["boost"] = boost if _name is not DEFAULT: kwargs["_name"] = _name super().__init__(kwargs) class SuggestContext(AttrDict[Any]): """ :arg name: (required) :arg type: (required) :arg path: :arg precision: """ name: Union[str, DefaultType] type: Union[str, DefaultType] path: Union[str, InstrumentedField, DefaultType] precision: Union[int, str, DefaultType] def __init__( self, *, name: Union[str, DefaultType] = DEFAULT, type: Union[str, DefaultType] = DEFAULT, path: Union[str, InstrumentedField, DefaultType] = DEFAULT, precision: Union[int, str, DefaultType] = DEFAULT, **kwargs: Any, ): if name is not DEFAULT: kwargs["name"] = name if type is not DEFAULT: kwargs["type"] = type if path is not DEFAULT: kwargs["path"] = str(path) if precision is not DEFAULT: kwargs["precision"] = precision super().__init__(kwargs) class TDigest(AttrDict[Any]): """ :arg compression: Limits the maximum number of nodes used by the underlying TDigest algorithm to `20 * compression`, enabling control of memory usage and approximation error. """ compression: Union[int, DefaultType] def __init__( self, *, compression: Union[int, DefaultType] = DEFAULT, **kwargs: Any ): if compression is not DEFAULT: kwargs["compression"] = compression super().__init__(kwargs) class TermQuery(AttrDict[Any]): """ :arg value: (required) Term you wish to find in the provided field. :arg case_insensitive: Allows ASCII case insensitive matching of the value with the indexed field values when set to `true`. When `false`, the case sensitivity of matching depends on the underlying field’s mapping. :arg boost: Floating point number used to decrease or increase the relevance scores of the query. Boost values are relative to the default value of 1.0. A boost value between 0 and 1.0 decreases the relevance score. A value greater than 1.0 increases the relevance score. Defaults to `1` if omitted. :arg _name: """ value: Union[int, float, str, bool, None, DefaultType] case_insensitive: Union[bool, DefaultType] boost: Union[float, DefaultType] _name: Union[str, DefaultType] def __init__( self, *, value: Union[int, float, str, bool, None, DefaultType] = DEFAULT, case_insensitive: Union[bool, DefaultType] = DEFAULT, boost: Union[float, DefaultType] = DEFAULT, _name: Union[str, DefaultType] = DEFAULT, **kwargs: Any, ): if value is not DEFAULT: kwargs["value"] = value if case_insensitive is not DEFAULT: kwargs["case_insensitive"] = case_insensitive if boost is not DEFAULT: kwargs["boost"] = boost if _name is not DEFAULT: kwargs["_name"] = _name super().__init__(kwargs) class TermsLookup(AttrDict[Any]): """ :arg index: (required) :arg id: (required) :arg path: (required) :arg routing: """ index: Union[str, DefaultType] id: Union[str, DefaultType] path: Union[str, InstrumentedField, DefaultType] routing: Union[str, DefaultType] def __init__( self, *, index: Union[str, DefaultType] = DEFAULT, id: Union[str, DefaultType] = DEFAULT, path: Union[str, InstrumentedField, DefaultType] = DEFAULT, routing: Union[str, DefaultType] = DEFAULT, **kwargs: Any, ): if index is not DEFAULT: kwargs["index"] = index if id is not DEFAULT: kwargs["id"] = id if path is not DEFAULT: kwargs["path"] = str(path) if routing is not DEFAULT: kwargs["routing"] = routing super().__init__(kwargs) class TermsPartition(AttrDict[Any]): """ :arg num_partitions: (required) The number of partitions. :arg partition: (required) The partition number for this request. """ num_partitions: Union[int, DefaultType] partition: Union[int, DefaultType] def __init__( self, *, num_partitions: Union[int, DefaultType] = DEFAULT, partition: Union[int, DefaultType] = DEFAULT, **kwargs: Any, ): if num_partitions is not DEFAULT: kwargs["num_partitions"] = num_partitions if partition is not DEFAULT: kwargs["partition"] = partition super().__init__(kwargs) class TermsSetQuery(AttrDict[Any]): """ :arg terms: (required) Array of terms you wish to find in the provided field. :arg minimum_should_match: Specification describing number of matching terms required to return a document. :arg minimum_should_match_field: Numeric field containing the number of matching terms required to return a document. :arg minimum_should_match_script: Custom script containing the number of matching terms required to return a document. :arg boost: Floating point number used to decrease or increase the relevance scores of the query. Boost values are relative to the default value of 1.0. A boost value between 0 and 1.0 decreases the relevance score. A value greater than 1.0 increases the relevance score. Defaults to `1` if omitted. :arg _name: """ terms: Union[Sequence[Union[int, float, str, bool, None]], DefaultType] minimum_should_match: Union[int, str, DefaultType] minimum_should_match_field: Union[str, InstrumentedField, DefaultType] minimum_should_match_script: Union["Script", Dict[str, Any], DefaultType] boost: Union[float, DefaultType] _name: Union[str, DefaultType] def __init__( self, *, terms: Union[ Sequence[Union[int, float, str, bool, None]], DefaultType ] = DEFAULT, minimum_should_match: Union[int, str, DefaultType] = DEFAULT, minimum_should_match_field: Union[ str, InstrumentedField, DefaultType ] = DEFAULT, minimum_should_match_script: Union[ "Script", Dict[str, Any], DefaultType ] = DEFAULT, boost: Union[float, DefaultType] = DEFAULT, _name: Union[str, DefaultType] = DEFAULT, **kwargs: Any, ): if terms is not DEFAULT: kwargs["terms"] = terms if minimum_should_match is not DEFAULT: kwargs["minimum_should_match"] = minimum_should_match if minimum_should_match_field is not DEFAULT: kwargs["minimum_should_match_field"] = str(minimum_should_match_field) if minimum_should_match_script is not DEFAULT: kwargs["minimum_should_match_script"] = minimum_should_match_script if boost is not DEFAULT: kwargs["boost"] = boost if _name is not DEFAULT: kwargs["_name"] = _name super().__init__(kwargs) class TestPopulation(AttrDict[Any]): """ :arg field: (required) The field to aggregate. :arg script: :arg filter: A filter used to define a set of records to run unpaired t-test on. """ field: Union[str, InstrumentedField, DefaultType] script: Union["Script", Dict[str, Any], DefaultType] filter: Union[Query, DefaultType] def __init__( self, *, field: Union[str, InstrumentedField, DefaultType] = DEFAULT, script: Union["Script", Dict[str, Any], DefaultType] = DEFAULT, filter: Union[Query, DefaultType] = DEFAULT, **kwargs: Any, ): if field is not DEFAULT: kwargs["field"] = str(field) if script is not DEFAULT: kwargs["script"] = script if filter is not DEFAULT: kwargs["filter"] = filter super().__init__(kwargs) class TextEmbedding(AttrDict[Any]): """ :arg model_id: (required) :arg model_text: (required) """ model_id: Union[str, DefaultType] model_text: Union[str, DefaultType] def __init__( self, *, model_id: Union[str, DefaultType] = DEFAULT, model_text: Union[str, DefaultType] = DEFAULT, **kwargs: Any, ): if model_id is not DEFAULT: kwargs["model_id"] = model_id if model_text is not DEFAULT: kwargs["model_text"] = model_text super().__init__(kwargs) class TextExpansionQuery(AttrDict[Any]): """ :arg model_id: (required) The text expansion NLP model to use :arg model_text: (required) The query text :arg pruning_config: Token pruning configurations :arg boost: Floating point number used to decrease or increase the relevance scores of the query. Boost values are relative to the default value of 1.0. A boost value between 0 and 1.0 decreases the relevance score. A value greater than 1.0 increases the relevance score. Defaults to `1` if omitted. :arg _name: """ model_id: Union[str, DefaultType] model_text: Union[str, DefaultType] pruning_config: Union["TokenPruningConfig", Dict[str, Any], DefaultType] boost: Union[float, DefaultType] _name: Union[str, DefaultType] def __init__( self, *, model_id: Union[str, DefaultType] = DEFAULT, model_text: Union[str, DefaultType] = DEFAULT, pruning_config: Union[ "TokenPruningConfig", Dict[str, Any], DefaultType ] = DEFAULT, boost: Union[float, DefaultType] = DEFAULT, _name: Union[str, DefaultType] = DEFAULT, **kwargs: Any, ): if model_id is not DEFAULT: kwargs["model_id"] = model_id if model_text is not DEFAULT: kwargs["model_text"] = model_text if pruning_config is not DEFAULT: kwargs["pruning_config"] = pruning_config if boost is not DEFAULT: kwargs["boost"] = boost if _name is not DEFAULT: kwargs["_name"] = _name super().__init__(kwargs) class TextIndexPrefixes(AttrDict[Any]): """ :arg max_chars: (required) :arg min_chars: (required) """ max_chars: Union[int, DefaultType] min_chars: Union[int, DefaultType] def __init__( self, *, max_chars: Union[int, DefaultType] = DEFAULT, min_chars: Union[int, DefaultType] = DEFAULT, **kwargs: Any, ): if max_chars is not DEFAULT: kwargs["max_chars"] = max_chars if min_chars is not DEFAULT: kwargs["min_chars"] = min_chars super().__init__(kwargs) class TokenPruningConfig(AttrDict[Any]): """ :arg tokens_freq_ratio_threshold: Tokens whose frequency is more than this threshold times the average frequency of all tokens in the specified field are considered outliers and pruned. Defaults to `5` if omitted. :arg tokens_weight_threshold: Tokens whose weight is less than this threshold are considered nonsignificant and pruned. Defaults to `0.4` if omitted. :arg only_score_pruned_tokens: Whether to only score pruned tokens, vs only scoring kept tokens. """ tokens_freq_ratio_threshold: Union[int, DefaultType] tokens_weight_threshold: Union[float, DefaultType] only_score_pruned_tokens: Union[bool, DefaultType] def __init__( self, *, tokens_freq_ratio_threshold: Union[int, DefaultType] = DEFAULT, tokens_weight_threshold: Union[float, DefaultType] = DEFAULT, only_score_pruned_tokens: Union[bool, DefaultType] = DEFAULT, **kwargs: Any, ): if tokens_freq_ratio_threshold is not DEFAULT: kwargs["tokens_freq_ratio_threshold"] = tokens_freq_ratio_threshold if tokens_weight_threshold is not DEFAULT: kwargs["tokens_weight_threshold"] = tokens_weight_threshold if only_score_pruned_tokens is not DEFAULT: kwargs["only_score_pruned_tokens"] = only_score_pruned_tokens super().__init__(kwargs) class TopLeftBottomRightGeoBounds(AttrDict[Any]): """ :arg top_left: (required) :arg bottom_right: (required) """ top_left: Union[ "LatLonGeoLocation", "GeoHashLocation", Sequence[float], str, Dict[str, Any], DefaultType, ] bottom_right: Union[ "LatLonGeoLocation", "GeoHashLocation", Sequence[float], str, Dict[str, Any], DefaultType, ] def __init__( self, *, top_left: Union[ "LatLonGeoLocation", "GeoHashLocation", Sequence[float], str, Dict[str, Any], DefaultType, ] = DEFAULT, bottom_right: Union[ "LatLonGeoLocation", "GeoHashLocation", Sequence[float], str, Dict[str, Any], DefaultType, ] = DEFAULT, **kwargs: Any, ): if top_left is not DEFAULT: kwargs["top_left"] = top_left if bottom_right is not DEFAULT: kwargs["bottom_right"] = bottom_right super().__init__(kwargs) class TopMetricsValue(AttrDict[Any]): """ :arg field: (required) A field to return as a metric. """ field: Union[str, InstrumentedField, DefaultType] def __init__( self, *, field: Union[str, InstrumentedField, DefaultType] = DEFAULT, **kwargs: Any, ): if field is not DEFAULT: kwargs["field"] = str(field) super().__init__(kwargs) class TopRightBottomLeftGeoBounds(AttrDict[Any]): """ :arg top_right: (required) :arg bottom_left: (required) """ top_right: Union[ "LatLonGeoLocation", "GeoHashLocation", Sequence[float], str, Dict[str, Any], DefaultType, ] bottom_left: Union[ "LatLonGeoLocation", "GeoHashLocation", Sequence[float], str, Dict[str, Any], DefaultType, ] def __init__( self, *, top_right: Union[ "LatLonGeoLocation", "GeoHashLocation", Sequence[float], str, Dict[str, Any], DefaultType, ] = DEFAULT, bottom_left: Union[ "LatLonGeoLocation", "GeoHashLocation", Sequence[float], str, Dict[str, Any], DefaultType, ] = DEFAULT, **kwargs: Any, ): if top_right is not DEFAULT: kwargs["top_right"] = top_right if bottom_left is not DEFAULT: kwargs["bottom_left"] = bottom_left super().__init__(kwargs) class WeightedAverageValue(AttrDict[Any]): """ :arg field: The field from which to extract the values or weights. :arg missing: A value or weight to use if the field is missing. :arg script: """ field: Union[str, InstrumentedField, DefaultType] missing: Union[float, DefaultType] script: Union["Script", Dict[str, Any], DefaultType] def __init__( self, *, field: Union[str, InstrumentedField, DefaultType] = DEFAULT, missing: Union[float, DefaultType] = DEFAULT, script: Union["Script", Dict[str, Any], DefaultType] = DEFAULT, **kwargs: Any, ): if field is not DEFAULT: kwargs["field"] = str(field) if missing is not DEFAULT: kwargs["missing"] = missing if script is not DEFAULT: kwargs["script"] = script super().__init__(kwargs) class WeightedTokensQuery(AttrDict[Any]): """ :arg tokens: (required) The tokens representing this query :arg pruning_config: Token pruning configurations :arg boost: Floating point number used to decrease or increase the relevance scores of the query. Boost values are relative to the default value of 1.0. A boost value between 0 and 1.0 decreases the relevance score. A value greater than 1.0 increases the relevance score. Defaults to `1` if omitted. :arg _name: """ tokens: Union[Mapping[str, float], DefaultType] pruning_config: Union["TokenPruningConfig", Dict[str, Any], DefaultType] boost: Union[float, DefaultType] _name: Union[str, DefaultType] def __init__( self, *, tokens: Union[Mapping[str, float], DefaultType] = DEFAULT, pruning_config: Union[ "TokenPruningConfig", Dict[str, Any], DefaultType ] = DEFAULT, boost: Union[float, DefaultType] = DEFAULT, _name: Union[str, DefaultType] = DEFAULT, **kwargs: Any, ): if tokens is not DEFAULT: kwargs["tokens"] = tokens if pruning_config is not DEFAULT: kwargs["pruning_config"] = pruning_config if boost is not DEFAULT: kwargs["boost"] = boost if _name is not DEFAULT: kwargs["_name"] = _name super().__init__(kwargs) class WildcardQuery(AttrDict[Any]): """ :arg case_insensitive: Allows case insensitive matching of the pattern with the indexed field values when set to true. Default is false which means the case sensitivity of matching depends on the underlying field’s mapping. :arg rewrite: Method used to rewrite the query. :arg value: Wildcard pattern for terms you wish to find in the provided field. Required, when wildcard is not set. :arg wildcard: Wildcard pattern for terms you wish to find in the provided field. Required, when value is not set. :arg boost: Floating point number used to decrease or increase the relevance scores of the query. Boost values are relative to the default value of 1.0. A boost value between 0 and 1.0 decreases the relevance score. A value greater than 1.0 increases the relevance score. Defaults to `1` if omitted. :arg _name: """ case_insensitive: Union[bool, DefaultType] rewrite: Union[str, DefaultType] value: Union[str, DefaultType] wildcard: Union[str, DefaultType] boost: Union[float, DefaultType] _name: Union[str, DefaultType] def __init__( self, *, case_insensitive: Union[bool, DefaultType] = DEFAULT, rewrite: Union[str, DefaultType] = DEFAULT, value: Union[str, DefaultType] = DEFAULT, wildcard: Union[str, DefaultType] = DEFAULT, boost: Union[float, DefaultType] = DEFAULT, _name: Union[str, DefaultType] = DEFAULT, **kwargs: Any, ): if case_insensitive is not DEFAULT: kwargs["case_insensitive"] = case_insensitive if rewrite is not DEFAULT: kwargs["rewrite"] = rewrite if value is not DEFAULT: kwargs["value"] = value if wildcard is not DEFAULT: kwargs["wildcard"] = wildcard if boost is not DEFAULT: kwargs["boost"] = boost if _name is not DEFAULT: kwargs["_name"] = _name super().__init__(kwargs) class WktGeoBounds(AttrDict[Any]): """ :arg wkt: (required) """ wkt: Union[str, DefaultType] def __init__(self, *, wkt: Union[str, DefaultType] = DEFAULT, **kwargs: Any): if wkt is not DEFAULT: kwargs["wkt"] = wkt super().__init__(kwargs) class AdjacencyMatrixAggregate(AttrDict[Any]): """ :arg buckets: (required) the aggregation buckets as a list :arg meta: """ buckets: Sequence["AdjacencyMatrixBucket"] meta: Mapping[str, Any] @property def buckets_as_dict(self) -> Mapping[str, "AdjacencyMatrixBucket"]: return self.buckets # type: ignore[return-value] class AdjacencyMatrixBucket(AttrDict[Any]): """ :arg key: (required) :arg doc_count: (required) """ key: str doc_count: int class AggregationBreakdown(AttrDict[Any]): """ :arg build_aggregation: (required) :arg build_aggregation_count: (required) :arg build_leaf_collector: (required) :arg build_leaf_collector_count: (required) :arg collect: (required) :arg collect_count: (required) :arg initialize: (required) :arg initialize_count: (required) :arg reduce: (required) :arg reduce_count: (required) :arg post_collection: :arg post_collection_count: """ build_aggregation: int build_aggregation_count: int build_leaf_collector: int build_leaf_collector_count: int collect: int collect_count: int initialize: int initialize_count: int reduce: int reduce_count: int post_collection: int post_collection_count: int class AggregationProfile(AttrDict[Any]): """ :arg breakdown: (required) :arg description: (required) :arg time_in_nanos: (required) :arg type: (required) :arg debug: :arg children: """ breakdown: "AggregationBreakdown" description: str time_in_nanos: Any type: str debug: "AggregationProfileDebug" children: Sequence["AggregationProfile"] class AggregationProfileDebug(AttrDict[Any]): """ :arg segments_with_multi_valued_ords: :arg collection_strategy: :arg segments_with_single_valued_ords: :arg total_buckets: :arg built_buckets: :arg result_strategy: :arg has_filter: :arg delegate: :arg delegate_debug: :arg chars_fetched: :arg extract_count: :arg extract_ns: :arg values_fetched: :arg collect_analyzed_ns: :arg collect_analyzed_count: :arg surviving_buckets: :arg ordinals_collectors_used: :arg ordinals_collectors_overhead_too_high: :arg string_hashing_collectors_used: :arg numeric_collectors_used: :arg empty_collectors_used: :arg deferred_aggregators: :arg segments_with_doc_count_field: :arg segments_with_deleted_docs: :arg filters: :arg segments_counted: :arg segments_collected: :arg map_reducer: :arg brute_force_used: :arg dynamic_pruning_attempted: :arg dynamic_pruning_used: :arg skipped_due_to_no_data: """ segments_with_multi_valued_ords: int collection_strategy: str segments_with_single_valued_ords: int total_buckets: int built_buckets: int result_strategy: str has_filter: bool delegate: str delegate_debug: "AggregationProfileDebug" chars_fetched: int extract_count: int extract_ns: int values_fetched: int collect_analyzed_ns: int collect_analyzed_count: int surviving_buckets: int ordinals_collectors_used: int ordinals_collectors_overhead_too_high: int string_hashing_collectors_used: int numeric_collectors_used: int empty_collectors_used: int deferred_aggregators: Sequence[str] segments_with_doc_count_field: int segments_with_deleted_docs: int filters: Sequence["AggregationProfileDelegateDebugFilter"] segments_counted: int segments_collected: int map_reducer: str brute_force_used: int dynamic_pruning_attempted: int dynamic_pruning_used: int skipped_due_to_no_data: int class AggregationProfileDelegateDebugFilter(AttrDict[Any]): """ :arg results_from_metadata: :arg query: :arg specialized_for: :arg segments_counted_in_constant_time: """ results_from_metadata: int query: str specialized_for: str segments_counted_in_constant_time: int class ArrayPercentilesItem(AttrDict[Any]): """ :arg key: (required) :arg value: (required) :arg value_as_string: """ key: str value: Union[float, None] value_as_string: str class AutoDateHistogramAggregate(AttrDict[Any]): """ :arg interval: (required) :arg buckets: (required) the aggregation buckets as a list :arg meta: """ interval: str buckets: Sequence["DateHistogramBucket"] meta: Mapping[str, Any] @property def buckets_as_dict(self) -> Mapping[str, "DateHistogramBucket"]: return self.buckets # type: ignore[return-value] class AvgAggregate(AttrDict[Any]): """ :arg value: (required) The metric value. A missing value generally means that there was no data to aggregate, unless specified otherwise. :arg value_as_string: :arg meta: """ value: Union[float, None] value_as_string: str meta: Mapping[str, Any] class BoxPlotAggregate(AttrDict[Any]): """ :arg min: (required) :arg max: (required) :arg q1: (required) :arg q2: (required) :arg q3: (required) :arg lower: (required) :arg upper: (required) :arg min_as_string: :arg max_as_string: :arg q1_as_string: :arg q2_as_string: :arg q3_as_string: :arg lower_as_string: :arg upper_as_string: :arg meta: """ min: float max: float q1: float q2: float q3: float lower: float upper: float min_as_string: str max_as_string: str q1_as_string: str q2_as_string: str q3_as_string: str lower_as_string: str upper_as_string: str meta: Mapping[str, Any] class BucketMetricValueAggregate(AttrDict[Any]): """ :arg keys: (required) :arg value: (required) The metric value. A missing value generally means that there was no data to aggregate, unless specified otherwise. :arg value_as_string: :arg meta: """ keys: Sequence[str] # type: ignore[assignment] value: Union[float, None] value_as_string: str meta: Mapping[str, Any] class BulkIndexByScrollFailure(AttrDict[Any]): """ :arg cause: (required) :arg id: (required) :arg index: (required) :arg status: (required) """ cause: "ErrorCause" id: str index: str status: int class CardinalityAggregate(AttrDict[Any]): """ :arg value: (required) :arg meta: """ value: int meta: Mapping[str, Any] class ChildrenAggregate(AttrDict[Any]): """ :arg doc_count: (required) :arg meta: """ doc_count: int meta: Mapping[str, Any] class ClusterDetails(AttrDict[Any]): """ :arg status: (required) :arg indices: (required) :arg timed_out: (required) :arg took: :arg _shards: :arg failures: """ status: Literal["running", "successful", "partial", "skipped", "failed"] indices: str timed_out: bool took: Any _shards: "ShardStatistics" failures: Sequence["ShardFailure"] class ClusterStatistics(AttrDict[Any]): """ :arg skipped: (required) :arg successful: (required) :arg total: (required) :arg running: (required) :arg partial: (required) :arg failed: (required) :arg details: """ skipped: int successful: int total: int running: int partial: int failed: int details: Mapping[str, "ClusterDetails"] class Collector(AttrDict[Any]): """ :arg name: (required) :arg reason: (required) :arg time_in_nanos: (required) :arg children: """ name: str reason: str time_in_nanos: Any children: Sequence["Collector"] class CompletionSuggest(AttrDict[Any]): """ :arg options: (required) :arg length: (required) :arg offset: (required) :arg text: (required) """ options: Sequence["CompletionSuggestOption"] length: int offset: int text: str class CompletionSuggestOption(AttrDict[Any]): """ :arg text: (required) :arg collate_match: :arg contexts: :arg fields: :arg _id: :arg _index: :arg _routing: :arg _score: :arg _source: :arg score: """ text: str collate_match: bool contexts: Mapping[ str, Sequence[ Union[ str, Union["LatLonGeoLocation", "GeoHashLocation", Sequence[float], str] ] ], ] fields: Mapping[str, Any] _id: str _index: str _routing: str _score: float _source: Any score: float class CompositeAggregate(AttrDict[Any]): """ :arg after_key: :arg buckets: (required) the aggregation buckets as a list :arg meta: """ after_key: Mapping[str, Union[int, float, str, bool, None]] buckets: Sequence["CompositeBucket"] meta: Mapping[str, Any] @property def buckets_as_dict(self) -> Mapping[str, "CompositeBucket"]: return self.buckets # type: ignore[return-value] class CompositeBucket(AttrDict[Any]): """ :arg key: (required) :arg doc_count: (required) """ key: Mapping[str, Union[int, float, str, bool, None]] doc_count: int class CumulativeCardinalityAggregate(AttrDict[Any]): """ Result of the `cumulative_cardinality` aggregation :arg value: (required) :arg value_as_string: :arg meta: """ value: int value_as_string: str meta: Mapping[str, Any] class DateHistogramAggregate(AttrDict[Any]): """ :arg buckets: (required) the aggregation buckets as a list :arg meta: """ buckets: Sequence["DateHistogramBucket"] meta: Mapping[str, Any] @property def buckets_as_dict(self) -> Mapping[str, "DateHistogramBucket"]: return self.buckets # type: ignore[return-value] class DateHistogramBucket(AttrDict[Any]): """ :arg key: (required) :arg doc_count: (required) :arg key_as_string: """ key: Any doc_count: int key_as_string: str class DateRangeAggregate(AttrDict[Any]): """ Result of a `date_range` aggregation. Same format as a for a `range` aggregation: `from` and `to` in `buckets` are milliseconds since the Epoch, represented as a floating point number. :arg buckets: (required) the aggregation buckets as a list :arg meta: """ buckets: Sequence["RangeBucket"] meta: Mapping[str, Any] @property def buckets_as_dict(self) -> Mapping[str, "RangeBucket"]: return self.buckets # type: ignore[return-value] class DerivativeAggregate(AttrDict[Any]): """ :arg value: (required) The metric value. A missing value generally means that there was no data to aggregate, unless specified otherwise. :arg normalized_value: :arg normalized_value_as_string: :arg value_as_string: :arg meta: """ value: Union[float, None] normalized_value: float normalized_value_as_string: str value_as_string: str meta: Mapping[str, Any] class DfsKnnProfile(AttrDict[Any]): """ :arg query: (required) :arg rewrite_time: (required) :arg collector: (required) :arg vector_operations_count: """ query: Sequence["KnnQueryProfileResult"] rewrite_time: int collector: Sequence["KnnCollectorResult"] vector_operations_count: int class DfsProfile(AttrDict[Any]): """ :arg statistics: :arg knn: """ statistics: "DfsStatisticsProfile" knn: Sequence["DfsKnnProfile"] class DfsStatisticsBreakdown(AttrDict[Any]): """ :arg collection_statistics: (required) :arg collection_statistics_count: (required) :arg create_weight: (required) :arg create_weight_count: (required) :arg rewrite: (required) :arg rewrite_count: (required) :arg term_statistics: (required) :arg term_statistics_count: (required) """ collection_statistics: int collection_statistics_count: int create_weight: int create_weight_count: int rewrite: int rewrite_count: int term_statistics: int term_statistics_count: int class DfsStatisticsProfile(AttrDict[Any]): """ :arg type: (required) :arg description: (required) :arg time_in_nanos: (required) :arg breakdown: (required) :arg time: :arg debug: :arg children: """ type: str description: str time_in_nanos: Any breakdown: "DfsStatisticsBreakdown" time: Any debug: Mapping[str, Any] children: Sequence["DfsStatisticsProfile"] class DoubleTermsAggregate(AttrDict[Any]): """ Result of a `terms` aggregation when the field is some kind of decimal number like a float, double, or distance. :arg doc_count_error_upper_bound: :arg sum_other_doc_count: :arg buckets: (required) the aggregation buckets as a list :arg meta: """ doc_count_error_upper_bound: int sum_other_doc_count: int buckets: Sequence["DoubleTermsBucket"] meta: Mapping[str, Any] @property def buckets_as_dict(self) -> Mapping[str, "DoubleTermsBucket"]: return self.buckets # type: ignore[return-value] class DoubleTermsBucket(AttrDict[Any]): """ :arg key: (required) :arg doc_count: (required) :arg key_as_string: :arg doc_count_error_upper_bound: """ key: float doc_count: int key_as_string: str doc_count_error_upper_bound: int class ErrorCause(AttrDict[Any]): """ Cause and details about a request failure. This class defines the properties common to all error types. Additional details are also provided, that depend on the error type. :arg type: (required) The type of error :arg reason: A human-readable explanation of the error, in English. :arg stack_trace: The server stack trace. Present only if the `error_trace=true` parameter was sent with the request. :arg caused_by: :arg root_cause: :arg suppressed: """ type: str reason: str stack_trace: str caused_by: "ErrorCause" root_cause: Sequence["ErrorCause"] suppressed: Sequence["ErrorCause"] class Explanation(AttrDict[Any]): """ :arg description: (required) :arg details: (required) :arg value: (required) """ description: str details: Sequence["ExplanationDetail"] value: float class ExplanationDetail(AttrDict[Any]): """ :arg description: (required) :arg value: (required) :arg details: """ description: str value: float details: Sequence["ExplanationDetail"] class ExtendedStatsAggregate(AttrDict[Any]): """ :arg sum_of_squares: (required) :arg variance: (required) :arg variance_population: (required) :arg variance_sampling: (required) :arg std_deviation: (required) :arg std_deviation_population: (required) :arg std_deviation_sampling: (required) :arg count: (required) :arg min: (required) :arg max: (required) :arg avg: (required) :arg sum: (required) :arg std_deviation_bounds: :arg sum_of_squares_as_string: :arg variance_as_string: :arg variance_population_as_string: :arg variance_sampling_as_string: :arg std_deviation_as_string: :arg std_deviation_bounds_as_string: :arg min_as_string: :arg max_as_string: :arg avg_as_string: :arg sum_as_string: :arg meta: """ sum_of_squares: Union[float, None] variance: Union[float, None] variance_population: Union[float, None] variance_sampling: Union[float, None] std_deviation: Union[float, None] std_deviation_population: Union[float, None] std_deviation_sampling: Union[float, None] count: int min: Union[float, None] max: Union[float, None] avg: Union[float, None] sum: float std_deviation_bounds: "StandardDeviationBounds" sum_of_squares_as_string: str variance_as_string: str variance_population_as_string: str variance_sampling_as_string: str std_deviation_as_string: str std_deviation_bounds_as_string: "StandardDeviationBoundsAsString" min_as_string: str max_as_string: str avg_as_string: str sum_as_string: str meta: Mapping[str, Any] class ExtendedStatsBucketAggregate(AttrDict[Any]): """ :arg sum_of_squares: (required) :arg variance: (required) :arg variance_population: (required) :arg variance_sampling: (required) :arg std_deviation: (required) :arg std_deviation_population: (required) :arg std_deviation_sampling: (required) :arg count: (required) :arg min: (required) :arg max: (required) :arg avg: (required) :arg sum: (required) :arg std_deviation_bounds: :arg sum_of_squares_as_string: :arg variance_as_string: :arg variance_population_as_string: :arg variance_sampling_as_string: :arg std_deviation_as_string: :arg std_deviation_bounds_as_string: :arg min_as_string: :arg max_as_string: :arg avg_as_string: :arg sum_as_string: :arg meta: """ sum_of_squares: Union[float, None] variance: Union[float, None] variance_population: Union[float, None] variance_sampling: Union[float, None] std_deviation: Union[float, None] std_deviation_population: Union[float, None] std_deviation_sampling: Union[float, None] count: int min: Union[float, None] max: Union[float, None] avg: Union[float, None] sum: float std_deviation_bounds: "StandardDeviationBounds" sum_of_squares_as_string: str variance_as_string: str variance_population_as_string: str variance_sampling_as_string: str std_deviation_as_string: str std_deviation_bounds_as_string: "StandardDeviationBoundsAsString" min_as_string: str max_as_string: str avg_as_string: str sum_as_string: str meta: Mapping[str, Any] class FetchProfile(AttrDict[Any]): """ :arg type: (required) :arg description: (required) :arg time_in_nanos: (required) :arg breakdown: (required) :arg debug: :arg children: """ type: str description: str time_in_nanos: Any breakdown: "FetchProfileBreakdown" debug: "FetchProfileDebug" children: Sequence["FetchProfile"] class FetchProfileBreakdown(AttrDict[Any]): """ :arg load_source: :arg load_source_count: :arg load_stored_fields: :arg load_stored_fields_count: :arg next_reader: :arg next_reader_count: :arg process_count: :arg process: """ load_source: int load_source_count: int load_stored_fields: int load_stored_fields_count: int next_reader: int next_reader_count: int process_count: int process: int class FetchProfileDebug(AttrDict[Any]): """ :arg stored_fields: :arg fast_path: """ stored_fields: Sequence[str] fast_path: int class FilterAggregate(AttrDict[Any]): """ :arg doc_count: (required) :arg meta: """ doc_count: int meta: Mapping[str, Any] class FiltersAggregate(AttrDict[Any]): """ :arg buckets: (required) the aggregation buckets as a list :arg meta: """ buckets: Sequence["FiltersBucket"] meta: Mapping[str, Any] @property def buckets_as_dict(self) -> Mapping[str, "FiltersBucket"]: return self.buckets # type: ignore[return-value] class FiltersBucket(AttrDict[Any]): """ :arg doc_count: (required) """ doc_count: int class FrequentItemSetsAggregate(AttrDict[Any]): """ :arg buckets: (required) the aggregation buckets as a list :arg meta: """ buckets: Sequence["FrequentItemSetsBucket"] meta: Mapping[str, Any] @property def buckets_as_dict(self) -> Mapping[str, "FrequentItemSetsBucket"]: return self.buckets # type: ignore[return-value] class FrequentItemSetsBucket(AttrDict[Any]): """ :arg key: (required) :arg support: (required) :arg doc_count: (required) """ key: Mapping[str, Sequence[str]] support: float doc_count: int class GeoBoundsAggregate(AttrDict[Any]): """ :arg bounds: :arg meta: """ bounds: Union[ "CoordsGeoBounds", "TopLeftBottomRightGeoBounds", "TopRightBottomLeftGeoBounds", "WktGeoBounds", ] meta: Mapping[str, Any] class GeoCentroidAggregate(AttrDict[Any]): """ :arg count: (required) :arg location: :arg meta: """ count: int location: Union["LatLonGeoLocation", "GeoHashLocation", Sequence[float], str] meta: Mapping[str, Any] class GeoDistanceAggregate(AttrDict[Any]): """ Result of a `geo_distance` aggregation. The unit for `from` and `to` is meters by default. :arg buckets: (required) the aggregation buckets as a list :arg meta: """ buckets: Sequence["RangeBucket"] meta: Mapping[str, Any] @property def buckets_as_dict(self) -> Mapping[str, "RangeBucket"]: return self.buckets # type: ignore[return-value] class GeoHashGridAggregate(AttrDict[Any]): """ :arg buckets: (required) the aggregation buckets as a list :arg meta: """ buckets: Sequence["GeoHashGridBucket"] meta: Mapping[str, Any] @property def buckets_as_dict(self) -> Mapping[str, "GeoHashGridBucket"]: return self.buckets # type: ignore[return-value] class GeoHashGridBucket(AttrDict[Any]): """ :arg key: (required) :arg doc_count: (required) """ key: str doc_count: int class GeoHexGridAggregate(AttrDict[Any]): """ :arg buckets: (required) the aggregation buckets as a list :arg meta: """ buckets: Sequence["GeoHexGridBucket"] meta: Mapping[str, Any] @property def buckets_as_dict(self) -> Mapping[str, "GeoHexGridBucket"]: return self.buckets # type: ignore[return-value] class GeoHexGridBucket(AttrDict[Any]): """ :arg key: (required) :arg doc_count: (required) """ key: str doc_count: int class GeoLine(AttrDict[Any]): """ A GeoJson GeoLine. :arg type: (required) Always `"LineString"` :arg coordinates: (required) Array of `[lon, lat]` coordinates """ type: str coordinates: Sequence[Sequence[float]] class GeoLineAggregate(AttrDict[Any]): """ :arg type: (required) :arg geometry: (required) :arg properties: (required) :arg meta: """ type: str geometry: "GeoLine" properties: Any meta: Mapping[str, Any] class GeoTileGridAggregate(AttrDict[Any]): """ :arg buckets: (required) the aggregation buckets as a list :arg meta: """ buckets: Sequence["GeoTileGridBucket"] meta: Mapping[str, Any] @property def buckets_as_dict(self) -> Mapping[str, "GeoTileGridBucket"]: return self.buckets # type: ignore[return-value] class GeoTileGridBucket(AttrDict[Any]): """ :arg key: (required) :arg doc_count: (required) """ key: str doc_count: int class GlobalAggregate(AttrDict[Any]): """ :arg doc_count: (required) :arg meta: """ doc_count: int meta: Mapping[str, Any] class HdrPercentileRanksAggregate(AttrDict[Any]): """ :arg values: (required) :arg meta: """ values: Union[Mapping[str, Union[str, int, None]], Sequence["ArrayPercentilesItem"]] meta: Mapping[str, Any] class HdrPercentilesAggregate(AttrDict[Any]): """ :arg values: (required) :arg meta: """ values: Union[Mapping[str, Union[str, int, None]], Sequence["ArrayPercentilesItem"]] meta: Mapping[str, Any] class HistogramAggregate(AttrDict[Any]): """ :arg buckets: (required) the aggregation buckets as a list :arg meta: """ buckets: Sequence["HistogramBucket"] meta: Mapping[str, Any] @property def buckets_as_dict(self) -> Mapping[str, "HistogramBucket"]: return self.buckets # type: ignore[return-value] class HistogramBucket(AttrDict[Any]): """ :arg key: (required) :arg doc_count: (required) :arg key_as_string: """ key: float doc_count: int key_as_string: str class Hit(AttrDict[Any]): """ :arg index: (required) :arg id: :arg score: :arg explanation: :arg fields: :arg highlight: :arg inner_hits: :arg matched_queries: :arg nested: :arg ignored: :arg ignored_field_values: :arg shard: :arg node: :arg routing: :arg source: :arg rank: :arg seq_no: :arg primary_term: :arg version: :arg sort: """ index: str id: str score: Union[float, None] explanation: "Explanation" fields: Mapping[str, Any] highlight: Mapping[str, Sequence[str]] inner_hits: Mapping[str, "InnerHitsResult"] matched_queries: Union[Sequence[str], Mapping[str, float]] nested: "NestedIdentity" ignored: Sequence[str] ignored_field_values: Mapping[str, Sequence[Any]] shard: str node: str routing: str source: Any rank: int seq_no: int primary_term: int version: int sort: Sequence[Union[int, float, str, bool, None]] class HitsMetadata(AttrDict[Any]): """ :arg hits: (required) :arg total: Total hit count information, present only if `track_total_hits` wasn't `false` in the search request. :arg max_score: """ hits: Sequence["Hit"] total: Union["TotalHits", int] max_score: Union[float, None] class InferenceAggregate(AttrDict[Any]): """ :arg value: :arg feature_importance: :arg top_classes: :arg warning: :arg meta: """ value: Union[int, float, str, bool, None] feature_importance: Sequence["InferenceFeatureImportance"] top_classes: Sequence["InferenceTopClassEntry"] warning: str meta: Mapping[str, Any] class InferenceClassImportance(AttrDict[Any]): """ :arg class_name: (required) :arg importance: (required) """ class_name: str importance: float class InferenceFeatureImportance(AttrDict[Any]): """ :arg feature_name: (required) :arg importance: :arg classes: """ feature_name: str importance: float classes: Sequence["InferenceClassImportance"] class InferenceTopClassEntry(AttrDict[Any]): """ :arg class_name: (required) :arg class_probability: (required) :arg class_score: (required) """ class_name: Union[int, float, str, bool, None] class_probability: float class_score: float class InnerHitsResult(AttrDict[Any]): """ :arg hits: (required) """ hits: "HitsMetadata" class IpPrefixAggregate(AttrDict[Any]): """ :arg buckets: (required) the aggregation buckets as a list :arg meta: """ buckets: Sequence["IpPrefixBucket"] meta: Mapping[str, Any] @property def buckets_as_dict(self) -> Mapping[str, "IpPrefixBucket"]: return self.buckets # type: ignore[return-value] class IpPrefixBucket(AttrDict[Any]): """ :arg is_ipv6: (required) :arg key: (required) :arg prefix_length: (required) :arg doc_count: (required) :arg netmask: """ is_ipv6: bool key: str prefix_length: int doc_count: int netmask: str class IpRangeAggregate(AttrDict[Any]): """ :arg buckets: (required) the aggregation buckets as a list :arg meta: """ buckets: Sequence["IpRangeBucket"] meta: Mapping[str, Any] @property def buckets_as_dict(self) -> Mapping[str, "IpRangeBucket"]: return self.buckets # type: ignore[return-value] class IpRangeBucket(AttrDict[Any]): """ :arg doc_count: (required) :arg key: :arg from: :arg to: """ doc_count: int key: str from_: str to: str class KnnCollectorResult(AttrDict[Any]): """ :arg name: (required) :arg reason: (required) :arg time_in_nanos: (required) :arg time: :arg children: """ name: str reason: str time_in_nanos: Any time: Any children: Sequence["KnnCollectorResult"] class KnnQueryProfileBreakdown(AttrDict[Any]): """ :arg advance: (required) :arg advance_count: (required) :arg build_scorer: (required) :arg build_scorer_count: (required) :arg compute_max_score: (required) :arg compute_max_score_count: (required) :arg count_weight: (required) :arg count_weight_count: (required) :arg create_weight: (required) :arg create_weight_count: (required) :arg match: (required) :arg match_count: (required) :arg next_doc: (required) :arg next_doc_count: (required) :arg score: (required) :arg score_count: (required) :arg set_min_competitive_score: (required) :arg set_min_competitive_score_count: (required) :arg shallow_advance: (required) :arg shallow_advance_count: (required) """ advance: int advance_count: int build_scorer: int build_scorer_count: int compute_max_score: int compute_max_score_count: int count_weight: int count_weight_count: int create_weight: int create_weight_count: int match: int match_count: int next_doc: int next_doc_count: int score: int score_count: int set_min_competitive_score: int set_min_competitive_score_count: int shallow_advance: int shallow_advance_count: int class KnnQueryProfileResult(AttrDict[Any]): """ :arg type: (required) :arg description: (required) :arg time_in_nanos: (required) :arg breakdown: (required) :arg time: :arg debug: :arg children: """ type: str description: str time_in_nanos: Any breakdown: "KnnQueryProfileBreakdown" time: Any debug: Mapping[str, Any] children: Sequence["KnnQueryProfileResult"] class LongRareTermsAggregate(AttrDict[Any]): """ Result of the `rare_terms` aggregation when the field is some kind of whole number like a integer, long, or a date. :arg buckets: (required) the aggregation buckets as a list :arg meta: """ buckets: Sequence["LongRareTermsBucket"] meta: Mapping[str, Any] @property def buckets_as_dict(self) -> Mapping[str, "LongRareTermsBucket"]: return self.buckets # type: ignore[return-value] class LongRareTermsBucket(AttrDict[Any]): """ :arg key: (required) :arg doc_count: (required) :arg key_as_string: """ key: int doc_count: int key_as_string: str class LongTermsAggregate(AttrDict[Any]): """ Result of a `terms` aggregation when the field is some kind of whole number like a integer, long, or a date. :arg doc_count_error_upper_bound: :arg sum_other_doc_count: :arg buckets: (required) the aggregation buckets as a list :arg meta: """ doc_count_error_upper_bound: int sum_other_doc_count: int buckets: Sequence["LongTermsBucket"] meta: Mapping[str, Any] @property def buckets_as_dict(self) -> Mapping[str, "LongTermsBucket"]: return self.buckets # type: ignore[return-value] class LongTermsBucket(AttrDict[Any]): """ :arg key: (required) :arg doc_count: (required) :arg key_as_string: :arg doc_count_error_upper_bound: """ key: int doc_count: int key_as_string: str doc_count_error_upper_bound: int class MatrixStatsAggregate(AttrDict[Any]): """ :arg doc_count: (required) :arg fields: :arg meta: """ doc_count: int fields: Sequence["MatrixStatsFields"] meta: Mapping[str, Any] class MatrixStatsFields(AttrDict[Any]): """ :arg name: (required) :arg count: (required) :arg mean: (required) :arg variance: (required) :arg skewness: (required) :arg kurtosis: (required) :arg covariance: (required) :arg correlation: (required) """ name: str count: int mean: float variance: float skewness: float kurtosis: float covariance: Mapping[str, float] correlation: Mapping[str, float] class MaxAggregate(AttrDict[Any]): """ :arg value: (required) The metric value. A missing value generally means that there was no data to aggregate, unless specified otherwise. :arg value_as_string: :arg meta: """ value: Union[float, None] value_as_string: str meta: Mapping[str, Any] class MedianAbsoluteDeviationAggregate(AttrDict[Any]): """ :arg value: (required) The metric value. A missing value generally means that there was no data to aggregate, unless specified otherwise. :arg value_as_string: :arg meta: """ value: Union[float, None] value_as_string: str meta: Mapping[str, Any] class MinAggregate(AttrDict[Any]): """ :arg value: (required) The metric value. A missing value generally means that there was no data to aggregate, unless specified otherwise. :arg value_as_string: :arg meta: """ value: Union[float, None] value_as_string: str meta: Mapping[str, Any] class MissingAggregate(AttrDict[Any]): """ :arg doc_count: (required) :arg meta: """ doc_count: int meta: Mapping[str, Any] class MultiTermsAggregate(AttrDict[Any]): """ :arg doc_count_error_upper_bound: :arg sum_other_doc_count: :arg buckets: (required) the aggregation buckets as a list :arg meta: """ doc_count_error_upper_bound: int sum_other_doc_count: int buckets: Sequence["MultiTermsBucket"] meta: Mapping[str, Any] @property def buckets_as_dict(self) -> Mapping[str, "MultiTermsBucket"]: return self.buckets # type: ignore[return-value] class MultiTermsBucket(AttrDict[Any]): """ :arg key: (required) :arg doc_count: (required) :arg key_as_string: :arg doc_count_error_upper_bound: """ key: Sequence[Union[int, float, str, bool, None]] doc_count: int key_as_string: str doc_count_error_upper_bound: int class NestedAggregate(AttrDict[Any]): """ :arg doc_count: (required) :arg meta: """ doc_count: int meta: Mapping[str, Any] class NestedIdentity(AttrDict[Any]): """ :arg field: (required) :arg offset: (required) :arg _nested: """ field: str offset: int _nested: "NestedIdentity" class ParentAggregate(AttrDict[Any]): """ :arg doc_count: (required) :arg meta: """ doc_count: int meta: Mapping[str, Any] class PercentilesBucketAggregate(AttrDict[Any]): """ :arg values: (required) :arg meta: """ values: Union[Mapping[str, Union[str, int, None]], Sequence["ArrayPercentilesItem"]] meta: Mapping[str, Any] class PhraseSuggest(AttrDict[Any]): """ :arg options: (required) :arg length: (required) :arg offset: (required) :arg text: (required) """ options: Sequence["PhraseSuggestOption"] length: int offset: int text: str class PhraseSuggestOption(AttrDict[Any]): """ :arg text: (required) :arg score: (required) :arg highlighted: :arg collate_match: """ text: str score: float highlighted: str collate_match: bool class Profile(AttrDict[Any]): """ :arg shards: (required) """ shards: Sequence["ShardProfile"] class QueryBreakdown(AttrDict[Any]): """ :arg advance: (required) :arg advance_count: (required) :arg build_scorer: (required) :arg build_scorer_count: (required) :arg create_weight: (required) :arg create_weight_count: (required) :arg match: (required) :arg match_count: (required) :arg shallow_advance: (required) :arg shallow_advance_count: (required) :arg next_doc: (required) :arg next_doc_count: (required) :arg score: (required) :arg score_count: (required) :arg compute_max_score: (required) :arg compute_max_score_count: (required) :arg count_weight: (required) :arg count_weight_count: (required) :arg set_min_competitive_score: (required) :arg set_min_competitive_score_count: (required) """ advance: int advance_count: int build_scorer: int build_scorer_count: int create_weight: int create_weight_count: int match: int match_count: int shallow_advance: int shallow_advance_count: int next_doc: int next_doc_count: int score: int score_count: int compute_max_score: int compute_max_score_count: int count_weight: int count_weight_count: int set_min_competitive_score: int set_min_competitive_score_count: int class QueryProfile(AttrDict[Any]): """ :arg breakdown: (required) :arg description: (required) :arg time_in_nanos: (required) :arg type: (required) :arg children: """ breakdown: "QueryBreakdown" description: str time_in_nanos: Any type: str children: Sequence["QueryProfile"] class RangeAggregate(AttrDict[Any]): """ :arg buckets: (required) the aggregation buckets as a list :arg meta: """ buckets: Sequence["RangeBucket"] meta: Mapping[str, Any] @property def buckets_as_dict(self) -> Mapping[str, "RangeBucket"]: return self.buckets # type: ignore[return-value] class RangeBucket(AttrDict[Any]): """ :arg doc_count: (required) :arg from: :arg to: :arg from_as_string: :arg to_as_string: :arg key: The bucket key. Present if the aggregation is _not_ keyed """ doc_count: int from_: float to: float from_as_string: str to_as_string: str key: str class RateAggregate(AttrDict[Any]): """ :arg value: (required) :arg value_as_string: :arg meta: """ value: float value_as_string: str meta: Mapping[str, Any] class Retries(AttrDict[Any]): """ :arg bulk: (required) The number of bulk actions retried. :arg search: (required) The number of search actions retried. """ bulk: int search: int class ReverseNestedAggregate(AttrDict[Any]): """ :arg doc_count: (required) :arg meta: """ doc_count: int meta: Mapping[str, Any] class SamplerAggregate(AttrDict[Any]): """ :arg doc_count: (required) :arg meta: """ doc_count: int meta: Mapping[str, Any] class ScriptedMetricAggregate(AttrDict[Any]): """ :arg value: (required) :arg meta: """ value: Any meta: Mapping[str, Any] class SearchProfile(AttrDict[Any]): """ :arg collector: (required) :arg query: (required) :arg rewrite_time: (required) """ collector: Sequence["Collector"] query: Sequence["QueryProfile"] rewrite_time: int class ShardFailure(AttrDict[Any]): """ :arg reason: (required) :arg shard: (required) :arg index: :arg node: :arg status: """ reason: "ErrorCause" shard: int index: str node: str status: str class ShardProfile(AttrDict[Any]): """ :arg aggregations: (required) :arg cluster: (required) :arg id: (required) :arg index: (required) :arg node_id: (required) :arg searches: (required) :arg shard_id: (required) :arg dfs: :arg fetch: """ aggregations: Sequence["AggregationProfile"] cluster: str id: str index: str node_id: str searches: Sequence["SearchProfile"] shard_id: int dfs: "DfsProfile" fetch: "FetchProfile" class ShardStatistics(AttrDict[Any]): """ :arg failed: (required) The number of shards the operation or search attempted to run on but failed. :arg successful: (required) The number of shards the operation or search succeeded on. :arg total: (required) The number of shards the operation or search will run on overall. :arg failures: :arg skipped: """ failed: int successful: int total: int failures: Sequence["ShardFailure"] skipped: int class SignificantLongTermsAggregate(AttrDict[Any]): """ :arg bg_count: :arg doc_count: :arg buckets: (required) the aggregation buckets as a list :arg meta: """ bg_count: int doc_count: int buckets: Sequence["SignificantLongTermsBucket"] meta: Mapping[str, Any] @property def buckets_as_dict(self) -> Mapping[str, "SignificantLongTermsBucket"]: return self.buckets # type: ignore[return-value] class SignificantLongTermsBucket(AttrDict[Any]): """ :arg key: (required) :arg score: (required) :arg bg_count: (required) :arg doc_count: (required) :arg key_as_string: """ key: int score: float bg_count: int doc_count: int key_as_string: str class SignificantStringTermsAggregate(AttrDict[Any]): """ :arg bg_count: :arg doc_count: :arg buckets: (required) the aggregation buckets as a list :arg meta: """ bg_count: int doc_count: int buckets: Sequence["SignificantStringTermsBucket"] meta: Mapping[str, Any] @property def buckets_as_dict(self) -> Mapping[str, "SignificantStringTermsBucket"]: return self.buckets # type: ignore[return-value] class SignificantStringTermsBucket(AttrDict[Any]): """ :arg key: (required) :arg score: (required) :arg bg_count: (required) :arg doc_count: (required) """ key: str score: float bg_count: int doc_count: int class SimpleValueAggregate(AttrDict[Any]): """ :arg value: (required) The metric value. A missing value generally means that there was no data to aggregate, unless specified otherwise. :arg value_as_string: :arg meta: """ value: Union[float, None] value_as_string: str meta: Mapping[str, Any] class StandardDeviationBounds(AttrDict[Any]): """ :arg upper: (required) :arg lower: (required) :arg upper_population: (required) :arg lower_population: (required) :arg upper_sampling: (required) :arg lower_sampling: (required) """ upper: Union[float, None] lower: Union[float, None] upper_population: Union[float, None] lower_population: Union[float, None] upper_sampling: Union[float, None] lower_sampling: Union[float, None] class StandardDeviationBoundsAsString(AttrDict[Any]): """ :arg upper: (required) :arg lower: (required) :arg upper_population: (required) :arg lower_population: (required) :arg upper_sampling: (required) :arg lower_sampling: (required) """ upper: str lower: str upper_population: str lower_population: str upper_sampling: str lower_sampling: str class StatsAggregate(AttrDict[Any]): """ Statistics aggregation result. `min`, `max` and `avg` are missing if there were no values to process (`count` is zero). :arg count: (required) :arg min: (required) :arg max: (required) :arg avg: (required) :arg sum: (required) :arg min_as_string: :arg max_as_string: :arg avg_as_string: :arg sum_as_string: :arg meta: """ count: int min: Union[float, None] max: Union[float, None] avg: Union[float, None] sum: float min_as_string: str max_as_string: str avg_as_string: str sum_as_string: str meta: Mapping[str, Any] class StatsBucketAggregate(AttrDict[Any]): """ :arg count: (required) :arg min: (required) :arg max: (required) :arg avg: (required) :arg sum: (required) :arg min_as_string: :arg max_as_string: :arg avg_as_string: :arg sum_as_string: :arg meta: """ count: int min: Union[float, None] max: Union[float, None] avg: Union[float, None] sum: float min_as_string: str max_as_string: str avg_as_string: str sum_as_string: str meta: Mapping[str, Any] class StringRareTermsAggregate(AttrDict[Any]): """ Result of the `rare_terms` aggregation when the field is a string. :arg buckets: (required) the aggregation buckets as a list :arg meta: """ buckets: Sequence["StringRareTermsBucket"] meta: Mapping[str, Any] @property def buckets_as_dict(self) -> Mapping[str, "StringRareTermsBucket"]: return self.buckets # type: ignore[return-value] class StringRareTermsBucket(AttrDict[Any]): """ :arg key: (required) :arg doc_count: (required) """ key: str doc_count: int class StringStatsAggregate(AttrDict[Any]): """ :arg count: (required) :arg min_length: (required) :arg max_length: (required) :arg avg_length: (required) :arg entropy: (required) :arg distribution: :arg min_length_as_string: :arg max_length_as_string: :arg avg_length_as_string: :arg meta: """ count: int min_length: Union[int, None] max_length: Union[int, None] avg_length: Union[float, None] entropy: Union[float, None] distribution: Union[Mapping[str, float], None] min_length_as_string: str max_length_as_string: str avg_length_as_string: str meta: Mapping[str, Any] class StringTermsAggregate(AttrDict[Any]): """ Result of a `terms` aggregation when the field is a string. :arg doc_count_error_upper_bound: :arg sum_other_doc_count: :arg buckets: (required) the aggregation buckets as a list :arg meta: """ doc_count_error_upper_bound: int sum_other_doc_count: int buckets: Sequence["StringTermsBucket"] meta: Mapping[str, Any] @property def buckets_as_dict(self) -> Mapping[str, "StringTermsBucket"]: return self.buckets # type: ignore[return-value] class StringTermsBucket(AttrDict[Any]): """ :arg key: (required) :arg doc_count: (required) :arg doc_count_error_upper_bound: """ key: Union[int, float, str, bool, None] doc_count: int doc_count_error_upper_bound: int class SumAggregate(AttrDict[Any]): """ Sum aggregation result. `value` is always present and is zero if there were no values to process. :arg value: (required) The metric value. A missing value generally means that there was no data to aggregate, unless specified otherwise. :arg value_as_string: :arg meta: """ value: Union[float, None] value_as_string: str meta: Mapping[str, Any] class TDigestPercentileRanksAggregate(AttrDict[Any]): """ :arg values: (required) :arg meta: """ values: Union[Mapping[str, Union[str, int, None]], Sequence["ArrayPercentilesItem"]] meta: Mapping[str, Any] class TDigestPercentilesAggregate(AttrDict[Any]): """ :arg values: (required) :arg meta: """ values: Union[Mapping[str, Union[str, int, None]], Sequence["ArrayPercentilesItem"]] meta: Mapping[str, Any] class TTestAggregate(AttrDict[Any]): """ :arg value: (required) :arg value_as_string: :arg meta: """ value: Union[float, None] value_as_string: str meta: Mapping[str, Any] class TermSuggest(AttrDict[Any]): """ :arg options: (required) :arg length: (required) :arg offset: (required) :arg text: (required) """ options: Sequence["TermSuggestOption"] length: int offset: int text: str class TermSuggestOption(AttrDict[Any]): """ :arg text: (required) :arg score: (required) :arg freq: (required) :arg highlighted: :arg collate_match: """ text: str score: float freq: int highlighted: str collate_match: bool class TimeSeriesAggregate(AttrDict[Any]): """ :arg buckets: (required) the aggregation buckets as a list :arg meta: """ buckets: Sequence["TimeSeriesBucket"] meta: Mapping[str, Any] @property def buckets_as_dict(self) -> Mapping[str, "TimeSeriesBucket"]: return self.buckets # type: ignore[return-value] class TimeSeriesBucket(AttrDict[Any]): """ :arg key: (required) :arg doc_count: (required) """ key: Mapping[str, Union[int, float, str, bool, None]] doc_count: int class TopHitsAggregate(AttrDict[Any]): """ :arg hits: (required) :arg meta: """ hits: "HitsMetadata" meta: Mapping[str, Any] class TopMetrics(AttrDict[Any]): """ :arg sort: (required) :arg metrics: (required) """ sort: Sequence[Union[Union[int, float, str, bool, None], None]] metrics: Mapping[str, Union[Union[int, float, str, bool, None], None]] class TopMetricsAggregate(AttrDict[Any]): """ :arg top: (required) :arg meta: """ top: Sequence["TopMetrics"] meta: Mapping[str, Any] class TotalHits(AttrDict[Any]): """ :arg relation: (required) :arg value: (required) """ relation: Literal["eq", "gte"] value: int class UnmappedRareTermsAggregate(AttrDict[Any]): """ Result of a `rare_terms` aggregation when the field is unmapped. `buckets` is always empty. :arg buckets: (required) the aggregation buckets as a list :arg meta: """ buckets: Sequence[Any] meta: Mapping[str, Any] @property def buckets_as_dict(self) -> Mapping[str, Any]: return self.buckets # type: ignore[return-value] class UnmappedSamplerAggregate(AttrDict[Any]): """ :arg doc_count: (required) :arg meta: """ doc_count: int meta: Mapping[str, Any] class UnmappedSignificantTermsAggregate(AttrDict[Any]): """ Result of the `significant_terms` aggregation on an unmapped field. `buckets` is always empty. :arg bg_count: :arg doc_count: :arg buckets: (required) the aggregation buckets as a list :arg meta: """ bg_count: int doc_count: int buckets: Sequence[Any] meta: Mapping[str, Any] @property def buckets_as_dict(self) -> Mapping[str, Any]: return self.buckets # type: ignore[return-value] class UnmappedTermsAggregate(AttrDict[Any]): """ Result of a `terms` aggregation when the field is unmapped. `buckets` is always empty. :arg doc_count_error_upper_bound: :arg sum_other_doc_count: :arg buckets: (required) the aggregation buckets as a list :arg meta: """ doc_count_error_upper_bound: int sum_other_doc_count: int buckets: Sequence[Any] meta: Mapping[str, Any] @property def buckets_as_dict(self) -> Mapping[str, Any]: return self.buckets # type: ignore[return-value] class ValueCountAggregate(AttrDict[Any]): """ Value count aggregation result. `value` is always present. :arg value: (required) The metric value. A missing value generally means that there was no data to aggregate, unless specified otherwise. :arg value_as_string: :arg meta: """ value: Union[float, None] value_as_string: str meta: Mapping[str, Any] class VariableWidthHistogramAggregate(AttrDict[Any]): """ :arg buckets: (required) the aggregation buckets as a list :arg meta: """ buckets: Sequence["VariableWidthHistogramBucket"] meta: Mapping[str, Any] @property def buckets_as_dict(self) -> Mapping[str, "VariableWidthHistogramBucket"]: return self.buckets # type: ignore[return-value] class VariableWidthHistogramBucket(AttrDict[Any]): """ :arg min: (required) :arg key: (required) :arg max: (required) :arg doc_count: (required) :arg min_as_string: :arg key_as_string: :arg max_as_string: """ min: float key: float max: float doc_count: int min_as_string: str key_as_string: str max_as_string: str class WeightedAvgAggregate(AttrDict[Any]): """ Weighted average aggregation result. `value` is missing if the weight was set to zero. :arg value: (required) The metric value. A missing value generally means that there was no data to aggregate, unless specified otherwise. :arg value_as_string: :arg meta: """ value: Union[float, None] value_as_string: str meta: Mapping[str, Any]

elasticsearch/dsl/types.py (3,599 lines of code) (raw):