elasticsearch 8.17.2__py3-none-any.whl → 9.0.0__py3-none-any.whl

elasticsearch/dsl/aggs.py

@@ -0,0 +1,3734 @@
+#  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.
+
+import collections.abc
+from copy import deepcopy
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    ClassVar,
+    Dict,
+    Generic,
+    Iterable,
+    Literal,
+    Mapping,
+    MutableMapping,
+    Optional,
+    Sequence,
+    Union,
+    cast,
+)
+
+from elastic_transport.client_utils import DEFAULT
+
+from . import wrappers
+from .query import Query
+from .response.aggs import AggResponse, BucketData, FieldBucketData, TopHitsData
+from .utils import _R, AttrDict, DslBase
+
+if TYPE_CHECKING:
+    from elastic_transport.client_utils import DefaultType
+
+    from . import types
+    from .document_base import InstrumentedField
+    from .search_base import SearchBase
+
+
+def A(
+    name_or_agg: Union[MutableMapping[str, Any], "Agg[_R]", str],
+    filter: Optional[Union[str, "Query"]] = None,
+    **params: Any,
+) -> "Agg[_R]":
+    if filter is not None:
+        if name_or_agg != "filter":
+            raise ValueError(
+                "Aggregation %r doesn't accept positional argument 'filter'."
+                % name_or_agg
+            )
+        params["filter"] = filter
+
+    # {"terms": {"field": "tags"}, "aggs": {...}}
+    if isinstance(name_or_agg, collections.abc.MutableMapping):
+        if params:
+            raise ValueError("A() cannot accept parameters when passing in a dict.")
+        # copy to avoid modifying in-place
+        agg = deepcopy(name_or_agg)
+        # pop out nested aggs
+        aggs = agg.pop("aggs", None)
+        # pop out meta data
+        meta = agg.pop("meta", None)
+        # should be {"terms": {"field": "tags"}}
+        if len(agg) != 1:
+            raise ValueError(
+                'A() can only accept dict with an aggregation ({"terms": {...}}). '
+                "Instead it got (%r)" % name_or_agg
+            )
+        agg_type, params = agg.popitem()
+        if aggs:
+            params = params.copy()
+            params["aggs"] = aggs
+        if meta:
+            params = params.copy()
+            params["meta"] = meta
+        return Agg[_R].get_dsl_class(agg_type)(_expand__to_dot=False, **params)
+
+    # Terms(...) just return the nested agg
+    elif isinstance(name_or_agg, Agg):
+        if params:
+            raise ValueError(
+                "A() cannot accept parameters when passing in an Agg object."
+            )
+        return name_or_agg
+
+    # "terms", field="tags"
+    return Agg[_R].get_dsl_class(name_or_agg)(**params)
+
+
+class Agg(DslBase, Generic[_R]):
+    _type_name = "agg"
+    _type_shortcut = staticmethod(A)
+    name = ""
+
+    def __contains__(self, key: str) -> bool:
+        return False
+
+    def to_dict(self) -> Dict[str, Any]:
+        d = super().to_dict()
+        if isinstance(d[self.name], dict):
+            n = cast(Dict[str, Any], d[self.name])
+            if "meta" in n:
+                d["meta"] = n.pop("meta")
+        return d
+
+    def result(self, search: "SearchBase[_R]", data: Dict[str, Any]) -> AttrDict[Any]:
+        return AggResponse[_R](self, search, data)
+
+
+class AggBase(Generic[_R]):
+    aggs: Dict[str, Agg[_R]]
+    _base: Agg[_R]
+    _params: Dict[str, Any]
+    _param_defs: ClassVar[Dict[str, Any]] = {
+        "aggs": {"type": "agg", "hash": True},
+    }
+
+    def __contains__(self, key: str) -> bool:
+        return key in self._params.get("aggs", {})
+
+    def __getitem__(self, agg_name: str) -> Agg[_R]:
+        agg = cast(
+            Agg[_R], self._params.setdefault("aggs", {})[agg_name]
+        )  # propagate KeyError
+
+        # make sure we're not mutating a shared state - whenever accessing a
+        # bucket, return a shallow copy of it to be safe
+        if isinstance(agg, Bucket):
+            agg = A(agg.name, **agg._params)
+            # be sure to store the copy so any modifications to it will affect us
+            self._params["aggs"][agg_name] = agg
+
+        return agg
+
+    def __setitem__(self, agg_name: str, agg: Agg[_R]) -> None:
+        self.aggs[agg_name] = A(agg)
+
+    def __iter__(self) -> Iterable[str]:
+        return iter(self.aggs)
+
+    def _agg(
+        self,
+        bucket: bool,
+        name: str,
+        agg_type: Union[Dict[str, Any], Agg[_R], str],
+        *args: Any,
+        **params: Any,
+    ) -> Agg[_R]:
+        agg = self[name] = A(agg_type, *args, **params)
+
+        # For chaining - when creating new buckets return them...
+        if bucket:
+            return agg
+        # otherwise return self._base so we can keep chaining
+        else:
+            return self._base
+
+    def metric(
+        self,
+        name: str,
+        agg_type: Union[Dict[str, Any], Agg[_R], str],
+        *args: Any,
+        **params: Any,
+    ) -> Agg[_R]:
+        return self._agg(False, name, agg_type, *args, **params)
+
+    def bucket(
+        self,
+        name: str,
+        agg_type: Union[Dict[str, Any], Agg[_R], str],
+        *args: Any,
+        **params: Any,
+    ) -> "Bucket[_R]":
+        return cast("Bucket[_R]", self._agg(True, name, agg_type, *args, **params))
+
+    def pipeline(
+        self,
+        name: str,
+        agg_type: Union[Dict[str, Any], Agg[_R], str],
+        *args: Any,
+        **params: Any,
+    ) -> "Pipeline[_R]":
+        return cast("Pipeline[_R]", self._agg(False, name, agg_type, *args, **params))
+
+    def result(self, search: "SearchBase[_R]", data: Any) -> AttrDict[Any]:
+        return BucketData(self, search, data)  # type: ignore[arg-type]
+
+
+class Bucket(AggBase[_R], Agg[_R]):
+    def __init__(self, **params: Any):
+        super().__init__(**params)
+        # remember self for chaining
+        self._base = self
+
+    def to_dict(self) -> Dict[str, Any]:
+        d = super(AggBase, self).to_dict()
+        if isinstance(d[self.name], dict):
+            n = cast(AttrDict[Any], d[self.name])
+            if "aggs" in n:
+                d["aggs"] = n.pop("aggs")
+        return d
+
+
+class Pipeline(Agg[_R]):
+    pass
+
+
+class AdjacencyMatrix(Bucket[_R]):
+    """
+    A bucket aggregation returning a form of adjacency matrix. The request
+    provides a collection of named filter expressions, similar to the
+    `filters` aggregation. Each bucket in the response represents a non-
+    empty cell in the matrix of intersecting filters.
+
+    :arg filters: Filters used to create buckets. At least one filter is
+        required.
+    :arg separator: Separator used to concatenate filter names. Defaults
+        to &.
+    """
+
+    name = "adjacency_matrix"
+    _param_defs = {
+        "filters": {"type": "query", "hash": True},
+    }
+
+    def __init__(
+        self,
+        *,
+        filters: Union[Mapping[str, Query], "DefaultType"] = DEFAULT,
+        separator: Union[str, "DefaultType"] = DEFAULT,
+        **kwargs: Any,
+    ):
+        super().__init__(filters=filters, separator=separator, **kwargs)
+
+
+class AutoDateHistogram(Bucket[_R]):
+    """
+    A multi-bucket aggregation similar to the date histogram, except
+    instead of providing an interval to use as the width of each bucket, a
+    target number of buckets is provided.
+
+    :arg buckets: The target number of buckets. Defaults to `10` if
+        omitted.
+    :arg field: The field on which to run the aggregation.
+    :arg format: The date format used to format `key_as_string` in the
+        response. If no `format` is specified, the first date format
+        specified in the field mapping is used.
+    :arg minimum_interval: The minimum rounding interval. This can make
+        the collection process more efficient, as the aggregation will not
+        attempt to round at any interval lower than `minimum_interval`.
+    :arg missing: The value to apply to documents that do not have a
+        value. By default, documents without a value are ignored.
+    :arg offset: Time zone specified as a ISO 8601 UTC offset.
+    :arg params:
+    :arg script:
+    :arg time_zone: Time zone ID.
+    """
+
+    name = "auto_date_histogram"
+
+    def __init__(
+        self,
+        *,
+        buckets: Union[int, "DefaultType"] = DEFAULT,
+        field: Union[str, "InstrumentedField", "DefaultType"] = DEFAULT,
+        format: Union[str, "DefaultType"] = DEFAULT,
+        minimum_interval: Union[
+            Literal["second", "minute", "hour", "day", "month", "year"], "DefaultType"
+        ] = DEFAULT,
+        missing: Any = DEFAULT,
+        offset: Union[str, "DefaultType"] = DEFAULT,
+        params: Union[Mapping[str, Any], "DefaultType"] = DEFAULT,
+        script: Union["types.Script", Dict[str, Any], "DefaultType"] = DEFAULT,
+        time_zone: Union[str, "DefaultType"] = DEFAULT,
+        **kwargs: Any,
+    ):
+        super().__init__(
+            buckets=buckets,
+            field=field,
+            format=format,
+            minimum_interval=minimum_interval,
+            missing=missing,
+            offset=offset,
+            params=params,
+            script=script,
+            time_zone=time_zone,
+            **kwargs,
+        )
+
+    def result(self, search: "SearchBase[_R]", data: Any) -> AttrDict[Any]:
+        return FieldBucketData(self, search, data)
+
+
+class Avg(Agg[_R]):
+    """
+    A single-value metrics aggregation that computes the average of
+    numeric values that are extracted from the aggregated documents.
+
+    :arg format:
+    :arg field: The field on which to run the aggregation.
+    :arg missing: The value to apply to documents that do not have a
+        value. By default, documents without a value are ignored.
+    :arg script:
+    """
+
+    name = "avg"
+
+    def __init__(
+        self,
+        *,
+        format: Union[str, "DefaultType"] = DEFAULT,
+        field: Union[str, "InstrumentedField", "DefaultType"] = DEFAULT,
+        missing: Union[str, int, float, bool, "DefaultType"] = DEFAULT,
+        script: Union["types.Script", Dict[str, Any], "DefaultType"] = DEFAULT,
+        **kwargs: Any,
+    ):
+        super().__init__(
+            format=format, field=field, missing=missing, script=script, **kwargs
+        )
+
+
+class AvgBucket(Pipeline[_R]):
+    """
+    A sibling pipeline aggregation which calculates the mean value of a
+    specified metric in a sibling aggregation. The specified metric must
+    be numeric and the sibling aggregation must be a multi-bucket
+    aggregation.
+
+    :arg format: `DecimalFormat` pattern for the output value. If
+        specified, the formatted value is returned in the aggregation’s
+        `value_as_string` property.
+    :arg gap_policy: Policy to apply when gaps are found in the data.
+        Defaults to `skip` if omitted.
+    :arg buckets_path: Path to the buckets that contain one set of values
+        to correlate.
+    """
+
+    name = "avg_bucket"
+
+    def __init__(
+        self,
+        *,
+        format: Union[str, "DefaultType"] = DEFAULT,
+        gap_policy: Union[
+            Literal["skip", "insert_zeros", "keep_values"], "DefaultType"
+        ] = DEFAULT,
+        buckets_path: Union[
+            str, Sequence[str], Mapping[str, str], "DefaultType"
+        ] = DEFAULT,
+        **kwargs: Any,
+    ):
+        super().__init__(
+            format=format, gap_policy=gap_policy, buckets_path=buckets_path, **kwargs
+        )
+
+
+class Boxplot(Agg[_R]):
+    """
+    A metrics aggregation that computes a box plot of numeric values
+    extracted from the aggregated documents.
+
+    :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.
+    :arg field: The field on which to run the aggregation.
+    :arg missing: The value to apply to documents that do not have a
+        value. By default, documents without a value are ignored.
+    :arg script:
+    """
+
+    name = "boxplot"
+
+    def __init__(
+        self,
+        *,
+        compression: Union[float, "DefaultType"] = DEFAULT,
+        field: Union[str, "InstrumentedField", "DefaultType"] = DEFAULT,
+        missing: Union[str, int, float, bool, "DefaultType"] = DEFAULT,
+        script: Union["types.Script", Dict[str, Any], "DefaultType"] = DEFAULT,
+        **kwargs: Any,
+    ):
+        super().__init__(
+            compression=compression,
+            field=field,
+            missing=missing,
+            script=script,
+            **kwargs,
+        )
+
+
+class BucketScript(Pipeline[_R]):
+    """
+    A parent pipeline aggregation which runs a script which can perform
+    per bucket computations on metrics in the parent multi-bucket
+    aggregation.
+
+    :arg script: The script to run for this aggregation.
+    :arg format: `DecimalFormat` pattern for the output value. If
+        specified, the formatted value is returned in the aggregation’s
+        `value_as_string` property.
+    :arg gap_policy: Policy to apply when gaps are found in the data.
+        Defaults to `skip` if omitted.
+    :arg buckets_path: Path to the buckets that contain one set of values
+        to correlate.
+    """
+
+    name = "bucket_script"
+
+    def __init__(
+        self,
+        *,
+        script: Union["types.Script", Dict[str, Any], "DefaultType"] = DEFAULT,
+        format: Union[str, "DefaultType"] = DEFAULT,
+        gap_policy: Union[
+            Literal["skip", "insert_zeros", "keep_values"], "DefaultType"
+        ] = DEFAULT,
+        buckets_path: Union[
+            str, Sequence[str], Mapping[str, str], "DefaultType"
+        ] = DEFAULT,
+        **kwargs: Any,
+    ):
+        super().__init__(
+            script=script,
+            format=format,
+            gap_policy=gap_policy,
+            buckets_path=buckets_path,
+            **kwargs,
+        )
+
+
+class BucketSelector(Pipeline[_R]):
+    """
+    A parent pipeline aggregation which runs a script to determine whether
+    the current bucket will be retained in the parent multi-bucket
+    aggregation.
+
+    :arg script: The script to run for this aggregation.
+    :arg format: `DecimalFormat` pattern for the output value. If
+        specified, the formatted value is returned in the aggregation’s
+        `value_as_string` property.
+    :arg gap_policy: Policy to apply when gaps are found in the data.
+        Defaults to `skip` if omitted.
+    :arg buckets_path: Path to the buckets that contain one set of values
+        to correlate.
+    """
+
+    name = "bucket_selector"
+
+    def __init__(
+        self,
+        *,
+        script: Union["types.Script", Dict[str, Any], "DefaultType"] = DEFAULT,
+        format: Union[str, "DefaultType"] = DEFAULT,
+        gap_policy: Union[
+            Literal["skip", "insert_zeros", "keep_values"], "DefaultType"
+        ] = DEFAULT,
+        buckets_path: Union[
+            str, Sequence[str], Mapping[str, str], "DefaultType"
+        ] = DEFAULT,
+        **kwargs: Any,
+    ):
+        super().__init__(
+            script=script,
+            format=format,
+            gap_policy=gap_policy,
+            buckets_path=buckets_path,
+            **kwargs,
+        )
+
+
+class BucketSort(Bucket[_R]):
+    """
+    A parent pipeline aggregation which sorts the buckets of its parent
+    multi-bucket aggregation.
+
+    :arg from: Buckets in positions prior to `from` will be truncated.
+    :arg gap_policy: The policy to apply when gaps are found in the data.
+        Defaults to `skip` if omitted.
+    :arg size: The number of buckets to return. Defaults to all buckets of
+        the parent aggregation.
+    :arg sort: The list of fields to sort on.
+    """
+
+    name = "bucket_sort"
+
+    def __init__(
+        self,
+        *,
+        from_: Union[int, "DefaultType"] = DEFAULT,
+        gap_policy: Union[
+            Literal["skip", "insert_zeros", "keep_values"], "DefaultType"
+        ] = DEFAULT,
+        size: Union[int, "DefaultType"] = DEFAULT,
+        sort: Union[
+            Union[Union[str, "InstrumentedField"], "types.SortOptions"],
+            Sequence[Union[Union[str, "InstrumentedField"], "types.SortOptions"]],
+            Dict[str, Any],
+            "DefaultType",
+        ] = DEFAULT,
+        **kwargs: Any,
+    ):
+        super().__init__(
+            from_=from_, gap_policy=gap_policy, size=size, sort=sort, **kwargs
+        )
+
+
+class BucketCountKsTest(Pipeline[_R]):
+    """
+    A sibling pipeline aggregation which runs a two sample
+    Kolmogorov–Smirnov test ("K-S test") against a provided distribution
+    and the distribution implied by the documents counts in the configured
+    sibling aggregation.
+
+    :arg alternative: A list of string values indicating which K-S test
+        alternative to calculate. The valid values are: "greater", "less",
+        "two_sided". This parameter is key for determining the K-S
+        statistic used when calculating the K-S test. Default value is all
+        possible alternative hypotheses.
+    :arg fractions: A list of doubles indicating the distribution of the
+        samples with which to compare to the `buckets_path` results. In
+        typical usage this is the overall proportion of documents in each
+        bucket, which is compared with the actual document proportions in
+        each bucket from the sibling aggregation counts. The default is to
+        assume that overall documents are uniformly distributed on these
+        buckets, which they would be if one used equal percentiles of a
+        metric to define the bucket end points.
+    :arg sampling_method: Indicates the sampling methodology when
+        calculating the K-S test. Note, this is sampling of the returned
+        values. This determines the cumulative distribution function (CDF)
+        points used comparing the two samples. Default is `upper_tail`,
+        which emphasizes the upper end of the CDF points. Valid options
+        are: `upper_tail`, `uniform`, and `lower_tail`.
+    :arg buckets_path: Path to the buckets that contain one set of values
+        to correlate.
+    """
+
+    name = "bucket_count_ks_test"
+
+    def __init__(
+        self,
+        *,
+        alternative: Union[Sequence[str], "DefaultType"] = DEFAULT,
+        fractions: Union[Sequence[float], "DefaultType"] = DEFAULT,
+        sampling_method: Union[str, "DefaultType"] = DEFAULT,
+        buckets_path: Union[
+            str, Sequence[str], Mapping[str, str], "DefaultType"
+        ] = DEFAULT,
+        **kwargs: Any,
+    ):
+        super().__init__(
+            alternative=alternative,
+            fractions=fractions,
+            sampling_method=sampling_method,
+            buckets_path=buckets_path,
+            **kwargs,
+        )
+
+
+class BucketCorrelation(Pipeline[_R]):
+    """
+    A sibling pipeline aggregation which runs a correlation function on
+    the configured sibling multi-bucket aggregation.
+
+    :arg function: (required) The correlation function to execute.
+    :arg buckets_path: Path to the buckets that contain one set of values
+        to correlate.
+    """
+
+    name = "bucket_correlation"
+
+    def __init__(
+        self,
+        *,
+        function: Union[
+            "types.BucketCorrelationFunction", Dict[str, Any], "DefaultType"
+        ] = DEFAULT,
+        buckets_path: Union[
+            str, Sequence[str], Mapping[str, str], "DefaultType"
+        ] = DEFAULT,
+        **kwargs: Any,
+    ):
+        super().__init__(function=function, buckets_path=buckets_path, **kwargs)
+
+
+class Cardinality(Agg[_R]):
+    """
+    A single-value metrics aggregation that calculates an approximate
+    count of distinct values.
+
+    :arg precision_threshold: A unique count below which counts are
+        expected to be close to accurate. This allows to trade memory for
+        accuracy. Defaults to `3000` if omitted.
+    :arg rehash:
+    :arg execution_hint: Mechanism by which cardinality aggregations is
+        run.
+    :arg field: The field on which to run the aggregation.
+    :arg missing: The value to apply to documents that do not have a
+        value. By default, documents without a value are ignored.
+    :arg script:
+    """
+
+    name = "cardinality"
+
+    def __init__(
+        self,
+        *,
+        precision_threshold: Union[int, "DefaultType"] = DEFAULT,
+        rehash: Union[bool, "DefaultType"] = DEFAULT,
+        execution_hint: Union[
+            Literal[
+                "global_ordinals",
+                "segment_ordinals",
+                "direct",
+                "save_memory_heuristic",
+                "save_time_heuristic",
+            ],
+            "DefaultType",
+        ] = DEFAULT,
+        field: Union[str, "InstrumentedField", "DefaultType"] = DEFAULT,
+        missing: Union[str, int, float, bool, "DefaultType"] = DEFAULT,
+        script: Union["types.Script", Dict[str, Any], "DefaultType"] = DEFAULT,
+        **kwargs: Any,
+    ):
+        super().__init__(
+            precision_threshold=precision_threshold,
+            rehash=rehash,
+            execution_hint=execution_hint,
+            field=field,
+            missing=missing,
+            script=script,
+            **kwargs,
+        )
+
+
+class CategorizeText(Bucket[_R]):
+    """
+    A multi-bucket aggregation that groups semi-structured text into
+    buckets.
+
+    :arg field: (required) The semi-structured text field to categorize.
+    :arg max_unique_tokens: The maximum number of unique tokens at any
+        position up to max_matched_tokens. Must be larger than 1. Smaller
+        values use less memory and create fewer categories. Larger values
+        will use more memory and create narrower categories. Max allowed
+        value is 100. Defaults to `50` if omitted.
+    :arg max_matched_tokens: The maximum number of token positions to
+        match on before attempting to merge categories. Larger values will
+        use more memory and create narrower categories. Max allowed value
+        is 100. Defaults to `5` if omitted.
+    :arg similarity_threshold: The minimum percentage of tokens that must
+        match for text to be added to the category bucket. Must be between
+        1 and 100. The larger the value the narrower the categories.
+        Larger values will increase memory usage and create narrower
+        categories. Defaults to `50` if omitted.
+    :arg categorization_filters: This property expects an array of regular
+        expressions. The expressions are used to filter out matching
+        sequences from the categorization field values. You can use this
+        functionality to fine tune the categorization by excluding
+        sequences from consideration when categories are defined. For
+        example, you can exclude SQL statements that appear in your log
+        files. This property cannot be used at the same time as
+        categorization_analyzer. If you only want to define simple regular
+        expression filters that are applied prior to tokenization, setting
+        this property is the easiest method. If you also want to customize
+        the tokenizer or post-tokenization filtering, use the
+        categorization_analyzer property instead and include the filters
+        as pattern_replace character filters.
+    :arg categorization_analyzer: The categorization analyzer specifies
+        how the text is analyzed and tokenized before being categorized.
+        The syntax is very similar to that used to define the analyzer in
+        the analyze API. This property cannot be used at the same time as
+        `categorization_filters`.
+    :arg shard_size: The number of categorization buckets to return from
+        each shard before merging all the results.
+    :arg size: The number of buckets to return. Defaults to `10` if
+        omitted.
+    :arg min_doc_count: The minimum number of documents in a bucket to be
+        returned to the results.
+    :arg shard_min_doc_count: The minimum number of documents in a bucket
+        to be returned from the shard before merging.
+    """
+
+    name = "categorize_text"
+
+    def __init__(
+        self,
+        *,
+        field: Union[str, "InstrumentedField", "DefaultType"] = DEFAULT,
+        max_unique_tokens: Union[int, "DefaultType"] = DEFAULT,
+        max_matched_tokens: Union[int, "DefaultType"] = DEFAULT,
+        similarity_threshold: Union[int, "DefaultType"] = DEFAULT,
+        categorization_filters: Union[Sequence[str], "DefaultType"] = DEFAULT,
+        categorization_analyzer: Union[
+            str, "types.CustomCategorizeTextAnalyzer", Dict[str, Any], "DefaultType"
+        ] = DEFAULT,
+        shard_size: Union[int, "DefaultType"] = DEFAULT,
+        size: Union[int, "DefaultType"] = DEFAULT,
+        min_doc_count: Union[int, "DefaultType"] = DEFAULT,
+        shard_min_doc_count: Union[int, "DefaultType"] = DEFAULT,
+        **kwargs: Any,
+    ):
+        super().__init__(
+            field=field,
+            max_unique_tokens=max_unique_tokens,
+            max_matched_tokens=max_matched_tokens,
+            similarity_threshold=similarity_threshold,
+            categorization_filters=categorization_filters,
+            categorization_analyzer=categorization_analyzer,
+            shard_size=shard_size,
+            size=size,
+            min_doc_count=min_doc_count,
+            shard_min_doc_count=shard_min_doc_count,
+            **kwargs,
+        )
+
+
+class Children(Bucket[_R]):
+    """
+    A single bucket aggregation that selects child documents that have the
+    specified type, as defined in a `join` field.
+
+    :arg type: The child type that should be selected.
+    """
+
+    name = "children"
+
+    def __init__(self, type: Union[str, "DefaultType"] = DEFAULT, **kwargs: Any):
+        super().__init__(type=type, **kwargs)
+
+
+class Composite(Bucket[_R]):
+    """
+    A multi-bucket aggregation that creates composite buckets from
+    different sources. Unlike the other multi-bucket aggregations, you can
+    use the `composite` aggregation to paginate *all* buckets from a
+    multi-level aggregation efficiently.
+
+    :arg after: When paginating, use the `after_key` value returned in the
+        previous response to retrieve the next page.
+    :arg size: The number of composite buckets that should be returned.
+        Defaults to `10` if omitted.
+    :arg sources: The value sources used to build composite buckets. Keys
+        are returned in the order of the `sources` definition.
+    """
+
+    name = "composite"
+
+    def __init__(
+        self,
+        *,
+        after: Union[
+            Mapping[
+                Union[str, "InstrumentedField"], Union[int, float, str, bool, None]
+            ],
+            "DefaultType",
+        ] = DEFAULT,
+        size: Union[int, "DefaultType"] = DEFAULT,
+        sources: Union[Sequence[Mapping[str, Agg[_R]]], "DefaultType"] = DEFAULT,
+        **kwargs: Any,
+    ):
+        super().__init__(after=after, size=size, sources=sources, **kwargs)
+
+
+class CumulativeCardinality(Pipeline[_R]):
+    """
+    A parent pipeline aggregation which calculates the cumulative
+    cardinality in a parent `histogram` or `date_histogram` aggregation.
+
+    :arg format: `DecimalFormat` pattern for the output value. If
+        specified, the formatted value is returned in the aggregation’s
+        `value_as_string` property.
+    :arg gap_policy: Policy to apply when gaps are found in the data.
+        Defaults to `skip` if omitted.
+    :arg buckets_path: Path to the buckets that contain one set of values
+        to correlate.
+    """
+
+    name = "cumulative_cardinality"
+
+    def __init__(
+        self,
+        *,
+        format: Union[str, "DefaultType"] = DEFAULT,
+        gap_policy: Union[
+            Literal["skip", "insert_zeros", "keep_values"], "DefaultType"
+        ] = DEFAULT,
+        buckets_path: Union[
+            str, Sequence[str], Mapping[str, str], "DefaultType"
+        ] = DEFAULT,
+        **kwargs: Any,
+    ):
+        super().__init__(
+            format=format, gap_policy=gap_policy, buckets_path=buckets_path, **kwargs
+        )
+
+
+class CumulativeSum(Pipeline[_R]):
+    """
+    A parent pipeline aggregation which calculates the cumulative sum of a
+    specified metric in a parent `histogram` or `date_histogram`
+    aggregation.
+
+    :arg format: `DecimalFormat` pattern for the output value. If
+        specified, the formatted value is returned in the aggregation’s
+        `value_as_string` property.
+    :arg gap_policy: Policy to apply when gaps are found in the data.
+        Defaults to `skip` if omitted.
+    :arg buckets_path: Path to the buckets that contain one set of values
+        to correlate.
+    """
+
+    name = "cumulative_sum"
+
+    def __init__(
+        self,
+        *,
+        format: Union[str, "DefaultType"] = DEFAULT,
+        gap_policy: Union[
+            Literal["skip", "insert_zeros", "keep_values"], "DefaultType"
+        ] = DEFAULT,
+        buckets_path: Union[
+            str, Sequence[str], Mapping[str, str], "DefaultType"
+        ] = DEFAULT,
+        **kwargs: Any,
+    ):
+        super().__init__(
+            format=format, gap_policy=gap_policy, buckets_path=buckets_path, **kwargs
+        )
+
+
+class DateHistogram(Bucket[_R]):
+    """
+    A multi-bucket values source based aggregation that can be applied on
+    date values or date range values extracted from the documents. It
+    dynamically builds fixed size (interval) buckets over the values.
+
+    :arg calendar_interval: Calendar-aware interval. Can be specified
+        using the unit name, such as `month`, or as a single unit
+        quantity, such as `1M`.
+    :arg extended_bounds: Enables extending the bounds of the histogram
+        beyond the data itself.
+    :arg hard_bounds: Limits the histogram to specified bounds.
+    :arg field: The date field whose values are use to build a histogram.
+    :arg fixed_interval: Fixed intervals: a fixed number of SI units and
+        never deviate, regardless of where they fall on the calendar.
+    :arg format: The date format used to format `key_as_string` in the
+        response. If no `format` is specified, the first date format
+        specified in the field mapping is used.
+    :arg interval:
+    :arg min_doc_count: Only returns buckets that have `min_doc_count`
+        number of documents. By default, all buckets between the first
+        bucket that matches documents and the last one are returned.
+    :arg missing: The value to apply to documents that do not have a
+        value. By default, documents without a value are ignored.
+    :arg offset: Changes the start value of each bucket by the specified
+        positive (`+`) or negative offset (`-`) duration.
+    :arg order: The sort order of the returned buckets.
+    :arg params:
+    :arg script:
+    :arg time_zone: Time zone used for bucketing and rounding. Defaults to
+        Coordinated Universal Time (UTC).
+    :arg keyed: Set to `true` to associate a unique string key with each
+        bucket and return the ranges as a hash rather than an array.
+    """
+
+    name = "date_histogram"
+
+    def __init__(
+        self,
+        *,
+        calendar_interval: Union[
+            Literal[
+                "second", "minute", "hour", "day", "week", "month", "quarter", "year"
+            ],
+            "DefaultType",
+        ] = DEFAULT,
+        extended_bounds: Union[
+            "types.ExtendedBounds", Dict[str, Any], "DefaultType"
+        ] = DEFAULT,
+        hard_bounds: Union[
+            "types.ExtendedBounds", Dict[str, Any], "DefaultType"
+        ] = DEFAULT,
+        field: Union[str, "InstrumentedField", "DefaultType"] = DEFAULT,
+        fixed_interval: Any = DEFAULT,
+        format: Union[str, "DefaultType"] = DEFAULT,
+        interval: Any = DEFAULT,
+        min_doc_count: Union[int, "DefaultType"] = DEFAULT,
+        missing: Any = DEFAULT,
+        offset: Any = DEFAULT,
+        order: Union[
+            Mapping[Union[str, "InstrumentedField"], Literal["asc", "desc"]],
+            Sequence[Mapping[Union[str, "InstrumentedField"], Literal["asc", "desc"]]],
+            "DefaultType",
+        ] = DEFAULT,
+        params: Union[Mapping[str, Any], "DefaultType"] = DEFAULT,
+        script: Union["types.Script", Dict[str, Any], "DefaultType"] = DEFAULT,
+        time_zone: Union[str, "DefaultType"] = DEFAULT,
+        keyed: Union[bool, "DefaultType"] = DEFAULT,
+        **kwargs: Any,
+    ):
+        super().__init__(
+            calendar_interval=calendar_interval,
+            extended_bounds=extended_bounds,
+            hard_bounds=hard_bounds,
+            field=field,
+            fixed_interval=fixed_interval,
+            format=format,
+            interval=interval,
+            min_doc_count=min_doc_count,
+            missing=missing,
+            offset=offset,
+            order=order,
+            params=params,
+            script=script,
+            time_zone=time_zone,
+            keyed=keyed,
+            **kwargs,
+        )
+
+    def result(self, search: "SearchBase[_R]", data: Any) -> AttrDict[Any]:
+        return FieldBucketData(self, search, data)
+
+
+class DateRange(Bucket[_R]):
+    """
+    A multi-bucket value source based aggregation that enables the user to
+    define a set of date ranges - each representing a bucket.
+
+    :arg field: The date field whose values are use to build ranges.
+    :arg format: The date format used to format `from` and `to` in the
+        response.
+    :arg missing: The value to apply to documents that do not have a
+        value. By default, documents without a value are ignored.
+    :arg ranges: Array of date ranges.
+    :arg time_zone: Time zone used to convert dates from another time zone
+        to UTC.
+    :arg keyed: Set to `true` to associate a unique string key with each
+        bucket and returns the ranges as a hash rather than an array.
+    """
+
+    name = "date_range"
+
+    def __init__(
+        self,
+        *,
+        field: Union[str, "InstrumentedField", "DefaultType"] = DEFAULT,
+        format: Union[str, "DefaultType"] = DEFAULT,
+        missing: Union[str, int, float, bool, "DefaultType"] = DEFAULT,
+        ranges: Union[
+            Sequence["wrappers.AggregationRange"],
+            Sequence[Dict[str, Any]],
+            "DefaultType",
+        ] = DEFAULT,
+        time_zone: Union[str, "DefaultType"] = DEFAULT,
+        keyed: Union[bool, "DefaultType"] = DEFAULT,
+        **kwargs: Any,
+    ):
+        super().__init__(
+            field=field,
+            format=format,
+            missing=missing,
+            ranges=ranges,
+            time_zone=time_zone,
+            keyed=keyed,
+            **kwargs,
+        )
+
+
+class Derivative(Pipeline[_R]):
+    """
+    A parent pipeline aggregation which calculates the derivative of a
+    specified metric in a parent `histogram` or `date_histogram`
+    aggregation.
+
+    :arg format: `DecimalFormat` pattern for the output value. If
+        specified, the formatted value is returned in the aggregation’s
+        `value_as_string` property.
+    :arg gap_policy: Policy to apply when gaps are found in the data.
+        Defaults to `skip` if omitted.
+    :arg buckets_path: Path to the buckets that contain one set of values
+        to correlate.
+    """
+
+    name = "derivative"
+
+    def __init__(
+        self,
+        *,
+        format: Union[str, "DefaultType"] = DEFAULT,
+        gap_policy: Union[
+            Literal["skip", "insert_zeros", "keep_values"], "DefaultType"
+        ] = DEFAULT,
+        buckets_path: Union[
+            str, Sequence[str], Mapping[str, str], "DefaultType"
+        ] = DEFAULT,
+        **kwargs: Any,
+    ):
+        super().__init__(
+            format=format, gap_policy=gap_policy, buckets_path=buckets_path, **kwargs
+        )
+
+
+class DiversifiedSampler(Bucket[_R]):
+    """
+    A filtering aggregation used to limit any sub aggregations' processing
+    to a sample of the top-scoring documents. Similar to the `sampler`
+    aggregation, but adds the ability to limit the number of matches that
+    share a common value.
+
+    :arg execution_hint: The type of value used for de-duplication.
+        Defaults to `global_ordinals` if omitted.
+    :arg max_docs_per_value: Limits how many documents are permitted per
+        choice of de-duplicating value. Defaults to `1` if omitted.
+    :arg script:
+    :arg shard_size: Limits how many top-scoring documents are collected
+        in the sample processed on each shard. Defaults to `100` if
+        omitted.
+    :arg field: The field used to provide values used for de-duplication.
+    """
+
+    name = "diversified_sampler"
+
+    def __init__(
+        self,
+        *,
+        execution_hint: Union[
+            Literal["map", "global_ordinals", "bytes_hash"], "DefaultType"
+        ] = DEFAULT,
+        max_docs_per_value: Union[int, "DefaultType"] = DEFAULT,
+        script: Union["types.Script", Dict[str, Any], "DefaultType"] = DEFAULT,
+        shard_size: Union[int, "DefaultType"] = DEFAULT,
+        field: Union[str, "InstrumentedField", "DefaultType"] = DEFAULT,
+        **kwargs: Any,
+    ):
+        super().__init__(
+            execution_hint=execution_hint,
+            max_docs_per_value=max_docs_per_value,
+            script=script,
+            shard_size=shard_size,
+            field=field,
+            **kwargs,
+        )
+
+
+class ExtendedStats(Agg[_R]):
+    """
+    A multi-value metrics aggregation that computes stats over numeric
+    values extracted from the aggregated documents.
+
+    :arg sigma: The number of standard deviations above/below the mean to
+        display.
+    :arg format:
+    :arg field: The field on which to run the aggregation.
+    :arg missing: The value to apply to documents that do not have a
+        value. By default, documents without a value are ignored.
+    :arg script:
+    """
+
+    name = "extended_stats"
+
+    def __init__(
+        self,
+        *,
+        sigma: Union[float, "DefaultType"] = DEFAULT,
+        format: Union[str, "DefaultType"] = DEFAULT,
+        field: Union[str, "InstrumentedField", "DefaultType"] = DEFAULT,
+        missing: Union[str, int, float, bool, "DefaultType"] = DEFAULT,
+        script: Union["types.Script", Dict[str, Any], "DefaultType"] = DEFAULT,
+        **kwargs: Any,
+    ):
+        super().__init__(
+            sigma=sigma,
+            format=format,
+            field=field,
+            missing=missing,
+            script=script,
+            **kwargs,
+        )
+
+
+class ExtendedStatsBucket(Pipeline[_R]):
+    """
+    A sibling pipeline aggregation which calculates a variety of stats
+    across all bucket of a specified metric in a sibling aggregation.
+
+    :arg sigma: The number of standard deviations above/below the mean to
+        display.
+    :arg format: `DecimalFormat` pattern for the output value. If
+        specified, the formatted value is returned in the aggregation’s
+        `value_as_string` property.
+    :arg gap_policy: Policy to apply when gaps are found in the data.
+        Defaults to `skip` if omitted.
+    :arg buckets_path: Path to the buckets that contain one set of values
+        to correlate.
+    """
+
+    name = "extended_stats_bucket"
+
+    def __init__(
+        self,
+        *,
+        sigma: Union[float, "DefaultType"] = DEFAULT,
+        format: Union[str, "DefaultType"] = DEFAULT,
+        gap_policy: Union[
+            Literal["skip", "insert_zeros", "keep_values"], "DefaultType"
+        ] = DEFAULT,
+        buckets_path: Union[
+            str, Sequence[str], Mapping[str, str], "DefaultType"
+        ] = DEFAULT,
+        **kwargs: Any,
+    ):
+        super().__init__(
+            sigma=sigma,
+            format=format,
+            gap_policy=gap_policy,
+            buckets_path=buckets_path,
+            **kwargs,
+        )
+
+
+class FrequentItemSets(Agg[_R]):
+    """
+    A bucket aggregation which finds frequent item sets, a form of
+    association rules mining that identifies items that often occur
+    together.
+
+    :arg fields: (required) Fields to analyze.
+    :arg minimum_set_size: The minimum size of one item set. Defaults to
+        `1` if omitted.
+    :arg minimum_support: The minimum support of one item set. Defaults to
+        `0.1` if omitted.
+    :arg size: The number of top item sets to return. Defaults to `10` if
+        omitted.
+    :arg filter: Query that filters documents from analysis.
+    """
+
+    name = "frequent_item_sets"
+    _param_defs = {
+        "filter": {"type": "query"},
+    }
+
+    def __init__(
+        self,
+        *,
+        fields: Union[
+            Sequence["types.FrequentItemSetsField"],
+            Sequence[Dict[str, Any]],
+            "DefaultType",
+        ] = DEFAULT,
+        minimum_set_size: Union[int, "DefaultType"] = DEFAULT,
+        minimum_support: Union[float, "DefaultType"] = DEFAULT,
+        size: Union[int, "DefaultType"] = DEFAULT,
+        filter: Union[Query, "DefaultType"] = DEFAULT,
+        **kwargs: Any,
+    ):
+        super().__init__(
+            fields=fields,
+            minimum_set_size=minimum_set_size,
+            minimum_support=minimum_support,
+            size=size,
+            filter=filter,
+            **kwargs,
+        )
+
+
+class Filter(Bucket[_R]):
+    """
+    A single bucket aggregation that narrows the set of documents to those
+    that match a query.
+
+    :arg filter: A single bucket aggregation that narrows the set of
+        documents to those that match a query.
+    """
+
+    name = "filter"
+    _param_defs = {
+        "filter": {"type": "query"},
+        "aggs": {"type": "agg", "hash": True},
+    }
+
+    def __init__(self, filter: Union[Query, "DefaultType"] = DEFAULT, **kwargs: Any):
+        super().__init__(filter=filter, **kwargs)
+
+    def to_dict(self) -> Dict[str, Any]:
+        d = super().to_dict()
+        if isinstance(d[self.name], dict):
+            n = cast(AttrDict[Any], d[self.name])
+            n.update(n.pop("filter", {}))
+        return d
+
+
+class Filters(Bucket[_R]):
+    """
+    A multi-bucket aggregation where each bucket contains the documents
+    that match a query.
+
+    :arg filters: Collection of queries from which to build buckets.
+    :arg other_bucket: Set to `true` to add a bucket to the response which
+        will contain all documents that do not match any of the given
+        filters.
+    :arg other_bucket_key: The key with which the other bucket is
+        returned. Defaults to `_other_` if omitted.
+    :arg keyed: By default, the named filters aggregation returns the
+        buckets as an object. Set to `false` to return the buckets as an
+        array of objects. Defaults to `True` if omitted.
+    """
+
+    name = "filters"
+    _param_defs = {
+        "filters": {"type": "query", "hash": True},
+        "aggs": {"type": "agg", "hash": True},
+    }
+
+    def __init__(
+        self,
+        *,
+        filters: Union[Dict[str, Query], "DefaultType"] = DEFAULT,
+        other_bucket: Union[bool, "DefaultType"] = DEFAULT,
+        other_bucket_key: Union[str, "DefaultType"] = DEFAULT,
+        keyed: Union[bool, "DefaultType"] = DEFAULT,
+        **kwargs: Any,
+    ):
+        super().__init__(
+            filters=filters,
+            other_bucket=other_bucket,
+            other_bucket_key=other_bucket_key,
+            keyed=keyed,
+            **kwargs,
+        )
+
+
+class GeoBounds(Agg[_R]):
+    """
+    A metric aggregation that computes the geographic bounding box
+    containing all values for a Geopoint or Geoshape field.
+
+    :arg wrap_longitude: Specifies whether the bounding box should be
+        allowed to overlap the international date line. Defaults to `True`
+        if omitted.
+    :arg field: The field on which to run the aggregation.
+    :arg missing: The value to apply to documents that do not have a
+        value. By default, documents without a value are ignored.
+    :arg script:
+    """
+
+    name = "geo_bounds"
+
+    def __init__(
+        self,
+        *,
+        wrap_longitude: Union[bool, "DefaultType"] = DEFAULT,
+        field: Union[str, "InstrumentedField", "DefaultType"] = DEFAULT,
+        missing: Union[str, int, float, bool, "DefaultType"] = DEFAULT,
+        script: Union["types.Script", Dict[str, Any], "DefaultType"] = DEFAULT,
+        **kwargs: Any,
+    ):
+        super().__init__(
+            wrap_longitude=wrap_longitude,
+            field=field,
+            missing=missing,
+            script=script,
+            **kwargs,
+        )
+
+
+class GeoCentroid(Agg[_R]):
+    """
+    A metric aggregation that computes the weighted centroid from all
+    coordinate values for geo fields.
+
+    :arg count:
+    :arg location:
+    :arg field: The field on which to run the aggregation.
+    :arg missing: The value to apply to documents that do not have a
+        value. By default, documents without a value are ignored.
+    :arg script:
+    """
+
+    name = "geo_centroid"
+
+    def __init__(
+        self,
+        *,
+        count: Union[int, "DefaultType"] = DEFAULT,
+        location: Union[
+            "types.LatLonGeoLocation",
+            "types.GeoHashLocation",
+            Sequence[float],
+            str,
+            Dict[str, Any],
+            "DefaultType",
+        ] = DEFAULT,
+        field: Union[str, "InstrumentedField", "DefaultType"] = DEFAULT,
+        missing: Union[str, int, float, bool, "DefaultType"] = DEFAULT,
+        script: Union["types.Script", Dict[str, Any], "DefaultType"] = DEFAULT,
+        **kwargs: Any,
+    ):
+        super().__init__(
+            count=count,
+            location=location,
+            field=field,
+            missing=missing,
+            script=script,
+            **kwargs,
+        )
+
+
+class GeoDistance(Bucket[_R]):
+    """
+    A multi-bucket aggregation that works on `geo_point` fields. Evaluates
+    the distance of each document value from an origin point and
+    determines the buckets it belongs to, based on ranges defined in the
+    request.
+
+    :arg distance_type: The distance calculation type. Defaults to `arc`
+        if omitted.
+    :arg field: A field of type `geo_point` used to evaluate the distance.
+    :arg origin: The origin  used to evaluate the distance.
+    :arg ranges: An array of ranges used to bucket documents.
+    :arg unit: The distance unit. Defaults to `m` if omitted.
+    """
+
+    name = "geo_distance"
+
+    def __init__(
+        self,
+        *,
+        distance_type: Union[Literal["arc", "plane"], "DefaultType"] = DEFAULT,
+        field: Union[str, "InstrumentedField", "DefaultType"] = DEFAULT,
+        origin: Union[
+            "types.LatLonGeoLocation",
+            "types.GeoHashLocation",
+            Sequence[float],
+            str,
+            Dict[str, Any],
+            "DefaultType",
+        ] = DEFAULT,
+        ranges: Union[
+            Sequence["wrappers.AggregationRange"],
+            Sequence[Dict[str, Any]],
+            "DefaultType",
+        ] = DEFAULT,
+        unit: Union[
+            Literal["in", "ft", "yd", "mi", "nmi", "km", "m", "cm", "mm"], "DefaultType"
+        ] = DEFAULT,
+        **kwargs: Any,
+    ):
+        super().__init__(
+            distance_type=distance_type,
+            field=field,
+            origin=origin,
+            ranges=ranges,
+            unit=unit,
+            **kwargs,
+        )
+
+
+class GeohashGrid(Bucket[_R]):
+    """
+    A multi-bucket aggregation that groups `geo_point` and `geo_shape`
+    values into buckets that represent a grid. Each cell is labeled using
+    a geohash which is of user-definable precision.
+
+    :arg bounds: The bounding box to filter the points in each bucket.
+    :arg field: Field containing indexed `geo_point` or `geo_shape`
+        values. If the field contains an array, `geohash_grid` aggregates
+        all array values.
+    :arg precision: The string length of the geohashes used to define
+        cells/buckets in the results. Defaults to `5` if omitted.
+    :arg shard_size: Allows for more accurate counting of the top cells
+        returned in the final result the aggregation. Defaults to
+        returning `max(10,(size x number-of-shards))` buckets from each
+        shard.
+    :arg size: The maximum number of geohash buckets to return. Defaults
+        to `10000` if omitted.
+    """
+
+    name = "geohash_grid"
+
+    def __init__(
+        self,
+        *,
+        bounds: Union[
+            "types.CoordsGeoBounds",
+            "types.TopLeftBottomRightGeoBounds",
+            "types.TopRightBottomLeftGeoBounds",
+            "types.WktGeoBounds",
+            Dict[str, Any],
+            "DefaultType",
+        ] = DEFAULT,
+        field: Union[str, "InstrumentedField", "DefaultType"] = DEFAULT,
+        precision: Union[float, str, "DefaultType"] = DEFAULT,
+        shard_size: Union[int, "DefaultType"] = DEFAULT,
+        size: Union[int, "DefaultType"] = DEFAULT,
+        **kwargs: Any,
+    ):
+        super().__init__(
+            bounds=bounds,
+            field=field,
+            precision=precision,
+            shard_size=shard_size,
+            size=size,
+            **kwargs,
+        )
+
+
+class GeoLine(Agg[_R]):
+    """
+    Aggregates all `geo_point` values within a bucket into a `LineString`
+    ordered by the chosen sort field.
+
+    :arg point: (required) The name of the geo_point field.
+    :arg sort: (required) The name of the numeric field to use as the sort
+        key for ordering the points. When the `geo_line` aggregation is
+        nested inside a `time_series` aggregation, this field defaults to
+        `@timestamp`, and any other value will result in error.
+    :arg include_sort: When `true`, returns an additional array of the
+        sort values in the feature properties.
+    :arg sort_order: The order in which the line is sorted (ascending or
+        descending). Defaults to `asc` if omitted.
+    :arg size: The maximum length of the line represented in the
+        aggregation. Valid sizes are between 1 and 10000. Defaults to
+        `10000` if omitted.
+    """
+
+    name = "geo_line"
+
+    def __init__(
+        self,
+        *,
+        point: Union["types.GeoLinePoint", Dict[str, Any], "DefaultType"] = DEFAULT,
+        sort: Union["types.GeoLineSort", Dict[str, Any], "DefaultType"] = DEFAULT,
+        include_sort: Union[bool, "DefaultType"] = DEFAULT,
+        sort_order: Union[Literal["asc", "desc"], "DefaultType"] = DEFAULT,
+        size: Union[int, "DefaultType"] = DEFAULT,
+        **kwargs: Any,
+    ):
+        super().__init__(
+            point=point,
+            sort=sort,
+            include_sort=include_sort,
+            sort_order=sort_order,
+            size=size,
+            **kwargs,
+        )
+
+
+class GeotileGrid(Bucket[_R]):
+    """
+    A multi-bucket aggregation that groups `geo_point` and `geo_shape`
+    values into buckets that represent a grid. Each cell corresponds to a
+    map tile as used by many online map sites.
+
+    :arg field: Field containing indexed `geo_point` or `geo_shape`
+        values. If the field contains an array, `geotile_grid` aggregates
+        all array values.
+    :arg precision: Integer zoom of the key used to define cells/buckets
+        in the results. Values outside of the range [0,29] will be
+        rejected. Defaults to `7` if omitted.
+    :arg shard_size: Allows for more accurate counting of the top cells
+        returned in the final result the aggregation. Defaults to
+        returning `max(10,(size x number-of-shards))` buckets from each
+        shard.
+    :arg size: The maximum number of buckets to return. Defaults to
+        `10000` if omitted.
+    :arg bounds: A bounding box to filter the geo-points or geo-shapes in
+        each bucket.
+    """
+
+    name = "geotile_grid"
+
+    def __init__(
+        self,
+        *,
+        field: Union[str, "InstrumentedField", "DefaultType"] = DEFAULT,
+        precision: Union[float, "DefaultType"] = DEFAULT,
+        shard_size: Union[int, "DefaultType"] = DEFAULT,
+        size: Union[int, "DefaultType"] = DEFAULT,
+        bounds: Union[
+            "types.CoordsGeoBounds",
+            "types.TopLeftBottomRightGeoBounds",
+            "types.TopRightBottomLeftGeoBounds",
+            "types.WktGeoBounds",
+            Dict[str, Any],
+            "DefaultType",
+        ] = DEFAULT,
+        **kwargs: Any,
+    ):
+        super().__init__(
+            field=field,
+            precision=precision,
+            shard_size=shard_size,
+            size=size,
+            bounds=bounds,
+            **kwargs,
+        )
+
+
+class GeohexGrid(Bucket[_R]):
+    """
+    A multi-bucket aggregation that groups `geo_point` and `geo_shape`
+    values into buckets that represent a grid. Each cell corresponds to a
+    H3 cell index and is labeled using the H3Index representation.
+
+    :arg field: (required) Field containing indexed `geo_point` or
+        `geo_shape` values. If the field contains an array, `geohex_grid`
+        aggregates all array values.
+    :arg precision: Integer zoom of the key used to defined cells or
+        buckets in the results. Value should be between 0-15. Defaults to
+        `6` if omitted.
+    :arg bounds: Bounding box used to filter the geo-points in each
+        bucket.
+    :arg size: Maximum number of buckets to return. Defaults to `10000` if
+        omitted.
+    :arg shard_size: Number of buckets returned from each shard.
+    """
+
+    name = "geohex_grid"
+
+    def __init__(
+        self,
+        *,
+        field: Union[str, "InstrumentedField", "DefaultType"] = DEFAULT,
+        precision: Union[int, "DefaultType"] = DEFAULT,
+        bounds: Union[
+            "types.CoordsGeoBounds",
+            "types.TopLeftBottomRightGeoBounds",
+            "types.TopRightBottomLeftGeoBounds",
+            "types.WktGeoBounds",
+            Dict[str, Any],
+            "DefaultType",
+        ] = DEFAULT,
+        size: Union[int, "DefaultType"] = DEFAULT,
+        shard_size: Union[int, "DefaultType"] = DEFAULT,
+        **kwargs: Any,
+    ):
+        super().__init__(
+            field=field,
+            precision=precision,
+            bounds=bounds,
+            size=size,
+            shard_size=shard_size,
+            **kwargs,
+        )
+
+
+class Global(Bucket[_R]):
+    """
+    Defines a single bucket of all the documents within the search
+    execution context. This context is defined by the indices and the
+    document types you’re searching on, but is not influenced by the
+    search query itself.
+    """
+
+    name = "global"
+
+    def __init__(self, **kwargs: Any):
+        super().__init__(**kwargs)
+
+
+class Histogram(Bucket[_R]):
+    """
+    A multi-bucket values source based aggregation that can be applied on
+    numeric values or numeric range values extracted from the documents.
+    It dynamically builds fixed size (interval) buckets over the values.
+
+    :arg extended_bounds: Enables extending the bounds of the histogram
+        beyond the data itself.
+    :arg hard_bounds: Limits the range of buckets in the histogram. It is
+        particularly useful in the case of open data ranges that can
+        result in a very large number of buckets.
+    :arg field: The name of the field to aggregate on.
+    :arg interval: The interval for the buckets. Must be a positive
+        decimal.
+    :arg min_doc_count: Only returns buckets that have `min_doc_count`
+        number of documents. By default, the response will fill gaps in
+        the histogram with empty buckets.
+    :arg missing: The value to apply to documents that do not have a
+        value. By default, documents without a value are ignored.
+    :arg offset: By default, the bucket keys start with 0 and then
+        continue in even spaced steps of `interval`. The bucket boundaries
+        can be shifted by using the `offset` option.
+    :arg order: The sort order of the returned buckets. By default, the
+        returned buckets are sorted by their key ascending.
+    :arg script:
+    :arg format:
+    :arg keyed: If `true`, returns buckets as a hash instead of an array,
+        keyed by the bucket keys.
+    """
+
+    name = "histogram"
+
+    def __init__(
+        self,
+        *,
+        extended_bounds: Union[
+            "types.ExtendedBounds", Dict[str, Any], "DefaultType"
+        ] = DEFAULT,
+        hard_bounds: Union[
+            "types.ExtendedBounds", Dict[str, Any], "DefaultType"
+        ] = DEFAULT,
+        field: Union[str, "InstrumentedField", "DefaultType"] = DEFAULT,
+        interval: Union[float, "DefaultType"] = DEFAULT,
+        min_doc_count: Union[int, "DefaultType"] = DEFAULT,
+        missing: Union[float, "DefaultType"] = DEFAULT,
+        offset: Union[float, "DefaultType"] = DEFAULT,
+        order: Union[
+            Mapping[Union[str, "InstrumentedField"], Literal["asc", "desc"]],
+            Sequence[Mapping[Union[str, "InstrumentedField"], Literal["asc", "desc"]]],
+            "DefaultType",
+        ] = DEFAULT,
+        script: Union["types.Script", Dict[str, Any], "DefaultType"] = DEFAULT,
+        format: Union[str, "DefaultType"] = DEFAULT,
+        keyed: Union[bool, "DefaultType"] = DEFAULT,
+        **kwargs: Any,
+    ):
+        super().__init__(
+            extended_bounds=extended_bounds,
+            hard_bounds=hard_bounds,
+            field=field,
+            interval=interval,
+            min_doc_count=min_doc_count,
+            missing=missing,
+            offset=offset,
+            order=order,
+            script=script,
+            format=format,
+            keyed=keyed,
+            **kwargs,
+        )
+
+    def result(self, search: "SearchBase[_R]", data: Any) -> AttrDict[Any]:
+        return FieldBucketData(self, search, data)
+
+
+class IPRange(Bucket[_R]):
+    """
+    A multi-bucket value source based aggregation that enables the user to
+    define a set of IP ranges - each representing a bucket.
+
+    :arg field: The date field whose values are used to build ranges.
+    :arg ranges: Array of IP ranges.
+    """
+
+    name = "ip_range"
+
+    def __init__(
+        self,
+        *,
+        field: Union[str, "InstrumentedField", "DefaultType"] = DEFAULT,
+        ranges: Union[
+            Sequence["types.IpRangeAggregationRange"],
+            Sequence[Dict[str, Any]],
+            "DefaultType",
+        ] = DEFAULT,
+        **kwargs: Any,
+    ):
+        super().__init__(field=field, ranges=ranges, **kwargs)
+
+
+class IPPrefix(Bucket[_R]):
+    """
+    A bucket aggregation that groups documents based on the network or
+    sub-network of an IP address.
+
+    :arg field: (required) The IP address field to aggregation on. The
+        field mapping type must be `ip`.
+    :arg prefix_length: (required) Length of the network prefix. For IPv4
+        addresses the accepted range is [0, 32]. For IPv6 addresses the
+        accepted range is [0, 128].
+    :arg is_ipv6: Defines whether the prefix applies to IPv6 addresses.
+    :arg append_prefix_length: Defines whether the prefix length is
+        appended to IP address keys in the response.
+    :arg keyed: Defines whether buckets are returned as a hash rather than
+        an array in the response.
+    :arg min_doc_count: Minimum number of documents in a bucket for it to
+        be included in the response. Defaults to `1` if omitted.
+    """
+
+    name = "ip_prefix"
+
+    def __init__(
+        self,
+        *,
+        field: Union[str, "InstrumentedField", "DefaultType"] = DEFAULT,
+        prefix_length: Union[int, "DefaultType"] = DEFAULT,
+        is_ipv6: Union[bool, "DefaultType"] = DEFAULT,
+        append_prefix_length: Union[bool, "DefaultType"] = DEFAULT,
+        keyed: Union[bool, "DefaultType"] = DEFAULT,
+        min_doc_count: Union[int, "DefaultType"] = DEFAULT,
+        **kwargs: Any,
+    ):
+        super().__init__(
+            field=field,
+            prefix_length=prefix_length,
+            is_ipv6=is_ipv6,
+            append_prefix_length=append_prefix_length,
+            keyed=keyed,
+            min_doc_count=min_doc_count,
+            **kwargs,
+        )
+
+
+class Inference(Pipeline[_R]):
+    """
+    A parent pipeline aggregation which loads a pre-trained model and
+    performs inference on the collated result fields from the parent
+    bucket aggregation.
+
+    :arg model_id: (required) The ID or alias for the trained model.
+    :arg inference_config: Contains the inference type and its options.
+    :arg format: `DecimalFormat` pattern for the output value. If
+        specified, the formatted value is returned in the aggregation’s
+        `value_as_string` property.
+    :arg gap_policy: Policy to apply when gaps are found in the data.
+        Defaults to `skip` if omitted.
+    :arg buckets_path: Path to the buckets that contain one set of values
+        to correlate.
+    """
+
+    name = "inference"
+
+    def __init__(
+        self,
+        *,
+        model_id: Union[str, "DefaultType"] = DEFAULT,
+        inference_config: Union[
+            "types.InferenceConfigContainer", Dict[str, Any], "DefaultType"
+        ] = DEFAULT,
+        format: Union[str, "DefaultType"] = DEFAULT,
+        gap_policy: Union[
+            Literal["skip", "insert_zeros", "keep_values"], "DefaultType"
+        ] = DEFAULT,
+        buckets_path: Union[
+            str, Sequence[str], Mapping[str, str], "DefaultType"
+        ] = DEFAULT,
+        **kwargs: Any,
+    ):
+        super().__init__(
+            model_id=model_id,
+            inference_config=inference_config,
+            format=format,
+            gap_policy=gap_policy,
+            buckets_path=buckets_path,
+            **kwargs,
+        )
+
+
+class Line(Agg[_R]):
+    """
+    :arg point: (required) The name of the geo_point field.
+    :arg sort: (required) The name of the numeric field to use as the sort
+        key for ordering the points. When the `geo_line` aggregation is
+        nested inside a `time_series` aggregation, this field defaults to
+        `@timestamp`, and any other value will result in error.
+    :arg include_sort: When `true`, returns an additional array of the
+        sort values in the feature properties.
+    :arg sort_order: The order in which the line is sorted (ascending or
+        descending). Defaults to `asc` if omitted.
+    :arg size: The maximum length of the line represented in the
+        aggregation. Valid sizes are between 1 and 10000. Defaults to
+        `10000` if omitted.
+    """
+
+    name = "line"
+
+    def __init__(
+        self,
+        *,
+        point: Union["types.GeoLinePoint", Dict[str, Any], "DefaultType"] = DEFAULT,
+        sort: Union["types.GeoLineSort", Dict[str, Any], "DefaultType"] = DEFAULT,
+        include_sort: Union[bool, "DefaultType"] = DEFAULT,
+        sort_order: Union[Literal["asc", "desc"], "DefaultType"] = DEFAULT,
+        size: Union[int, "DefaultType"] = DEFAULT,
+        **kwargs: Any,
+    ):
+        super().__init__(
+            point=point,
+            sort=sort,
+            include_sort=include_sort,
+            sort_order=sort_order,
+            size=size,
+            **kwargs,
+        )
+
+
+class MatrixStats(Agg[_R]):
+    """
+    A numeric aggregation that computes the following statistics over a
+    set of document fields: `count`, `mean`, `variance`, `skewness`,
+    `kurtosis`, `covariance`, and `covariance`.
+
+    :arg mode: Array value the aggregation will use for array or multi-
+        valued fields. Defaults to `avg` if omitted.
+    :arg fields: An array of fields for computing the statistics.
+    :arg missing: The value to apply to documents that do not have a
+        value. By default, documents without a value are ignored.
+    """
+
+    name = "matrix_stats"
+
+    def __init__(
+        self,
+        *,
+        mode: Union[
+            Literal["min", "max", "sum", "avg", "median"], "DefaultType"
+        ] = DEFAULT,
+        fields: Union[
+            Union[str, "InstrumentedField"],
+            Sequence[Union[str, "InstrumentedField"]],
+            "DefaultType",
+        ] = DEFAULT,
+        missing: Union[
+            Mapping[Union[str, "InstrumentedField"], float], "DefaultType"
+        ] = DEFAULT,
+        **kwargs: Any,
+    ):
+        super().__init__(mode=mode, fields=fields, missing=missing, **kwargs)
+
+
+class Max(Agg[_R]):
+    """
+    A single-value metrics aggregation that returns the maximum value
+    among the numeric values extracted from the aggregated documents.
+
+    :arg format:
+    :arg field: The field on which to run the aggregation.
+    :arg missing: The value to apply to documents that do not have a
+        value. By default, documents without a value are ignored.
+    :arg script:
+    """
+
+    name = "max"
+
+    def __init__(
+        self,
+        *,
+        format: Union[str, "DefaultType"] = DEFAULT,
+        field: Union[str, "InstrumentedField", "DefaultType"] = DEFAULT,
+        missing: Union[str, int, float, bool, "DefaultType"] = DEFAULT,
+        script: Union["types.Script", Dict[str, Any], "DefaultType"] = DEFAULT,
+        **kwargs: Any,
+    ):
+        super().__init__(
+            format=format, field=field, missing=missing, script=script, **kwargs
+        )
+
+
+class MaxBucket(Pipeline[_R]):
+    """
+    A sibling pipeline aggregation which identifies the bucket(s) with the
+    maximum value of a specified metric in a sibling aggregation and
+    outputs both the value and the key(s) of the bucket(s).
+
+    :arg format: `DecimalFormat` pattern for the output value. If
+        specified, the formatted value is returned in the aggregation’s
+        `value_as_string` property.
+    :arg gap_policy: Policy to apply when gaps are found in the data.
+        Defaults to `skip` if omitted.
+    :arg buckets_path: Path to the buckets that contain one set of values
+        to correlate.
+    """
+
+    name = "max_bucket"
+
+    def __init__(
+        self,
+        *,
+        format: Union[str, "DefaultType"] = DEFAULT,
+        gap_policy: Union[
+            Literal["skip", "insert_zeros", "keep_values"], "DefaultType"
+        ] = DEFAULT,
+        buckets_path: Union[
+            str, Sequence[str], Mapping[str, str], "DefaultType"
+        ] = DEFAULT,
+        **kwargs: Any,
+    ):
+        super().__init__(
+            format=format, gap_policy=gap_policy, buckets_path=buckets_path, **kwargs
+        )
+
+
+class MedianAbsoluteDeviation(Agg[_R]):
+    """
+    A single-value aggregation that approximates the median absolute
+    deviation of its search results.
+
+    :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. Defaults to
+        `1000` if omitted.
+    :arg format:
+    :arg field: The field on which to run the aggregation.
+    :arg missing: The value to apply to documents that do not have a
+        value. By default, documents without a value are ignored.
+    :arg script:
+    """
+
+    name = "median_absolute_deviation"
+
+    def __init__(
+        self,
+        *,
+        compression: Union[float, "DefaultType"] = DEFAULT,
+        format: Union[str, "DefaultType"] = DEFAULT,
+        field: Union[str, "InstrumentedField", "DefaultType"] = DEFAULT,
+        missing: Union[str, int, float, bool, "DefaultType"] = DEFAULT,
+        script: Union["types.Script", Dict[str, Any], "DefaultType"] = DEFAULT,
+        **kwargs: Any,
+    ):
+        super().__init__(
+            compression=compression,
+            format=format,
+            field=field,
+            missing=missing,
+            script=script,
+            **kwargs,
+        )
+
+
+class Min(Agg[_R]):
+    """
+    A single-value metrics aggregation that returns the minimum value
+    among numeric values extracted from the aggregated documents.
+
+    :arg format:
+    :arg field: The field on which to run the aggregation.
+    :arg missing: The value to apply to documents that do not have a
+        value. By default, documents without a value are ignored.
+    :arg script:
+    """
+
+    name = "min"
+
+    def __init__(
+        self,
+        *,
+        format: Union[str, "DefaultType"] = DEFAULT,
+        field: Union[str, "InstrumentedField", "DefaultType"] = DEFAULT,
+        missing: Union[str, int, float, bool, "DefaultType"] = DEFAULT,
+        script: Union["types.Script", Dict[str, Any], "DefaultType"] = DEFAULT,
+        **kwargs: Any,
+    ):
+        super().__init__(
+            format=format, field=field, missing=missing, script=script, **kwargs
+        )
+
+
+class MinBucket(Pipeline[_R]):
+    """
+    A sibling pipeline aggregation which identifies the bucket(s) with the
+    minimum value of a specified metric in a sibling aggregation and
+    outputs both the value and the key(s) of the bucket(s).
+
+    :arg format: `DecimalFormat` pattern for the output value. If
+        specified, the formatted value is returned in the aggregation’s
+        `value_as_string` property.
+    :arg gap_policy: Policy to apply when gaps are found in the data.
+        Defaults to `skip` if omitted.
+    :arg buckets_path: Path to the buckets that contain one set of values
+        to correlate.
+    """
+
+    name = "min_bucket"
+
+    def __init__(
+        self,
+        *,
+        format: Union[str, "DefaultType"] = DEFAULT,
+        gap_policy: Union[
+            Literal["skip", "insert_zeros", "keep_values"], "DefaultType"
+        ] = DEFAULT,
+        buckets_path: Union[
+            str, Sequence[str], Mapping[str, str], "DefaultType"
+        ] = DEFAULT,
+        **kwargs: Any,
+    ):
+        super().__init__(
+            format=format, gap_policy=gap_policy, buckets_path=buckets_path, **kwargs
+        )
+
+
+class Missing(Bucket[_R]):
+    """
+    A field data based single bucket aggregation, that creates a bucket of
+    all documents in the current document set context that are missing a
+    field value (effectively, missing a field or having the configured
+    NULL value set).
+
+    :arg field: The name of the field.
+    :arg missing:
+    """
+
+    name = "missing"
+
+    def __init__(
+        self,
+        *,
+        field: Union[str, "InstrumentedField", "DefaultType"] = DEFAULT,
+        missing: Union[str, int, float, bool, "DefaultType"] = DEFAULT,
+        **kwargs: Any,
+    ):
+        super().__init__(field=field, missing=missing, **kwargs)
+
+
+class MovingAvg(Pipeline[_R]):
+    """ """
+
+    name = "moving_avg"
+
+    def __init__(self, **kwargs: Any):
+        super().__init__(**kwargs)
+
+
+class LinearMovingAverageAggregation(MovingAvg[_R]):
+    """
+    :arg model: (required)
+    :arg settings: (required)
+    :arg minimize:
+    :arg predict:
+    :arg window:
+    :arg format: `DecimalFormat` pattern for the output value. If
+        specified, the formatted value is returned in the aggregation’s
+        `value_as_string` property.
+    :arg gap_policy: Policy to apply when gaps are found in the data.
+        Defaults to `skip` if omitted.
+    :arg buckets_path: Path to the buckets that contain one set of values
+        to correlate.
+    """
+
+    def __init__(
+        self,
+        *,
+        model: Any = DEFAULT,
+        settings: Union["types.EmptyObject", Dict[str, Any], "DefaultType"] = DEFAULT,
+        minimize: Union[bool, "DefaultType"] = DEFAULT,
+        predict: Union[int, "DefaultType"] = DEFAULT,
+        window: Union[int, "DefaultType"] = DEFAULT,
+        format: Union[str, "DefaultType"] = DEFAULT,
+        gap_policy: Union[
+            Literal["skip", "insert_zeros", "keep_values"], "DefaultType"
+        ] = DEFAULT,
+        buckets_path: Union[
+            str, Sequence[str], Mapping[str, str], "DefaultType"
+        ] = DEFAULT,
+        **kwargs: Any,
+    ):
+        super().__init__(
+            model=model,
+            settings=settings,
+            minimize=minimize,
+            predict=predict,
+            window=window,
+            format=format,
+            gap_policy=gap_policy,
+            buckets_path=buckets_path,
+            **kwargs,
+        )
+
+
+class SimpleMovingAverageAggregation(MovingAvg[_R]):
+    """
+    :arg model: (required)
+    :arg settings: (required)
+    :arg minimize:
+    :arg predict:
+    :arg window:
+    :arg format: `DecimalFormat` pattern for the output value. If
+        specified, the formatted value is returned in the aggregation’s
+        `value_as_string` property.
+    :arg gap_policy: Policy to apply when gaps are found in the data.
+        Defaults to `skip` if omitted.
+    :arg buckets_path: Path to the buckets that contain one set of values
+        to correlate.
+    """
+
+    def __init__(
+        self,
+        *,
+        model: Any = DEFAULT,
+        settings: Union["types.EmptyObject", Dict[str, Any], "DefaultType"] = DEFAULT,
+        minimize: Union[bool, "DefaultType"] = DEFAULT,
+        predict: Union[int, "DefaultType"] = DEFAULT,
+        window: Union[int, "DefaultType"] = DEFAULT,
+        format: Union[str, "DefaultType"] = DEFAULT,
+        gap_policy: Union[
+            Literal["skip", "insert_zeros", "keep_values"], "DefaultType"
+        ] = DEFAULT,
+        buckets_path: Union[
+            str, Sequence[str], Mapping[str, str], "DefaultType"
+        ] = DEFAULT,
+        **kwargs: Any,
+    ):
+        super().__init__(
+            model=model,
+            settings=settings,
+            minimize=minimize,
+            predict=predict,
+            window=window,
+            format=format,
+            gap_policy=gap_policy,
+            buckets_path=buckets_path,
+            **kwargs,
+        )
+
+
+class EwmaMovingAverageAggregation(MovingAvg[_R]):
+    """
+    :arg model: (required)
+    :arg settings: (required)
+    :arg minimize:
+    :arg predict:
+    :arg window:
+    :arg format: `DecimalFormat` pattern for the output value. If
+        specified, the formatted value is returned in the aggregation’s
+        `value_as_string` property.
+    :arg gap_policy: Policy to apply when gaps are found in the data.
+        Defaults to `skip` if omitted.
+    :arg buckets_path: Path to the buckets that contain one set of values
+        to correlate.
+    """
+
+    def __init__(
+        self,
+        *,
+        model: Any = DEFAULT,
+        settings: Union[
+            "types.EwmaModelSettings", Dict[str, Any], "DefaultType"
+        ] = DEFAULT,
+        minimize: Union[bool, "DefaultType"] = DEFAULT,
+        predict: Union[int, "DefaultType"] = DEFAULT,
+        window: Union[int, "DefaultType"] = DEFAULT,
+        format: Union[str, "DefaultType"] = DEFAULT,
+        gap_policy: Union[
+            Literal["skip", "insert_zeros", "keep_values"], "DefaultType"
+        ] = DEFAULT,
+        buckets_path: Union[
+            str, Sequence[str], Mapping[str, str], "DefaultType"
+        ] = DEFAULT,
+        **kwargs: Any,
+    ):
+        super().__init__(
+            model=model,
+            settings=settings,
+            minimize=minimize,
+            predict=predict,
+            window=window,
+            format=format,
+            gap_policy=gap_policy,
+            buckets_path=buckets_path,
+            **kwargs,
+        )
+
+
+class HoltMovingAverageAggregation(MovingAvg[_R]):
+    """
+    :arg model: (required)
+    :arg settings: (required)
+    :arg minimize:
+    :arg predict:
+    :arg window:
+    :arg format: `DecimalFormat` pattern for the output value. If
+        specified, the formatted value is returned in the aggregation’s
+        `value_as_string` property.
+    :arg gap_policy: Policy to apply when gaps are found in the data.
+        Defaults to `skip` if omitted.
+    :arg buckets_path: Path to the buckets that contain one set of values
+        to correlate.
+    """
+
+    def __init__(
+        self,
+        *,
+        model: Any = DEFAULT,
+        settings: Union[
+            "types.HoltLinearModelSettings", Dict[str, Any], "DefaultType"
+        ] = DEFAULT,
+        minimize: Union[bool, "DefaultType"] = DEFAULT,
+        predict: Union[int, "DefaultType"] = DEFAULT,
+        window: Union[int, "DefaultType"] = DEFAULT,
+        format: Union[str, "DefaultType"] = DEFAULT,
+        gap_policy: Union[
+            Literal["skip", "insert_zeros", "keep_values"], "DefaultType"
+        ] = DEFAULT,
+        buckets_path: Union[
+            str, Sequence[str], Mapping[str, str], "DefaultType"
+        ] = DEFAULT,
+        **kwargs: Any,
+    ):
+        super().__init__(
+            model=model,
+            settings=settings,
+            minimize=minimize,
+            predict=predict,
+            window=window,
+            format=format,
+            gap_policy=gap_policy,
+            buckets_path=buckets_path,
+            **kwargs,
+        )
+
+
+class HoltWintersMovingAverageAggregation(MovingAvg[_R]):
+    """
+    :arg model: (required)
+    :arg settings: (required)
+    :arg minimize:
+    :arg predict:
+    :arg window:
+    :arg format: `DecimalFormat` pattern for the output value. If
+        specified, the formatted value is returned in the aggregation’s
+        `value_as_string` property.
+    :arg gap_policy: Policy to apply when gaps are found in the data.
+        Defaults to `skip` if omitted.
+    :arg buckets_path: Path to the buckets that contain one set of values
+        to correlate.
+    """
+
+    def __init__(
+        self,
+        *,
+        model: Any = DEFAULT,
+        settings: Union[
+            "types.HoltWintersModelSettings", Dict[str, Any], "DefaultType"
+        ] = DEFAULT,
+        minimize: Union[bool, "DefaultType"] = DEFAULT,
+        predict: Union[int, "DefaultType"] = DEFAULT,
+        window: Union[int, "DefaultType"] = DEFAULT,
+        format: Union[str, "DefaultType"] = DEFAULT,
+        gap_policy: Union[
+            Literal["skip", "insert_zeros", "keep_values"], "DefaultType"
+        ] = DEFAULT,
+        buckets_path: Union[
+            str, Sequence[str], Mapping[str, str], "DefaultType"
+        ] = DEFAULT,
+        **kwargs: Any,
+    ):
+        super().__init__(
+            model=model,
+            settings=settings,
+            minimize=minimize,
+            predict=predict,
+            window=window,
+            format=format,
+            gap_policy=gap_policy,
+            buckets_path=buckets_path,
+            **kwargs,
+        )
+
+
+class MovingPercentiles(Pipeline[_R]):
+    """
+    Given an ordered series of percentiles, "slides" a window across those
+    percentiles and computes cumulative percentiles.
+
+    :arg window: The size of window to "slide" across the histogram.
+    :arg shift: By default, the window consists of the last n values
+        excluding the current bucket. Increasing `shift` by 1, moves the
+        starting window position by 1 to the right.
+    :arg keyed:
+    :arg format: `DecimalFormat` pattern for the output value. If
+        specified, the formatted value is returned in the aggregation’s
+        `value_as_string` property.
+    :arg gap_policy: Policy to apply when gaps are found in the data.
+        Defaults to `skip` if omitted.
+    :arg buckets_path: Path to the buckets that contain one set of values
+        to correlate.
+    """
+
+    name = "moving_percentiles"
+
+    def __init__(
+        self,
+        *,
+        window: Union[int, "DefaultType"] = DEFAULT,
+        shift: Union[int, "DefaultType"] = DEFAULT,
+        keyed: Union[bool, "DefaultType"] = DEFAULT,
+        format: Union[str, "DefaultType"] = DEFAULT,
+        gap_policy: Union[
+            Literal["skip", "insert_zeros", "keep_values"], "DefaultType"
+        ] = DEFAULT,
+        buckets_path: Union[
+            str, Sequence[str], Mapping[str, str], "DefaultType"
+        ] = DEFAULT,
+        **kwargs: Any,
+    ):
+        super().__init__(
+            window=window,
+            shift=shift,
+            keyed=keyed,
+            format=format,
+            gap_policy=gap_policy,
+            buckets_path=buckets_path,
+            **kwargs,
+        )
+
+
+class MovingFn(Pipeline[_R]):
+    """
+    Given an ordered series of data, "slides" a window across the data and
+    runs a custom script on each window of data. For convenience, a number
+    of common functions are predefined such as `min`, `max`, and moving
+    averages.
+
+    :arg script: The script that should be executed on each window of
+        data.
+    :arg shift: By default, the window consists of the last n values
+        excluding the current bucket. Increasing `shift` by 1, moves the
+        starting window position by 1 to the right.
+    :arg window: The size of window to "slide" across the histogram.
+    :arg format: `DecimalFormat` pattern for the output value. If
+        specified, the formatted value is returned in the aggregation’s
+        `value_as_string` property.
+    :arg gap_policy: Policy to apply when gaps are found in the data.
+        Defaults to `skip` if omitted.
+    :arg buckets_path: Path to the buckets that contain one set of values
+        to correlate.
+    """
+
+    name = "moving_fn"
+
+    def __init__(
+        self,
+        *,
+        script: Union[str, "DefaultType"] = DEFAULT,
+        shift: Union[int, "DefaultType"] = DEFAULT,
+        window: Union[int, "DefaultType"] = DEFAULT,
+        format: Union[str, "DefaultType"] = DEFAULT,
+        gap_policy: Union[
+            Literal["skip", "insert_zeros", "keep_values"], "DefaultType"
+        ] = DEFAULT,
+        buckets_path: Union[
+            str, Sequence[str], Mapping[str, str], "DefaultType"
+        ] = DEFAULT,
+        **kwargs: Any,
+    ):
+        super().__init__(
+            script=script,
+            shift=shift,
+            window=window,
+            format=format,
+            gap_policy=gap_policy,
+            buckets_path=buckets_path,
+            **kwargs,
+        )
+
+
+class MultiTerms(Bucket[_R]):
+    """
+    A multi-bucket value source based aggregation where buckets are
+    dynamically built - one per unique set of values.
+
+    :arg terms: (required) The field from which to generate sets of terms.
+    :arg collect_mode: Specifies the strategy for data collection.
+        Defaults to `breadth_first` if omitted.
+    :arg order: Specifies the sort order of the buckets. Defaults to
+        sorting by descending document count.
+    :arg min_doc_count: The minimum number of documents in a bucket for it
+        to be returned. Defaults to `1` if omitted.
+    :arg shard_min_doc_count: The minimum number of documents in a bucket
+        on each shard for it to be returned. Defaults to `1` if omitted.
+    :arg shard_size: The number of candidate terms produced by each shard.
+        By default, `shard_size` will be automatically estimated based on
+        the number of shards and the `size` parameter.
+    :arg show_term_doc_count_error: Calculates the doc count error on per
+        term basis.
+    :arg size: The number of term buckets should be returned out of the
+        overall terms list. Defaults to `10` if omitted.
+    """
+
+    name = "multi_terms"
+
+    def __init__(
+        self,
+        *,
+        terms: Union[
+            Sequence["types.MultiTermLookup"], Sequence[Dict[str, Any]], "DefaultType"
+        ] = DEFAULT,
+        collect_mode: Union[
+            Literal["depth_first", "breadth_first"], "DefaultType"
+        ] = DEFAULT,
+        order: Union[
+            Mapping[Union[str, "InstrumentedField"], Literal["asc", "desc"]],
+            Sequence[Mapping[Union[str, "InstrumentedField"], Literal["asc", "desc"]]],
+            "DefaultType",
+        ] = DEFAULT,
+        min_doc_count: Union[int, "DefaultType"] = DEFAULT,
+        shard_min_doc_count: Union[int, "DefaultType"] = DEFAULT,
+        shard_size: Union[int, "DefaultType"] = DEFAULT,
+        show_term_doc_count_error: Union[bool, "DefaultType"] = DEFAULT,
+        size: Union[int, "DefaultType"] = DEFAULT,
+        **kwargs: Any,
+    ):
+        super().__init__(
+            terms=terms,
+            collect_mode=collect_mode,
+            order=order,
+            min_doc_count=min_doc_count,
+            shard_min_doc_count=shard_min_doc_count,
+            shard_size=shard_size,
+            show_term_doc_count_error=show_term_doc_count_error,
+            size=size,
+            **kwargs,
+        )
+
+
+class Nested(Bucket[_R]):
+    """
+    A special single bucket aggregation that enables aggregating nested
+    documents.
+
+    :arg path: The path to the field of type `nested`.
+    """
+
+    name = "nested"
+
+    def __init__(
+        self,
+        path: Union[str, "InstrumentedField", "DefaultType"] = DEFAULT,
+        **kwargs: Any,
+    ):
+        super().__init__(path=path, **kwargs)
+
+
+class Normalize(Pipeline[_R]):
+    """
+    A parent pipeline aggregation which calculates the specific
+    normalized/rescaled value for a specific bucket value.
+
+    :arg method: The specific method to apply.
+    :arg format: `DecimalFormat` pattern for the output value. If
+        specified, the formatted value is returned in the aggregation’s
+        `value_as_string` property.
+    :arg gap_policy: Policy to apply when gaps are found in the data.
+        Defaults to `skip` if omitted.
+    :arg buckets_path: Path to the buckets that contain one set of values
+        to correlate.
+    """
+
+    name = "normalize"
+
+    def __init__(
+        self,
+        *,
+        method: Union[
+            Literal[
+                "rescale_0_1",
+                "rescale_0_100",
+                "percent_of_sum",
+                "mean",
+                "z-score",
+                "softmax",
+            ],
+            "DefaultType",
+        ] = DEFAULT,
+        format: Union[str, "DefaultType"] = DEFAULT,
+        gap_policy: Union[
+            Literal["skip", "insert_zeros", "keep_values"], "DefaultType"
+        ] = DEFAULT,
+        buckets_path: Union[
+            str, Sequence[str], Mapping[str, str], "DefaultType"
+        ] = DEFAULT,
+        **kwargs: Any,
+    ):
+        super().__init__(
+            method=method,
+            format=format,
+            gap_policy=gap_policy,
+            buckets_path=buckets_path,
+            **kwargs,
+        )
+
+
+class Parent(Bucket[_R]):
+    """
+    A special single bucket aggregation that selects parent documents that
+    have the specified type, as defined in a `join` field.
+
+    :arg type: The child type that should be selected.
+    """
+
+    name = "parent"
+
+    def __init__(self, type: Union[str, "DefaultType"] = DEFAULT, **kwargs: Any):
+        super().__init__(type=type, **kwargs)
+
+
+class PercentileRanks(Agg[_R]):
+    """
+    A multi-value metrics aggregation that calculates one or more
+    percentile ranks over numeric values extracted from the aggregated
+    documents.
+
+    :arg keyed: By default, the aggregation associates a unique string key
+        with each bucket and returns the ranges as a hash rather than an
+        array. Set to `false` to disable this behavior. Defaults to `True`
+        if omitted.
+    :arg values: An array of values for which to calculate the percentile
+        ranks.
+    :arg hdr: Uses the alternative High Dynamic Range Histogram algorithm
+        to calculate percentile ranks.
+    :arg tdigest: Sets parameters for the default TDigest algorithm used
+        to calculate percentile ranks.
+    :arg format:
+    :arg field: The field on which to run the aggregation.
+    :arg missing: The value to apply to documents that do not have a
+        value. By default, documents without a value are ignored.
+    :arg script:
+    """
+
+    name = "percentile_ranks"
+
+    def __init__(
+        self,
+        *,
+        keyed: Union[bool, "DefaultType"] = DEFAULT,
+        values: Union[Sequence[float], None, "DefaultType"] = DEFAULT,
+        hdr: Union["types.HdrMethod", Dict[str, Any], "DefaultType"] = DEFAULT,
+        tdigest: Union["types.TDigest", Dict[str, Any], "DefaultType"] = DEFAULT,
+        format: Union[str, "DefaultType"] = DEFAULT,
+        field: Union[str, "InstrumentedField", "DefaultType"] = DEFAULT,
+        missing: Union[str, int, float, bool, "DefaultType"] = DEFAULT,
+        script: Union["types.Script", Dict[str, Any], "DefaultType"] = DEFAULT,
+        **kwargs: Any,
+    ):
+        super().__init__(
+            keyed=keyed,
+            values=values,
+            hdr=hdr,
+            tdigest=tdigest,
+            format=format,
+            field=field,
+            missing=missing,
+            script=script,
+            **kwargs,
+        )
+
+
+class Percentiles(Agg[_R]):
+    """
+    A multi-value metrics aggregation that calculates one or more
+    percentiles over numeric values extracted from the aggregated
+    documents.
+
+    :arg keyed: By default, the aggregation associates a unique string key
+        with each bucket and returns the ranges as a hash rather than an
+        array. Set to `false` to disable this behavior. Defaults to `True`
+        if omitted.
+    :arg percents: The percentiles to calculate.
+    :arg hdr: Uses the alternative High Dynamic Range Histogram algorithm
+        to calculate percentiles.
+    :arg tdigest: Sets parameters for the default TDigest algorithm used
+        to calculate percentiles.
+    :arg format:
+    :arg field: The field on which to run the aggregation.
+    :arg missing: The value to apply to documents that do not have a
+        value. By default, documents without a value are ignored.
+    :arg script:
+    """
+
+    name = "percentiles"
+
+    def __init__(
+        self,
+        *,
+        keyed: Union[bool, "DefaultType"] = DEFAULT,
+        percents: Union[Sequence[float], "DefaultType"] = DEFAULT,
+        hdr: Union["types.HdrMethod", Dict[str, Any], "DefaultType"] = DEFAULT,
+        tdigest: Union["types.TDigest", Dict[str, Any], "DefaultType"] = DEFAULT,
+        format: Union[str, "DefaultType"] = DEFAULT,
+        field: Union[str, "InstrumentedField", "DefaultType"] = DEFAULT,
+        missing: Union[str, int, float, bool, "DefaultType"] = DEFAULT,
+        script: Union["types.Script", Dict[str, Any], "DefaultType"] = DEFAULT,
+        **kwargs: Any,
+    ):
+        super().__init__(
+            keyed=keyed,
+            percents=percents,
+            hdr=hdr,
+            tdigest=tdigest,
+            format=format,
+            field=field,
+            missing=missing,
+            script=script,
+            **kwargs,
+        )
+
+
+class PercentilesBucket(Pipeline[_R]):
+    """
+    A sibling pipeline aggregation which calculates percentiles across all
+    bucket of a specified metric in a sibling aggregation.
+
+    :arg percents: The list of percentiles to calculate.
+    :arg format: `DecimalFormat` pattern for the output value. If
+        specified, the formatted value is returned in the aggregation’s
+        `value_as_string` property.
+    :arg gap_policy: Policy to apply when gaps are found in the data.
+        Defaults to `skip` if omitted.
+    :arg buckets_path: Path to the buckets that contain one set of values
+        to correlate.
+    """
+
+    name = "percentiles_bucket"
+
+    def __init__(
+        self,
+        *,
+        percents: Union[Sequence[float], "DefaultType"] = DEFAULT,
+        format: Union[str, "DefaultType"] = DEFAULT,
+        gap_policy: Union[
+            Literal["skip", "insert_zeros", "keep_values"], "DefaultType"
+        ] = DEFAULT,
+        buckets_path: Union[
+            str, Sequence[str], Mapping[str, str], "DefaultType"
+        ] = DEFAULT,
+        **kwargs: Any,
+    ):
+        super().__init__(
+            percents=percents,
+            format=format,
+            gap_policy=gap_policy,
+            buckets_path=buckets_path,
+            **kwargs,
+        )
+
+
+class Range(Bucket[_R]):
+    """
+    A multi-bucket value source based aggregation that enables the user to
+    define a set of ranges - each representing a bucket.
+
+    :arg field: The date field whose values are use to build ranges.
+    :arg missing: The value to apply to documents that do not have a
+        value. By default, documents without a value are ignored.
+    :arg ranges: An array of ranges used to bucket documents.
+    :arg script:
+    :arg keyed: Set to `true` to associate a unique string key with each
+        bucket and return the ranges as a hash rather than an array.
+    :arg format:
+    """
+
+    name = "range"
+
+    def __init__(
+        self,
+        *,
+        field: Union[str, "InstrumentedField", "DefaultType"] = DEFAULT,
+        missing: Union[int, "DefaultType"] = DEFAULT,
+        ranges: Union[
+            Sequence["wrappers.AggregationRange"],
+            Sequence[Dict[str, Any]],
+            "DefaultType",
+        ] = DEFAULT,
+        script: Union["types.Script", Dict[str, Any], "DefaultType"] = DEFAULT,
+        keyed: Union[bool, "DefaultType"] = DEFAULT,
+        format: Union[str, "DefaultType"] = DEFAULT,
+        **kwargs: Any,
+    ):
+        super().__init__(
+            field=field,
+            missing=missing,
+            ranges=ranges,
+            script=script,
+            keyed=keyed,
+            format=format,
+            **kwargs,
+        )
+
+
+class RareTerms(Bucket[_R]):
+    """
+    A multi-bucket value source based aggregation which finds "rare"
+    terms — terms that are at the long-tail of the distribution and are
+    not frequent.
+
+    :arg exclude: Terms that should be excluded from the aggregation.
+    :arg field: The field from which to return rare terms.
+    :arg include: Terms that should be included in the aggregation.
+    :arg max_doc_count: The maximum number of documents a term should
+        appear in. Defaults to `1` if omitted.
+    :arg missing: The value to apply to documents that do not have a
+        value. By default, documents without a value are ignored.
+    :arg precision: The precision of the internal CuckooFilters. Smaller
+        precision leads to better approximation, but higher memory usage.
+        Defaults to `0.001` if omitted.
+    :arg value_type:
+    """
+
+    name = "rare_terms"
+
+    def __init__(
+        self,
+        *,
+        exclude: Union[str, Sequence[str], "DefaultType"] = DEFAULT,
+        field: Union[str, "InstrumentedField", "DefaultType"] = DEFAULT,
+        include: Union[
+            str, Sequence[str], "types.TermsPartition", Dict[str, Any], "DefaultType"
+        ] = DEFAULT,
+        max_doc_count: Union[int, "DefaultType"] = DEFAULT,
+        missing: Union[str, int, float, bool, "DefaultType"] = DEFAULT,
+        precision: Union[float, "DefaultType"] = DEFAULT,
+        value_type: Union[str, "DefaultType"] = DEFAULT,
+        **kwargs: Any,
+    ):
+        super().__init__(
+            exclude=exclude,
+            field=field,
+            include=include,
+            max_doc_count=max_doc_count,
+            missing=missing,
+            precision=precision,
+            value_type=value_type,
+            **kwargs,
+        )
+
+
+class Rate(Agg[_R]):
+    """
+    Calculates a rate of documents or a field in each bucket. Can only be
+    used inside a `date_histogram` or `composite` aggregation.
+
+    :arg unit: The interval used to calculate the rate. By default, the
+        interval of the `date_histogram` is used.
+    :arg mode: How the rate is calculated. Defaults to `sum` if omitted.
+    :arg format:
+    :arg field: The field on which to run the aggregation.
+    :arg missing: The value to apply to documents that do not have a
+        value. By default, documents without a value are ignored.
+    :arg script:
+    """
+
+    name = "rate"
+
+    def __init__(
+        self,
+        *,
+        unit: Union[
+            Literal[
+                "second", "minute", "hour", "day", "week", "month", "quarter", "year"
+            ],
+            "DefaultType",
+        ] = DEFAULT,
+        mode: Union[Literal["sum", "value_count"], "DefaultType"] = DEFAULT,
+        format: Union[str, "DefaultType"] = DEFAULT,
+        field: Union[str, "InstrumentedField", "DefaultType"] = DEFAULT,
+        missing: Union[str, int, float, bool, "DefaultType"] = DEFAULT,
+        script: Union["types.Script", Dict[str, Any], "DefaultType"] = DEFAULT,
+        **kwargs: Any,
+    ):
+        super().__init__(
+            unit=unit,
+            mode=mode,
+            format=format,
+            field=field,
+            missing=missing,
+            script=script,
+            **kwargs,
+        )
+
+
+class ReverseNested(Bucket[_R]):
+    """
+    A special single bucket aggregation that enables aggregating on parent
+    documents from nested documents. Should only be defined inside a
+    `nested` aggregation.
+
+    :arg path: Defines the nested object field that should be joined back
+        to. The default is empty, which means that it joins back to the
+        root/main document level.
+    """
+
+    name = "reverse_nested"
+
+    def __init__(
+        self,
+        path: Union[str, "InstrumentedField", "DefaultType"] = DEFAULT,
+        **kwargs: Any,
+    ):
+        super().__init__(path=path, **kwargs)
+
+
+class RandomSampler(Bucket[_R]):
+    """
+    A single bucket aggregation that randomly includes documents in the
+    aggregated results. Sampling provides significant speed improvement at
+    the cost of accuracy.
+
+    :arg probability: (required) The probability that a document will be
+        included in the aggregated data. Must be greater than 0, less than
+        0.5, or exactly 1. The lower the probability, the fewer documents
+        are matched.
+    :arg seed: The seed to generate the random sampling of documents. When
+        a seed is provided, the random subset of documents is the same
+        between calls.
+    :arg shard_seed: When combined with seed, setting shard_seed ensures
+        100% consistent sampling over shards where data is exactly the
+        same.
+    """
+
+    name = "random_sampler"
+
+    def __init__(
+        self,
+        *,
+        probability: Union[float, "DefaultType"] = DEFAULT,
+        seed: Union[int, "DefaultType"] = DEFAULT,
+        shard_seed: Union[int, "DefaultType"] = DEFAULT,
+        **kwargs: Any,
+    ):
+        super().__init__(
+            probability=probability, seed=seed, shard_seed=shard_seed, **kwargs
+        )
+
+
+class Sampler(Bucket[_R]):
+    """
+    A filtering aggregation used to limit any sub aggregations' processing
+    to a sample of the top-scoring documents.
+
+    :arg shard_size: Limits how many top-scoring documents are collected
+        in the sample processed on each shard. Defaults to `100` if
+        omitted.
+    """
+
+    name = "sampler"
+
+    def __init__(self, shard_size: Union[int, "DefaultType"] = DEFAULT, **kwargs: Any):
+        super().__init__(shard_size=shard_size, **kwargs)
+
+
+class ScriptedMetric(Agg[_R]):
+    """
+    A metric aggregation that uses scripts to provide a metric output.
+
+    :arg combine_script: Runs once on each shard after document collection
+        is complete. Allows the aggregation to consolidate the state
+        returned from each shard.
+    :arg init_script: Runs prior to any collection of documents. Allows
+        the aggregation to set up any initial state.
+    :arg map_script: Run once per document collected. If no
+        `combine_script` is specified, the resulting state needs to be
+        stored in the `state` object.
+    :arg params: A global object with script parameters for `init`, `map`
+        and `combine` scripts. It is shared between the scripts.
+    :arg reduce_script: Runs once on the coordinating node after all
+        shards have returned their results. The script is provided with
+        access to a variable `states`, which is an array of the result of
+        the `combine_script` on each shard.
+    :arg field: The field on which to run the aggregation.
+    :arg missing: The value to apply to documents that do not have a
+        value. By default, documents without a value are ignored.
+    :arg script:
+    """
+
+    name = "scripted_metric"
+
+    def __init__(
+        self,
+        *,
+        combine_script: Union["types.Script", Dict[str, Any], "DefaultType"] = DEFAULT,
+        init_script: Union["types.Script", Dict[str, Any], "DefaultType"] = DEFAULT,
+        map_script: Union["types.Script", Dict[str, Any], "DefaultType"] = DEFAULT,
+        params: Union[Mapping[str, Any], "DefaultType"] = DEFAULT,
+        reduce_script: Union["types.Script", Dict[str, Any], "DefaultType"] = DEFAULT,
+        field: Union[str, "InstrumentedField", "DefaultType"] = DEFAULT,
+        missing: Union[str, int, float, bool, "DefaultType"] = DEFAULT,
+        script: Union["types.Script", Dict[str, Any], "DefaultType"] = DEFAULT,
+        **kwargs: Any,
+    ):
+        super().__init__(
+            combine_script=combine_script,
+            init_script=init_script,
+            map_script=map_script,
+            params=params,
+            reduce_script=reduce_script,
+            field=field,
+            missing=missing,
+            script=script,
+            **kwargs,
+        )
+
+
+class SerialDiff(Pipeline[_R]):
+    """
+    An aggregation that subtracts values in a time series from themselves
+    at different time lags or periods.
+
+    :arg lag: The historical bucket to subtract from the current value.
+        Must be a positive, non-zero integer.
+    :arg format: `DecimalFormat` pattern for the output value. If
+        specified, the formatted value is returned in the aggregation’s
+        `value_as_string` property.
+    :arg gap_policy: Policy to apply when gaps are found in the data.
+        Defaults to `skip` if omitted.
+    :arg buckets_path: Path to the buckets that contain one set of values
+        to correlate.
+    """
+
+    name = "serial_diff"
+
+    def __init__(
+        self,
+        *,
+        lag: Union[int, "DefaultType"] = DEFAULT,
+        format: Union[str, "DefaultType"] = DEFAULT,
+        gap_policy: Union[
+            Literal["skip", "insert_zeros", "keep_values"], "DefaultType"
+        ] = DEFAULT,
+        buckets_path: Union[
+            str, Sequence[str], Mapping[str, str], "DefaultType"
+        ] = DEFAULT,
+        **kwargs: Any,
+    ):
+        super().__init__(
+            lag=lag,
+            format=format,
+            gap_policy=gap_policy,
+            buckets_path=buckets_path,
+            **kwargs,
+        )
+
+
+class SignificantTerms(Bucket[_R]):
+    """
+    Returns interesting or unusual occurrences of terms in a set.
+
+    :arg background_filter: A background filter that can be used to focus
+        in on significant terms within a narrower context, instead of the
+        entire index.
+    :arg chi_square: Use Chi square, as described in "Information
+        Retrieval", Manning et al., Chapter 13.5.2, as the significance
+        score.
+    :arg exclude: Terms to exclude.
+    :arg execution_hint: Mechanism by which the aggregation should be
+        executed: using field values directly or using global ordinals.
+    :arg field: The field from which to return significant terms.
+    :arg gnd: Use Google normalized distance as described in "The Google
+        Similarity Distance", Cilibrasi and Vitanyi, 2007, as the
+        significance score.
+    :arg include: Terms to include.
+    :arg jlh: Use JLH score as the significance score.
+    :arg min_doc_count: Only return terms that are found in more than
+        `min_doc_count` hits. Defaults to `3` if omitted.
+    :arg mutual_information: Use mutual information as described in
+        "Information Retrieval", Manning et al., Chapter 13.5.1, as the
+        significance score.
+    :arg percentage: A simple calculation of the number of documents in
+        the foreground sample with a term divided by the number of
+        documents in the background with the term.
+    :arg script_heuristic: Customized score, implemented via a script.
+    :arg shard_min_doc_count: Regulates the certainty a shard has if the
+        term should actually be added to the candidate list or not with
+        respect to the `min_doc_count`. Terms will only be considered if
+        their local shard frequency within the set is higher than the
+        `shard_min_doc_count`.
+    :arg shard_size: Can be used to control the volumes of candidate terms
+        produced by each shard. By default, `shard_size` will be
+        automatically estimated based on the number of shards and the
+        `size` parameter.
+    :arg size: The number of buckets returned out of the overall terms
+        list.
+    """
+
+    name = "significant_terms"
+    _param_defs = {
+        "background_filter": {"type": "query"},
+    }
+
+    def __init__(
+        self,
+        *,
+        background_filter: Union[Query, "DefaultType"] = DEFAULT,
+        chi_square: Union[
+            "types.ChiSquareHeuristic", Dict[str, Any], "DefaultType"
+        ] = DEFAULT,
+        exclude: Union[str, Sequence[str], "DefaultType"] = DEFAULT,
+        execution_hint: Union[
+            Literal[
+                "map",
+                "global_ordinals",
+                "global_ordinals_hash",
+                "global_ordinals_low_cardinality",
+            ],
+            "DefaultType",
+        ] = DEFAULT,
+        field: Union[str, "InstrumentedField", "DefaultType"] = DEFAULT,
+        gnd: Union[
+            "types.GoogleNormalizedDistanceHeuristic", Dict[str, Any], "DefaultType"
+        ] = DEFAULT,
+        include: Union[
+            str, Sequence[str], "types.TermsPartition", Dict[str, Any], "DefaultType"
+        ] = DEFAULT,
+        jlh: Union["types.EmptyObject", Dict[str, Any], "DefaultType"] = DEFAULT,
+        min_doc_count: Union[int, "DefaultType"] = DEFAULT,
+        mutual_information: Union[
+            "types.MutualInformationHeuristic", Dict[str, Any], "DefaultType"
+        ] = DEFAULT,
+        percentage: Union[
+            "types.PercentageScoreHeuristic", Dict[str, Any], "DefaultType"
+        ] = DEFAULT,
+        script_heuristic: Union[
+            "types.ScriptedHeuristic", Dict[str, Any], "DefaultType"
+        ] = DEFAULT,
+        shard_min_doc_count: Union[int, "DefaultType"] = DEFAULT,
+        shard_size: Union[int, "DefaultType"] = DEFAULT,
+        size: Union[int, "DefaultType"] = DEFAULT,
+        **kwargs: Any,
+    ):
+        super().__init__(
+            background_filter=background_filter,
+            chi_square=chi_square,
+            exclude=exclude,
+            execution_hint=execution_hint,
+            field=field,
+            gnd=gnd,
+            include=include,
+            jlh=jlh,
+            min_doc_count=min_doc_count,
+            mutual_information=mutual_information,
+            percentage=percentage,
+            script_heuristic=script_heuristic,
+            shard_min_doc_count=shard_min_doc_count,
+            shard_size=shard_size,
+            size=size,
+            **kwargs,
+        )
+
+
+class SignificantText(Bucket[_R]):
+    """
+    Returns interesting or unusual occurrences of free-text terms in a
+    set.
+
+    :arg background_filter: A background filter that can be used to focus
+        in on significant terms within a narrower context, instead of the
+        entire index.
+    :arg chi_square: Use Chi square, as described in "Information
+        Retrieval", Manning et al., Chapter 13.5.2, as the significance
+        score.
+    :arg exclude: Values to exclude.
+    :arg execution_hint: Determines whether the aggregation will use field
+        values directly or global ordinals.
+    :arg field: The field from which to return significant text.
+    :arg filter_duplicate_text: Whether to out duplicate text to deal with
+        noisy data.
+    :arg gnd: Use Google normalized distance as described in "The Google
+        Similarity Distance", Cilibrasi and Vitanyi, 2007, as the
+        significance score.
+    :arg include: Values to include.
+    :arg jlh: Use JLH score as the significance score.
+    :arg min_doc_count: Only return values that are found in more than
+        `min_doc_count` hits. Defaults to `3` if omitted.
+    :arg mutual_information: Use mutual information as described in
+        "Information Retrieval", Manning et al., Chapter 13.5.1, as the
+        significance score.
+    :arg percentage: A simple calculation of the number of documents in
+        the foreground sample with a term divided by the number of
+        documents in the background with the term.
+    :arg script_heuristic: Customized score, implemented via a script.
+    :arg shard_min_doc_count: Regulates the certainty a shard has if the
+        values should actually be added to the candidate list or not with
+        respect to the min_doc_count. Values will only be considered if
+        their local shard frequency within the set is higher than the
+        `shard_min_doc_count`.
+    :arg shard_size: The number of candidate terms produced by each shard.
+        By default, `shard_size` will be automatically estimated based on
+        the number of shards and the `size` parameter.
+    :arg size: The number of buckets returned out of the overall terms
+        list.
+    :arg source_fields: Overrides the JSON `_source` fields from which
+        text will be analyzed.
+    """
+
+    name = "significant_text"
+    _param_defs = {
+        "background_filter": {"type": "query"},
+    }
+
+    def __init__(
+        self,
+        *,
+        background_filter: Union[Query, "DefaultType"] = DEFAULT,
+        chi_square: Union[
+            "types.ChiSquareHeuristic", Dict[str, Any], "DefaultType"
+        ] = DEFAULT,
+        exclude: Union[str, Sequence[str], "DefaultType"] = DEFAULT,
+        execution_hint: Union[
+            Literal[
+                "map",
+                "global_ordinals",
+                "global_ordinals_hash",
+                "global_ordinals_low_cardinality",
+            ],
+            "DefaultType",
+        ] = DEFAULT,
+        field: Union[str, "InstrumentedField", "DefaultType"] = DEFAULT,
+        filter_duplicate_text: Union[bool, "DefaultType"] = DEFAULT,
+        gnd: Union[
+            "types.GoogleNormalizedDistanceHeuristic", Dict[str, Any], "DefaultType"
+        ] = DEFAULT,
+        include: Union[
+            str, Sequence[str], "types.TermsPartition", Dict[str, Any], "DefaultType"
+        ] = DEFAULT,
+        jlh: Union["types.EmptyObject", Dict[str, Any], "DefaultType"] = DEFAULT,
+        min_doc_count: Union[int, "DefaultType"] = DEFAULT,
+        mutual_information: Union[
+            "types.MutualInformationHeuristic", Dict[str, Any], "DefaultType"
+        ] = DEFAULT,
+        percentage: Union[
+            "types.PercentageScoreHeuristic", Dict[str, Any], "DefaultType"
+        ] = DEFAULT,
+        script_heuristic: Union[
+            "types.ScriptedHeuristic", Dict[str, Any], "DefaultType"
+        ] = DEFAULT,
+        shard_min_doc_count: Union[int, "DefaultType"] = DEFAULT,
+        shard_size: Union[int, "DefaultType"] = DEFAULT,
+        size: Union[int, "DefaultType"] = DEFAULT,
+        source_fields: Union[
+            Union[str, "InstrumentedField"],
+            Sequence[Union[str, "InstrumentedField"]],
+            "DefaultType",
+        ] = DEFAULT,
+        **kwargs: Any,
+    ):
+        super().__init__(
+            background_filter=background_filter,
+            chi_square=chi_square,
+            exclude=exclude,
+            execution_hint=execution_hint,
+            field=field,
+            filter_duplicate_text=filter_duplicate_text,
+            gnd=gnd,
+            include=include,
+            jlh=jlh,
+            min_doc_count=min_doc_count,
+            mutual_information=mutual_information,
+            percentage=percentage,
+            script_heuristic=script_heuristic,
+            shard_min_doc_count=shard_min_doc_count,
+            shard_size=shard_size,
+            size=size,
+            source_fields=source_fields,
+            **kwargs,
+        )
+
+
+class Stats(Agg[_R]):
+    """
+    A multi-value metrics aggregation that computes stats over numeric
+    values extracted from the aggregated documents.
+
+    :arg format:
+    :arg field: The field on which to run the aggregation.
+    :arg missing: The value to apply to documents that do not have a
+        value. By default, documents without a value are ignored.
+    :arg script:
+    """
+
+    name = "stats"
+
+    def __init__(
+        self,
+        *,
+        format: Union[str, "DefaultType"] = DEFAULT,
+        field: Union[str, "InstrumentedField", "DefaultType"] = DEFAULT,
+        missing: Union[str, int, float, bool, "DefaultType"] = DEFAULT,
+        script: Union["types.Script", Dict[str, Any], "DefaultType"] = DEFAULT,
+        **kwargs: Any,
+    ):
+        super().__init__(
+            format=format, field=field, missing=missing, script=script, **kwargs
+        )
+
+
+class StatsBucket(Pipeline[_R]):
+    """
+    A sibling pipeline aggregation which calculates a variety of stats
+    across all bucket of a specified metric in a sibling aggregation.
+
+    :arg format: `DecimalFormat` pattern for the output value. If
+        specified, the formatted value is returned in the aggregation’s
+        `value_as_string` property.
+    :arg gap_policy: Policy to apply when gaps are found in the data.
+        Defaults to `skip` if omitted.
+    :arg buckets_path: Path to the buckets that contain one set of values
+        to correlate.
+    """
+
+    name = "stats_bucket"
+
+    def __init__(
+        self,
+        *,
+        format: Union[str, "DefaultType"] = DEFAULT,
+        gap_policy: Union[
+            Literal["skip", "insert_zeros", "keep_values"], "DefaultType"
+        ] = DEFAULT,
+        buckets_path: Union[
+            str, Sequence[str], Mapping[str, str], "DefaultType"
+        ] = DEFAULT,
+        **kwargs: Any,
+    ):
+        super().__init__(
+            format=format, gap_policy=gap_policy, buckets_path=buckets_path, **kwargs
+        )
+
+
+class StringStats(Agg[_R]):
+    """
+    A multi-value metrics aggregation that computes statistics over string
+    values extracted from the aggregated documents.
+
+    :arg show_distribution: Shows the probability distribution for all
+        characters.
+    :arg field: The field on which to run the aggregation.
+    :arg missing: The value to apply to documents that do not have a
+        value. By default, documents without a value are ignored.
+    :arg script:
+    """
+
+    name = "string_stats"
+
+    def __init__(
+        self,
+        *,
+        show_distribution: Union[bool, "DefaultType"] = DEFAULT,
+        field: Union[str, "InstrumentedField", "DefaultType"] = DEFAULT,
+        missing: Union[str, int, float, bool, "DefaultType"] = DEFAULT,
+        script: Union["types.Script", Dict[str, Any], "DefaultType"] = DEFAULT,
+        **kwargs: Any,
+    ):
+        super().__init__(
+            show_distribution=show_distribution,
+            field=field,
+            missing=missing,
+            script=script,
+            **kwargs,
+        )
+
+
+class Sum(Agg[_R]):
+    """
+    A single-value metrics aggregation that sums numeric values that are
+    extracted from the aggregated documents.
+
+    :arg format:
+    :arg field: The field on which to run the aggregation.
+    :arg missing: The value to apply to documents that do not have a
+        value. By default, documents without a value are ignored.
+    :arg script:
+    """
+
+    name = "sum"
+
+    def __init__(
+        self,
+        *,
+        format: Union[str, "DefaultType"] = DEFAULT,
+        field: Union[str, "InstrumentedField", "DefaultType"] = DEFAULT,
+        missing: Union[str, int, float, bool, "DefaultType"] = DEFAULT,
+        script: Union["types.Script", Dict[str, Any], "DefaultType"] = DEFAULT,
+        **kwargs: Any,
+    ):
+        super().__init__(
+            format=format, field=field, missing=missing, script=script, **kwargs
+        )
+
+
+class SumBucket(Pipeline[_R]):
+    """
+    A sibling pipeline aggregation which calculates the sum of a specified
+    metric across all buckets in a sibling aggregation.
+
+    :arg format: `DecimalFormat` pattern for the output value. If
+        specified, the formatted value is returned in the aggregation’s
+        `value_as_string` property.
+    :arg gap_policy: Policy to apply when gaps are found in the data.
+        Defaults to `skip` if omitted.
+    :arg buckets_path: Path to the buckets that contain one set of values
+        to correlate.
+    """
+
+    name = "sum_bucket"
+
+    def __init__(
+        self,
+        *,
+        format: Union[str, "DefaultType"] = DEFAULT,
+        gap_policy: Union[
+            Literal["skip", "insert_zeros", "keep_values"], "DefaultType"
+        ] = DEFAULT,
+        buckets_path: Union[
+            str, Sequence[str], Mapping[str, str], "DefaultType"
+        ] = DEFAULT,
+        **kwargs: Any,
+    ):
+        super().__init__(
+            format=format, gap_policy=gap_policy, buckets_path=buckets_path, **kwargs
+        )
+
+
+class Terms(Bucket[_R]):
+    """
+    A multi-bucket value source based aggregation where buckets are
+    dynamically built - one per unique value.
+
+    :arg collect_mode: Determines how child aggregations should be
+        calculated: breadth-first or depth-first.
+    :arg exclude: Values to exclude. Accepts regular expressions and
+        partitions.
+    :arg execution_hint: Determines whether the aggregation will use field
+        values directly or global ordinals.
+    :arg field: The field from which to return terms.
+    :arg include: Values to include. Accepts regular expressions and
+        partitions.
+    :arg min_doc_count: Only return values that are found in more than
+        `min_doc_count` hits. Defaults to `1` if omitted.
+    :arg missing: The value to apply to documents that do not have a
+        value. By default, documents without a value are ignored.
+    :arg missing_order:
+    :arg missing_bucket:
+    :arg value_type: Coerced unmapped fields into the specified type.
+    :arg order: Specifies the sort order of the buckets. Defaults to
+        sorting by descending document count.
+    :arg script:
+    :arg shard_min_doc_count: Regulates the certainty a shard has if the
+        term should actually be added to the candidate list or not with
+        respect to the `min_doc_count`. Terms will only be considered if
+        their local shard frequency within the set is higher than the
+        `shard_min_doc_count`.
+    :arg shard_size: The number of candidate terms produced by each shard.
+        By default, `shard_size` will be automatically estimated based on
+        the number of shards and the `size` parameter.
+    :arg show_term_doc_count_error: Set to `true` to return the
+        `doc_count_error_upper_bound`, which is an upper bound to the
+        error on the `doc_count` returned by each shard.
+    :arg size: The number of buckets returned out of the overall terms
+        list. Defaults to `10` if omitted.
+    :arg format:
+    """
+
+    name = "terms"
+
+    def __init__(
+        self,
+        *,
+        collect_mode: Union[
+            Literal["depth_first", "breadth_first"], "DefaultType"
+        ] = DEFAULT,
+        exclude: Union[str, Sequence[str], "DefaultType"] = DEFAULT,
+        execution_hint: Union[
+            Literal[
+                "map",
+                "global_ordinals",
+                "global_ordinals_hash",
+                "global_ordinals_low_cardinality",
+            ],
+            "DefaultType",
+        ] = DEFAULT,
+        field: Union[str, "InstrumentedField", "DefaultType"] = DEFAULT,
+        include: Union[
+            str, Sequence[str], "types.TermsPartition", Dict[str, Any], "DefaultType"
+        ] = DEFAULT,
+        min_doc_count: Union[int, "DefaultType"] = DEFAULT,
+        missing: Union[str, int, float, bool, "DefaultType"] = DEFAULT,
+        missing_order: Union[
+            Literal["first", "last", "default"], "DefaultType"
+        ] = DEFAULT,
+        missing_bucket: Union[bool, "DefaultType"] = DEFAULT,
+        value_type: Union[str, "DefaultType"] = DEFAULT,
+        order: Union[
+            Mapping[Union[str, "InstrumentedField"], Literal["asc", "desc"]],
+            Sequence[Mapping[Union[str, "InstrumentedField"], Literal["asc", "desc"]]],
+            "DefaultType",
+        ] = DEFAULT,
+        script: Union["types.Script", Dict[str, Any], "DefaultType"] = DEFAULT,
+        shard_min_doc_count: Union[int, "DefaultType"] = DEFAULT,
+        shard_size: Union[int, "DefaultType"] = DEFAULT,
+        show_term_doc_count_error: Union[bool, "DefaultType"] = DEFAULT,
+        size: Union[int, "DefaultType"] = DEFAULT,
+        format: Union[str, "DefaultType"] = DEFAULT,
+        **kwargs: Any,
+    ):
+        super().__init__(
+            collect_mode=collect_mode,
+            exclude=exclude,
+            execution_hint=execution_hint,
+            field=field,
+            include=include,
+            min_doc_count=min_doc_count,
+            missing=missing,
+            missing_order=missing_order,
+            missing_bucket=missing_bucket,
+            value_type=value_type,
+            order=order,
+            script=script,
+            shard_min_doc_count=shard_min_doc_count,
+            shard_size=shard_size,
+            show_term_doc_count_error=show_term_doc_count_error,
+            size=size,
+            format=format,
+            **kwargs,
+        )
+
+    def result(self, search: "SearchBase[_R]", data: Any) -> AttrDict[Any]:
+        return FieldBucketData(self, search, data)
+
+
+class TimeSeries(Bucket[_R]):
+    """
+    The time series aggregation queries data created using a time series
+    index. This is typically data such as metrics or other data streams
+    with a time component, and requires creating an index using the time
+    series mode.
+
+    :arg size: The maximum number of results to return. Defaults to
+        `10000` if omitted.
+    :arg keyed: Set to `true` to associate a unique string key with each
+        bucket and returns the ranges as a hash rather than an array.
+    """
+
+    name = "time_series"
+
+    def __init__(
+        self,
+        *,
+        size: Union[int, "DefaultType"] = DEFAULT,
+        keyed: Union[bool, "DefaultType"] = DEFAULT,
+        **kwargs: Any,
+    ):
+        super().__init__(size=size, keyed=keyed, **kwargs)
+
+
+class TopHits(Agg[_R]):
+    """
+    A metric aggregation that returns the top matching documents per
+    bucket.
+
+    :arg docvalue_fields: Fields for which to return doc values.
+    :arg explain: If `true`, returns detailed information about score
+        computation as part of a hit.
+    :arg fields: Array of wildcard (*) patterns. The request returns
+        values for field names matching these patterns in the hits.fields
+        property of the response.
+    :arg from: Starting document offset.
+    :arg highlight: Specifies the highlighter to use for retrieving
+        highlighted snippets from one or more fields in the search
+        results.
+    :arg script_fields: Returns the result of one or more script
+        evaluations for each hit.
+    :arg size: The maximum number of top matching hits to return per
+        bucket. Defaults to `3` if omitted.
+    :arg sort: Sort order of the top matching hits. By default, the hits
+        are sorted by the score of the main query.
+    :arg _source: Selects the fields of the source that are returned.
+    :arg stored_fields: Returns values for the specified stored fields
+        (fields that use the `store` mapping option).
+    :arg track_scores: If `true`, calculates and returns document scores,
+        even if the scores are not used for sorting.
+    :arg version: If `true`, returns document version as part of a hit.
+    :arg seq_no_primary_term: If `true`, returns sequence number and
+        primary term of the last modification of each hit.
+    :arg field: The field on which to run the aggregation.
+    :arg missing: The value to apply to documents that do not have a
+        value. By default, documents without a value are ignored.
+    :arg script:
+    """
+
+    name = "top_hits"
+
+    def __init__(
+        self,
+        *,
+        docvalue_fields: Union[
+            Sequence["types.FieldAndFormat"], Sequence[Dict[str, Any]], "DefaultType"
+        ] = DEFAULT,
+        explain: Union[bool, "DefaultType"] = DEFAULT,
+        fields: Union[
+            Sequence["types.FieldAndFormat"], Sequence[Dict[str, Any]], "DefaultType"
+        ] = DEFAULT,
+        from_: Union[int, "DefaultType"] = DEFAULT,
+        highlight: Union["types.Highlight", Dict[str, Any], "DefaultType"] = DEFAULT,
+        script_fields: Union[
+            Mapping[str, "types.ScriptField"], Dict[str, Any], "DefaultType"
+        ] = DEFAULT,
+        size: Union[int, "DefaultType"] = DEFAULT,
+        sort: Union[
+            Union[Union[str, "InstrumentedField"], "types.SortOptions"],
+            Sequence[Union[Union[str, "InstrumentedField"], "types.SortOptions"]],
+            Dict[str, Any],
+            "DefaultType",
+        ] = DEFAULT,
+        _source: Union[
+            bool, "types.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,
+        seq_no_primary_term: Union[bool, "DefaultType"] = DEFAULT,
+        field: Union[str, "InstrumentedField", "DefaultType"] = DEFAULT,
+        missing: Union[str, int, float, bool, "DefaultType"] = DEFAULT,
+        script: Union["types.Script", Dict[str, Any], "DefaultType"] = DEFAULT,
+        **kwargs: Any,
+    ):
+        super().__init__(
+            docvalue_fields=docvalue_fields,
+            explain=explain,
+            fields=fields,
+            from_=from_,
+            highlight=highlight,
+            script_fields=script_fields,
+            size=size,
+            sort=sort,
+            _source=_source,
+            stored_fields=stored_fields,
+            track_scores=track_scores,
+            version=version,
+            seq_no_primary_term=seq_no_primary_term,
+            field=field,
+            missing=missing,
+            script=script,
+            **kwargs,
+        )
+
+    def result(self, search: "SearchBase[_R]", data: Any) -> AttrDict[Any]:
+        return TopHitsData(self, search, data)
+
+
+class TTest(Agg[_R]):
+    """
+    A metrics aggregation that performs a statistical hypothesis test in
+    which the test statistic follows a Student’s t-distribution under the
+    null hypothesis on numeric values extracted from the aggregated
+    documents.
+
+    :arg a: Test population A.
+    :arg b: Test population B.
+    :arg type: The type of test. Defaults to `heteroscedastic` if omitted.
+    """
+
+    name = "t_test"
+
+    def __init__(
+        self,
+        *,
+        a: Union["types.TestPopulation", Dict[str, Any], "DefaultType"] = DEFAULT,
+        b: Union["types.TestPopulation", Dict[str, Any], "DefaultType"] = DEFAULT,
+        type: Union[
+            Literal["paired", "homoscedastic", "heteroscedastic"], "DefaultType"
+        ] = DEFAULT,
+        **kwargs: Any,
+    ):
+        super().__init__(a=a, b=b, type=type, **kwargs)
+
+
+class TopMetrics(Agg[_R]):
+    """
+    A metric aggregation that selects metrics from the document with the
+    largest or smallest sort value.
+
+    :arg metrics: The fields of the top document to return.
+    :arg size: The number of top documents from which to return metrics.
+        Defaults to `1` if omitted.
+    :arg sort: The sort order of the documents.
+    :arg field: The field on which to run the aggregation.
+    :arg missing: The value to apply to documents that do not have a
+        value. By default, documents without a value are ignored.
+    :arg script:
+    """
+
+    name = "top_metrics"
+
+    def __init__(
+        self,
+        *,
+        metrics: Union[
+            "types.TopMetricsValue",
+            Sequence["types.TopMetricsValue"],
+            Sequence[Dict[str, Any]],
+            "DefaultType",
+        ] = DEFAULT,
+        size: Union[int, "DefaultType"] = DEFAULT,
+        sort: Union[
+            Union[Union[str, "InstrumentedField"], "types.SortOptions"],
+            Sequence[Union[Union[str, "InstrumentedField"], "types.SortOptions"]],
+            Dict[str, Any],
+            "DefaultType",
+        ] = DEFAULT,
+        field: Union[str, "InstrumentedField", "DefaultType"] = DEFAULT,
+        missing: Union[str, int, float, bool, "DefaultType"] = DEFAULT,
+        script: Union["types.Script", Dict[str, Any], "DefaultType"] = DEFAULT,
+        **kwargs: Any,
+    ):
+        super().__init__(
+            metrics=metrics,
+            size=size,
+            sort=sort,
+            field=field,
+            missing=missing,
+            script=script,
+            **kwargs,
+        )
+
+
+class ValueCount(Agg[_R]):
+    """
+    A single-value metrics aggregation that counts the number of values
+    that are extracted from the aggregated documents.
+
+    :arg format:
+    :arg field: The field on which to run the aggregation.
+    :arg missing: The value to apply to documents that do not have a
+        value. By default, documents without a value are ignored.
+    :arg script:
+    """
+
+    name = "value_count"
+
+    def __init__(
+        self,
+        *,
+        format: Union[str, "DefaultType"] = DEFAULT,
+        field: Union[str, "InstrumentedField", "DefaultType"] = DEFAULT,
+        missing: Union[str, int, float, bool, "DefaultType"] = DEFAULT,
+        script: Union["types.Script", Dict[str, Any], "DefaultType"] = DEFAULT,
+        **kwargs: Any,
+    ):
+        super().__init__(
+            format=format, field=field, missing=missing, script=script, **kwargs
+        )
+
+
+class WeightedAvg(Agg[_R]):
+    """
+    A single-value metrics aggregation that computes the weighted average
+    of numeric values that are extracted from the aggregated documents.
+
+    :arg format: A numeric response formatter.
+    :arg value: Configuration for the field that provides the values.
+    :arg value_type:
+    :arg weight: Configuration for the field or script that provides the
+        weights.
+    """
+
+    name = "weighted_avg"
+
+    def __init__(
+        self,
+        *,
+        format: Union[str, "DefaultType"] = DEFAULT,
+        value: Union[
+            "types.WeightedAverageValue", Dict[str, Any], "DefaultType"
+        ] = DEFAULT,
+        value_type: Union[
+            Literal[
+                "string",
+                "long",
+                "double",
+                "number",
+                "date",
+                "date_nanos",
+                "ip",
+                "numeric",
+                "geo_point",
+                "boolean",
+            ],
+            "DefaultType",
+        ] = DEFAULT,
+        weight: Union[
+            "types.WeightedAverageValue", Dict[str, Any], "DefaultType"
+        ] = DEFAULT,
+        **kwargs: Any,
+    ):
+        super().__init__(
+            format=format, value=value, value_type=value_type, weight=weight, **kwargs
+        )
+
+
+class VariableWidthHistogram(Bucket[_R]):
+    """
+    A multi-bucket aggregation similar to the histogram, except instead of
+    providing an interval to use as the width of each bucket, a target
+    number of buckets is provided.
+
+    :arg field: The name of the field.
+    :arg buckets: The target number of buckets. Defaults to `10` if
+        omitted.
+    :arg shard_size: The number of buckets that the coordinating node will
+        request from each shard. Defaults to `buckets * 50`.
+    :arg initial_buffer: Specifies the number of individual documents that
+        will be stored in memory on a shard before the initial bucketing
+        algorithm is run. Defaults to `min(10 * shard_size, 50000)`.
+    :arg script:
+    """
+
+    name = "variable_width_histogram"
+
+    def __init__(
+        self,
+        *,
+        field: Union[str, "InstrumentedField", "DefaultType"] = DEFAULT,
+        buckets: Union[int, "DefaultType"] = DEFAULT,
+        shard_size: Union[int, "DefaultType"] = DEFAULT,
+        initial_buffer: Union[int, "DefaultType"] = DEFAULT,
+        script: Union["types.Script", Dict[str, Any], "DefaultType"] = DEFAULT,
+        **kwargs: Any,
+    ):
+        super().__init__(
+            field=field,
+            buckets=buckets,
+            shard_size=shard_size,
+            initial_buffer=initial_buffer,
+            script=script,
+            **kwargs,
+        )
+
+    def result(self, search: "SearchBase[_R]", data: Any) -> AttrDict[Any]:
+        return FieldBucketData(self, search, data)