elasticsearch/
eql.rs

1/*
2 * Licensed to Elasticsearch B.V. under one or more contributor
3 * license agreements. See the NOTICE file distributed with
4 * this work for additional information regarding copyright
5 * ownership. Elasticsearch B.V. licenses this file to you under
6 * the Apache License, Version 2.0 (the "License"); you may
7 * not use this file except in compliance with the License.
8 * You may obtain a copy of the License at
9 *
10 *	http://www.apache.org/licenses/LICENSE-2.0
11 *
12 * Unless required by applicable law or agreed to in writing,
13 * software distributed under the License is distributed on an
14 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
15 * KIND, either express or implied.  See the License for the
16 * specific language governing permissions and limitations
17 * under the License.
18 */
19
20// -----------------------------------------------
21// This file is generated, Please do not edit it manually.
22// Run the following in the root of the repo to regenerate:
23//
24// cargo make generate-api
25// -----------------------------------------------
26
27//! EQL APIs
28//!
29//! [Event Query Language (EQL)](https://www.elastic.co/guide/en/elasticsearch/reference/master/eql.html) is a query
30//! language for event-based time series data, such as logs, metrics, and traces.
31//!
32//!
33
34#![allow(unused_imports)]
35use crate::{
36    client::Elasticsearch,
37    error::Error,
38    http::{
39        self,
40        headers::{HeaderMap, HeaderName, HeaderValue, ACCEPT, CONTENT_TYPE},
41        request::{Body, JsonBody, NdBody, PARTS_ENCODED},
42        response::Response,
43        transport::Transport,
44    },
45    params::*,
46};
47use percent_encoding::percent_encode;
48use serde::Serialize;
49use std::{borrow::Cow, time::Duration};
50#[derive(Debug, Clone, PartialEq, Eq)]
51#[doc = "API parts for the Eql Delete API"]
52pub enum EqlDeleteParts<'b> {
53    #[doc = "Id"]
54    Id(&'b str),
55}
56impl<'b> EqlDeleteParts<'b> {
57    #[doc = "Builds a relative URL path to the Eql Delete API"]
58    pub fn url(self) -> Cow<'static, str> {
59        match self {
60            EqlDeleteParts::Id(id) => {
61                let encoded_id: Cow<str> = percent_encode(id.as_bytes(), PARTS_ENCODED).into();
62                let mut p = String::with_capacity(13usize + encoded_id.len());
63                p.push_str("/_eql/search/");
64                p.push_str(encoded_id.as_ref());
65                p.into()
66            }
67        }
68    }
69}
70#[doc = "Builder for the [Eql Delete API](https://www.elastic.co/guide/en/elasticsearch/reference/9.0/eql-search-api.html)\n\nDeletes an async EQL search by ID. If the search is still running, the search request will be cancelled. Otherwise, the saved search results are deleted."]
71#[derive(Clone, Debug)]
72pub struct EqlDelete<'a, 'b> {
73    transport: &'a Transport,
74    parts: EqlDeleteParts<'b>,
75    error_trace: Option<bool>,
76    filter_path: Option<&'b [&'b str]>,
77    headers: HeaderMap,
78    human: Option<bool>,
79    pretty: Option<bool>,
80    request_timeout: Option<Duration>,
81    source: Option<&'b str>,
82}
83impl<'a, 'b> EqlDelete<'a, 'b> {
84    #[doc = "Creates a new instance of [EqlDelete] with the specified API parts"]
85    pub fn new(transport: &'a Transport, parts: EqlDeleteParts<'b>) -> Self {
86        let headers = HeaderMap::new();
87        EqlDelete {
88            transport,
89            parts,
90            headers,
91            error_trace: None,
92            filter_path: None,
93            human: None,
94            pretty: None,
95            request_timeout: None,
96            source: None,
97        }
98    }
99    #[doc = "Include the stack trace of returned errors."]
100    pub fn error_trace(mut self, error_trace: bool) -> Self {
101        self.error_trace = Some(error_trace);
102        self
103    }
104    #[doc = "A comma-separated list of filters used to reduce the response."]
105    pub fn filter_path(mut self, filter_path: &'b [&'b str]) -> Self {
106        self.filter_path = Some(filter_path);
107        self
108    }
109    #[doc = "Adds a HTTP header"]
110    pub fn header(mut self, key: HeaderName, value: HeaderValue) -> Self {
111        self.headers.insert(key, value);
112        self
113    }
114    #[doc = "Return human readable values for statistics."]
115    pub fn human(mut self, human: bool) -> Self {
116        self.human = Some(human);
117        self
118    }
119    #[doc = "Pretty format the returned JSON response."]
120    pub fn pretty(mut self, pretty: bool) -> Self {
121        self.pretty = Some(pretty);
122        self
123    }
124    #[doc = "Sets a request timeout for this API call.\n\nThe timeout is applied from when the request starts connecting until the response body has finished."]
125    pub fn request_timeout(mut self, timeout: Duration) -> Self {
126        self.request_timeout = Some(timeout);
127        self
128    }
129    #[doc = "The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests."]
130    pub fn source(mut self, source: &'b str) -> Self {
131        self.source = Some(source);
132        self
133    }
134    #[doc = "Creates an asynchronous call to the Eql Delete API that can be awaited"]
135    pub async fn send(self) -> Result<Response, Error> {
136        let path = self.parts.url();
137        let method = http::Method::Delete;
138        let headers = self.headers;
139        let timeout = self.request_timeout;
140        let query_string = {
141            #[serde_with::skip_serializing_none]
142            #[derive(Serialize)]
143            struct QueryParams<'b> {
144                error_trace: Option<bool>,
145                #[serde(serialize_with = "crate::client::serialize_coll_qs")]
146                filter_path: Option<&'b [&'b str]>,
147                human: Option<bool>,
148                pretty: Option<bool>,
149                source: Option<&'b str>,
150            }
151            let query_params = QueryParams {
152                error_trace: self.error_trace,
153                filter_path: self.filter_path,
154                human: self.human,
155                pretty: self.pretty,
156                source: self.source,
157            };
158            Some(query_params)
159        };
160        let body = Option::<()>::None;
161        let response = self
162            .transport
163            .send(method, &path, headers, query_string.as_ref(), body, timeout)
164            .await?;
165        Ok(response)
166    }
167}
168#[derive(Debug, Clone, PartialEq, Eq)]
169#[doc = "API parts for the Eql Get API"]
170pub enum EqlGetParts<'b> {
171    #[doc = "Id"]
172    Id(&'b str),
173}
174impl<'b> EqlGetParts<'b> {
175    #[doc = "Builds a relative URL path to the Eql Get API"]
176    pub fn url(self) -> Cow<'static, str> {
177        match self {
178            EqlGetParts::Id(id) => {
179                let encoded_id: Cow<str> = percent_encode(id.as_bytes(), PARTS_ENCODED).into();
180                let mut p = String::with_capacity(13usize + encoded_id.len());
181                p.push_str("/_eql/search/");
182                p.push_str(encoded_id.as_ref());
183                p.into()
184            }
185        }
186    }
187}
188#[doc = "Builder for the [Eql Get API](https://www.elastic.co/guide/en/elasticsearch/reference/9.0/eql-search-api.html)\n\nReturns async results from previously executed Event Query Language (EQL) search"]
189#[derive(Clone, Debug)]
190pub struct EqlGet<'a, 'b> {
191    transport: &'a Transport,
192    parts: EqlGetParts<'b>,
193    error_trace: Option<bool>,
194    filter_path: Option<&'b [&'b str]>,
195    headers: HeaderMap,
196    human: Option<bool>,
197    keep_alive: Option<&'b str>,
198    pretty: Option<bool>,
199    request_timeout: Option<Duration>,
200    source: Option<&'b str>,
201    wait_for_completion_timeout: Option<&'b str>,
202}
203impl<'a, 'b> EqlGet<'a, 'b> {
204    #[doc = "Creates a new instance of [EqlGet] with the specified API parts"]
205    pub fn new(transport: &'a Transport, parts: EqlGetParts<'b>) -> Self {
206        let headers = HeaderMap::new();
207        EqlGet {
208            transport,
209            parts,
210            headers,
211            error_trace: None,
212            filter_path: None,
213            human: None,
214            keep_alive: None,
215            pretty: None,
216            request_timeout: None,
217            source: None,
218            wait_for_completion_timeout: None,
219        }
220    }
221    #[doc = "Include the stack trace of returned errors."]
222    pub fn error_trace(mut self, error_trace: bool) -> Self {
223        self.error_trace = Some(error_trace);
224        self
225    }
226    #[doc = "A comma-separated list of filters used to reduce the response."]
227    pub fn filter_path(mut self, filter_path: &'b [&'b str]) -> Self {
228        self.filter_path = Some(filter_path);
229        self
230    }
231    #[doc = "Adds a HTTP header"]
232    pub fn header(mut self, key: HeaderName, value: HeaderValue) -> Self {
233        self.headers.insert(key, value);
234        self
235    }
236    #[doc = "Return human readable values for statistics."]
237    pub fn human(mut self, human: bool) -> Self {
238        self.human = Some(human);
239        self
240    }
241    #[doc = "Update the time interval in which the results (partial or final) for this search will be available"]
242    pub fn keep_alive(mut self, keep_alive: &'b str) -> Self {
243        self.keep_alive = Some(keep_alive);
244        self
245    }
246    #[doc = "Pretty format the returned JSON response."]
247    pub fn pretty(mut self, pretty: bool) -> Self {
248        self.pretty = Some(pretty);
249        self
250    }
251    #[doc = "Sets a request timeout for this API call.\n\nThe timeout is applied from when the request starts connecting until the response body has finished."]
252    pub fn request_timeout(mut self, timeout: Duration) -> Self {
253        self.request_timeout = Some(timeout);
254        self
255    }
256    #[doc = "The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests."]
257    pub fn source(mut self, source: &'b str) -> Self {
258        self.source = Some(source);
259        self
260    }
261    #[doc = "Specify the time that the request should block waiting for the final response"]
262    pub fn wait_for_completion_timeout(mut self, wait_for_completion_timeout: &'b str) -> Self {
263        self.wait_for_completion_timeout = Some(wait_for_completion_timeout);
264        self
265    }
266    #[doc = "Creates an asynchronous call to the Eql Get API that can be awaited"]
267    pub async fn send(self) -> Result<Response, Error> {
268        let path = self.parts.url();
269        let method = http::Method::Get;
270        let headers = self.headers;
271        let timeout = self.request_timeout;
272        let query_string = {
273            #[serde_with::skip_serializing_none]
274            #[derive(Serialize)]
275            struct QueryParams<'b> {
276                error_trace: Option<bool>,
277                #[serde(serialize_with = "crate::client::serialize_coll_qs")]
278                filter_path: Option<&'b [&'b str]>,
279                human: Option<bool>,
280                keep_alive: Option<&'b str>,
281                pretty: Option<bool>,
282                source: Option<&'b str>,
283                wait_for_completion_timeout: Option<&'b str>,
284            }
285            let query_params = QueryParams {
286                error_trace: self.error_trace,
287                filter_path: self.filter_path,
288                human: self.human,
289                keep_alive: self.keep_alive,
290                pretty: self.pretty,
291                source: self.source,
292                wait_for_completion_timeout: self.wait_for_completion_timeout,
293            };
294            Some(query_params)
295        };
296        let body = Option::<()>::None;
297        let response = self
298            .transport
299            .send(method, &path, headers, query_string.as_ref(), body, timeout)
300            .await?;
301        Ok(response)
302    }
303}
304#[derive(Debug, Clone, PartialEq, Eq)]
305#[doc = "API parts for the Eql Get Status API"]
306pub enum EqlGetStatusParts<'b> {
307    #[doc = "Id"]
308    Id(&'b str),
309}
310impl<'b> EqlGetStatusParts<'b> {
311    #[doc = "Builds a relative URL path to the Eql Get Status API"]
312    pub fn url(self) -> Cow<'static, str> {
313        match self {
314            EqlGetStatusParts::Id(id) => {
315                let encoded_id: Cow<str> = percent_encode(id.as_bytes(), PARTS_ENCODED).into();
316                let mut p = String::with_capacity(20usize + encoded_id.len());
317                p.push_str("/_eql/search/status/");
318                p.push_str(encoded_id.as_ref());
319                p.into()
320            }
321        }
322    }
323}
324#[doc = "Builder for the [Eql Get Status API](https://www.elastic.co/guide/en/elasticsearch/reference/9.0/eql-search-api.html)\n\nReturns the status of a previously submitted async or stored Event Query Language (EQL) search"]
325#[derive(Clone, Debug)]
326pub struct EqlGetStatus<'a, 'b> {
327    transport: &'a Transport,
328    parts: EqlGetStatusParts<'b>,
329    error_trace: Option<bool>,
330    filter_path: Option<&'b [&'b str]>,
331    headers: HeaderMap,
332    human: Option<bool>,
333    pretty: Option<bool>,
334    request_timeout: Option<Duration>,
335    source: Option<&'b str>,
336}
337impl<'a, 'b> EqlGetStatus<'a, 'b> {
338    #[doc = "Creates a new instance of [EqlGetStatus] with the specified API parts"]
339    pub fn new(transport: &'a Transport, parts: EqlGetStatusParts<'b>) -> Self {
340        let headers = HeaderMap::new();
341        EqlGetStatus {
342            transport,
343            parts,
344            headers,
345            error_trace: None,
346            filter_path: None,
347            human: None,
348            pretty: None,
349            request_timeout: None,
350            source: None,
351        }
352    }
353    #[doc = "Include the stack trace of returned errors."]
354    pub fn error_trace(mut self, error_trace: bool) -> Self {
355        self.error_trace = Some(error_trace);
356        self
357    }
358    #[doc = "A comma-separated list of filters used to reduce the response."]
359    pub fn filter_path(mut self, filter_path: &'b [&'b str]) -> Self {
360        self.filter_path = Some(filter_path);
361        self
362    }
363    #[doc = "Adds a HTTP header"]
364    pub fn header(mut self, key: HeaderName, value: HeaderValue) -> Self {
365        self.headers.insert(key, value);
366        self
367    }
368    #[doc = "Return human readable values for statistics."]
369    pub fn human(mut self, human: bool) -> Self {
370        self.human = Some(human);
371        self
372    }
373    #[doc = "Pretty format the returned JSON response."]
374    pub fn pretty(mut self, pretty: bool) -> Self {
375        self.pretty = Some(pretty);
376        self
377    }
378    #[doc = "Sets a request timeout for this API call.\n\nThe timeout is applied from when the request starts connecting until the response body has finished."]
379    pub fn request_timeout(mut self, timeout: Duration) -> Self {
380        self.request_timeout = Some(timeout);
381        self
382    }
383    #[doc = "The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests."]
384    pub fn source(mut self, source: &'b str) -> Self {
385        self.source = Some(source);
386        self
387    }
388    #[doc = "Creates an asynchronous call to the Eql Get Status API that can be awaited"]
389    pub async fn send(self) -> Result<Response, Error> {
390        let path = self.parts.url();
391        let method = http::Method::Get;
392        let headers = self.headers;
393        let timeout = self.request_timeout;
394        let query_string = {
395            #[serde_with::skip_serializing_none]
396            #[derive(Serialize)]
397            struct QueryParams<'b> {
398                error_trace: Option<bool>,
399                #[serde(serialize_with = "crate::client::serialize_coll_qs")]
400                filter_path: Option<&'b [&'b str]>,
401                human: Option<bool>,
402                pretty: Option<bool>,
403                source: Option<&'b str>,
404            }
405            let query_params = QueryParams {
406                error_trace: self.error_trace,
407                filter_path: self.filter_path,
408                human: self.human,
409                pretty: self.pretty,
410                source: self.source,
411            };
412            Some(query_params)
413        };
414        let body = Option::<()>::None;
415        let response = self
416            .transport
417            .send(method, &path, headers, query_string.as_ref(), body, timeout)
418            .await?;
419        Ok(response)
420    }
421}
422#[derive(Debug, Clone, PartialEq, Eq)]
423#[doc = "API parts for the Eql Search API"]
424pub enum EqlSearchParts<'b> {
425    #[doc = "Index"]
426    Index(&'b str),
427}
428impl<'b> EqlSearchParts<'b> {
429    #[doc = "Builds a relative URL path to the Eql Search API"]
430    pub fn url(self) -> Cow<'static, str> {
431        match self {
432            EqlSearchParts::Index(index) => {
433                let encoded_index: Cow<str> =
434                    percent_encode(index.as_bytes(), PARTS_ENCODED).into();
435                let mut p = String::with_capacity(13usize + encoded_index.len());
436                p.push('/');
437                p.push_str(encoded_index.as_ref());
438                p.push_str("/_eql/search");
439                p.into()
440            }
441        }
442    }
443}
444#[doc = "Builder for the [Eql Search API](https://www.elastic.co/guide/en/elasticsearch/reference/9.0/eql-search-api.html)\n\nReturns results matching a query expressed in Event Query Language (EQL)"]
445#[derive(Clone, Debug)]
446pub struct EqlSearch<'a, 'b, B> {
447    transport: &'a Transport,
448    parts: EqlSearchParts<'b>,
449    allow_partial_search_results: Option<bool>,
450    allow_partial_sequence_results: Option<bool>,
451    body: Option<B>,
452    error_trace: Option<bool>,
453    filter_path: Option<&'b [&'b str]>,
454    headers: HeaderMap,
455    human: Option<bool>,
456    keep_alive: Option<&'b str>,
457    keep_on_completion: Option<bool>,
458    pretty: Option<bool>,
459    request_timeout: Option<Duration>,
460    source: Option<&'b str>,
461    wait_for_completion_timeout: Option<&'b str>,
462}
463impl<'a, 'b, B> EqlSearch<'a, 'b, B>
464where
465    B: Body,
466{
467    #[doc = "Creates a new instance of [EqlSearch] with the specified API parts"]
468    pub fn new(transport: &'a Transport, parts: EqlSearchParts<'b>) -> Self {
469        let headers = HeaderMap::new();
470        EqlSearch {
471            transport,
472            parts,
473            headers,
474            allow_partial_search_results: None,
475            allow_partial_sequence_results: None,
476            body: None,
477            error_trace: None,
478            filter_path: None,
479            human: None,
480            keep_alive: None,
481            keep_on_completion: None,
482            pretty: None,
483            request_timeout: None,
484            source: None,
485            wait_for_completion_timeout: None,
486        }
487    }
488    #[doc = "Control whether the query should keep running in case of shard failures, and return partial results"]
489    pub fn allow_partial_search_results(mut self, allow_partial_search_results: bool) -> Self {
490        self.allow_partial_search_results = Some(allow_partial_search_results);
491        self
492    }
493    #[doc = "Control whether a sequence query should return partial results or no results at all in case of shard failures. This option has effect only if [allow_partial_search_results] is true."]
494    pub fn allow_partial_sequence_results(mut self, allow_partial_sequence_results: bool) -> Self {
495        self.allow_partial_sequence_results = Some(allow_partial_sequence_results);
496        self
497    }
498    #[doc = "The body for the API call"]
499    pub fn body<T>(self, body: T) -> EqlSearch<'a, 'b, JsonBody<T>>
500    where
501        T: Serialize,
502    {
503        EqlSearch {
504            transport: self.transport,
505            parts: self.parts,
506            body: Some(body.into()),
507            allow_partial_search_results: self.allow_partial_search_results,
508            allow_partial_sequence_results: self.allow_partial_sequence_results,
509            error_trace: self.error_trace,
510            filter_path: self.filter_path,
511            headers: self.headers,
512            human: self.human,
513            keep_alive: self.keep_alive,
514            keep_on_completion: self.keep_on_completion,
515            pretty: self.pretty,
516            request_timeout: self.request_timeout,
517            source: self.source,
518            wait_for_completion_timeout: self.wait_for_completion_timeout,
519        }
520    }
521    #[doc = "Include the stack trace of returned errors."]
522    pub fn error_trace(mut self, error_trace: bool) -> Self {
523        self.error_trace = Some(error_trace);
524        self
525    }
526    #[doc = "A comma-separated list of filters used to reduce the response."]
527    pub fn filter_path(mut self, filter_path: &'b [&'b str]) -> Self {
528        self.filter_path = Some(filter_path);
529        self
530    }
531    #[doc = "Adds a HTTP header"]
532    pub fn header(mut self, key: HeaderName, value: HeaderValue) -> Self {
533        self.headers.insert(key, value);
534        self
535    }
536    #[doc = "Return human readable values for statistics."]
537    pub fn human(mut self, human: bool) -> Self {
538        self.human = Some(human);
539        self
540    }
541    #[doc = "Update the time interval in which the results (partial or final) for this search will be available"]
542    pub fn keep_alive(mut self, keep_alive: &'b str) -> Self {
543        self.keep_alive = Some(keep_alive);
544        self
545    }
546    #[doc = "Control whether the response should be stored in the cluster if it completed within the provided [wait_for_completion] time (default: false)"]
547    pub fn keep_on_completion(mut self, keep_on_completion: bool) -> Self {
548        self.keep_on_completion = Some(keep_on_completion);
549        self
550    }
551    #[doc = "Pretty format the returned JSON response."]
552    pub fn pretty(mut self, pretty: bool) -> Self {
553        self.pretty = Some(pretty);
554        self
555    }
556    #[doc = "Sets a request timeout for this API call.\n\nThe timeout is applied from when the request starts connecting until the response body has finished."]
557    pub fn request_timeout(mut self, timeout: Duration) -> Self {
558        self.request_timeout = Some(timeout);
559        self
560    }
561    #[doc = "The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests."]
562    pub fn source(mut self, source: &'b str) -> Self {
563        self.source = Some(source);
564        self
565    }
566    #[doc = "Specify the time that the request should block waiting for the final response"]
567    pub fn wait_for_completion_timeout(mut self, wait_for_completion_timeout: &'b str) -> Self {
568        self.wait_for_completion_timeout = Some(wait_for_completion_timeout);
569        self
570    }
571    #[doc = "Creates an asynchronous call to the Eql Search API that can be awaited"]
572    pub async fn send(self) -> Result<Response, Error> {
573        let path = self.parts.url();
574        let method = match self.body {
575            Some(_) => http::Method::Post,
576            None => http::Method::Get,
577        };
578        let headers = self.headers;
579        let timeout = self.request_timeout;
580        let query_string = {
581            #[serde_with::skip_serializing_none]
582            #[derive(Serialize)]
583            struct QueryParams<'b> {
584                allow_partial_search_results: Option<bool>,
585                allow_partial_sequence_results: Option<bool>,
586                error_trace: Option<bool>,
587                #[serde(serialize_with = "crate::client::serialize_coll_qs")]
588                filter_path: Option<&'b [&'b str]>,
589                human: Option<bool>,
590                keep_alive: Option<&'b str>,
591                keep_on_completion: Option<bool>,
592                pretty: Option<bool>,
593                source: Option<&'b str>,
594                wait_for_completion_timeout: Option<&'b str>,
595            }
596            let query_params = QueryParams {
597                allow_partial_search_results: self.allow_partial_search_results,
598                allow_partial_sequence_results: self.allow_partial_sequence_results,
599                error_trace: self.error_trace,
600                filter_path: self.filter_path,
601                human: self.human,
602                keep_alive: self.keep_alive,
603                keep_on_completion: self.keep_on_completion,
604                pretty: self.pretty,
605                source: self.source,
606                wait_for_completion_timeout: self.wait_for_completion_timeout,
607            };
608            Some(query_params)
609        };
610        let body = self.body;
611        let response = self
612            .transport
613            .send(method, &path, headers, query_string.as_ref(), body, timeout)
614            .await?;
615        Ok(response)
616    }
617}
618#[doc = "Namespace client for Eql APIs"]
619pub struct Eql<'a> {
620    transport: &'a Transport,
621}
622impl<'a> Eql<'a> {
623    #[doc = "Creates a new instance of [Eql]"]
624    pub fn new(transport: &'a Transport) -> Self {
625        Self { transport }
626    }
627    pub fn transport(&self) -> &Transport {
628        self.transport
629    }
630    #[doc = "[Eql Delete API](https://www.elastic.co/guide/en/elasticsearch/reference/9.0/eql-search-api.html)\n\nDeletes an async EQL search by ID. If the search is still running, the search request will be cancelled. Otherwise, the saved search results are deleted."]
631    pub fn delete<'b>(&'a self, parts: EqlDeleteParts<'b>) -> EqlDelete<'a, 'b> {
632        EqlDelete::new(self.transport(), parts)
633    }
634    #[doc = "[Eql Get API](https://www.elastic.co/guide/en/elasticsearch/reference/9.0/eql-search-api.html)\n\nReturns async results from previously executed Event Query Language (EQL) search"]
635    pub fn get<'b>(&'a self, parts: EqlGetParts<'b>) -> EqlGet<'a, 'b> {
636        EqlGet::new(self.transport(), parts)
637    }
638    #[doc = "[Eql Get Status API](https://www.elastic.co/guide/en/elasticsearch/reference/9.0/eql-search-api.html)\n\nReturns the status of a previously submitted async or stored Event Query Language (EQL) search"]
639    pub fn get_status<'b>(&'a self, parts: EqlGetStatusParts<'b>) -> EqlGetStatus<'a, 'b> {
640        EqlGetStatus::new(self.transport(), parts)
641    }
642    #[doc = "[Eql Search API](https://www.elastic.co/guide/en/elasticsearch/reference/9.0/eql-search-api.html)\n\nReturns results matching a query expressed in Event Query Language (EQL)"]
643    pub fn search<'b>(&'a self, parts: EqlSearchParts<'b>) -> EqlSearch<'a, 'b, ()> {
644        EqlSearch::new(self.transport(), parts)
645    }
646}
647impl Elasticsearch {
648    #[doc = "Creates a namespace client for Eql APIs"]
649    pub fn eql(&self) -> Eql {
650        Eql::new(self.transport())
651    }
652}
elasticsearch/eql.rs

elasticsearch/
eql.rs
