impl BoolQuery {
    /// The clause (query) must appear in matching documents and will contribute to the score.
    pub fn must<T>(mut self, query: T) -> Self
    where
        T: IntoIterator,
        T::Item: Into<Query>,
    {
        self.must.extend(query);
        self
    }

    /// The clause (query) must appear in matching documents and will contribute to the score.
    pub fn must_mut<T>(&mut self, query: T)
    where
        T: IntoIterator,
        T::Item: Into<Query>,
    {
        self.must.extend(query);
    }

    /// The clause (query) should appear in the matching document.
    pub fn should<T>(mut self, query: T) -> Self
    where
        T: IntoIterator,
        T::Item: Into<Query>,
    {
        self.should.extend(query);
        self
    }

    /// The clause (query) must appear in matching documents.
    /// However unlike must the score of the query will be ignored.
    /// Filter clauses are executed in [filter context](https://www.elastic.co/guide/en/elasticsearch/reference/current/query-filter-context.html),
    /// meaning that scoring is ignored and clauses are considered for caching.
    pub fn filter<T>(mut self, query: T) -> Self
    where
        T: IntoIterator,
        T::Item: Into<Query>,
    {
        self.filter.extend(query);
        self
    }

    /// The clause (query) must not appear in the matching documents.
    /// Clauses are executed in [filter context](https://www.elastic.co/guide/en/elasticsearch/reference/current/query-filter-context.html)
    /// meaning that scoring is ignored and clauses are considered for caching.
    /// Because scoring is ignored, a score of `0` for all documents is returned.
    pub fn must_not<T>(mut self, query: T) -> Self
    where
        T: IntoIterator,
        T::Item: Into<Query>,
    {
        self.must_not.extend(query);
        self
    }

    /// You can use the `minimum_should_match` parameter to specify the number
    /// or percentage of should clauses returned documents must match.
    ///
    /// If the `bool` query includes at least one `should` clause and no
    /// `must` or `filter` clauses, the default value is `1`.
    /// Otherwise, the default value is `0`.
    ///
    /// For other valid values, see the
    /// [minimum_should_match parameter](https://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl-minimum-should-match.html).
    pub fn minimum_should_match<T>(mut self, minimum_should_match: T) -> Self
    where
        T: ToString,
    {
        self.minimum_should_match = Some(minimum_should_match.to_string());
        self
    }

    add_boost_and_name!();
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_mut_must() {
        let mut test = Query::bool();
        test.must_mut(Query::term("abc", "def"));

        assert_eq!(Query::bool().must(Query::term("abc", "def")),test);
    }
}

impl QueryCollection {
    fn dedup(&self) {
        self.0.sort_unstable();
        self.0.dedup()
    }
}

let q = Query::has_child(
        "tag",
        Query::bool()
            .filter([Query::term("a", "b")])
            .filter(Query::terms("def", ["g", "h"])),
    );

let client = Elasticsearch::default();
let s = client.search(SearchParts::None).size(1000).timeout("120s");
let search = Search::new().query(my_bool_query);
let response = s.body(json!(search)).allow_no_indices(true).send().await?;

impl SpanNearQuery {
    /// TODO
    pub fn in_order(mut self, in_order: bool) -> Self {
        self.in_order = Some(in_order);
        self
    }

    /// TODO
    pub fn slop(mut self, slop: i32) -> Self {
        self.slop = Some(slop);
        self
    }
}

 "aggs": {
    "timeline": {
      "date_histogram": {
        "field": "audit_date",
        "calendar_interval": "month",
        "min_doc_count": 1,
        "time_zone": "+02:00"
      }
    }
  }