nominal_api/conjure/objects/scout/run/api/
search_query.rs

1use conjure_object::serde::{ser, de};
2use conjure_object::serde::ser::SerializeMap as SerializeMap_;
3use conjure_object::private::{UnionField_, UnionTypeField_};
4use std::fmt;
5#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
6pub enum SearchQuery {
7    #[deprecated(note = "Use startTime instead")]
8    StartTimeInclusive(super::UtcTimestamp),
9    StartTime(Box<super::TimeframeFilter>),
10    #[deprecated(note = "Use endTime instead")]
11    EndTimeInclusive(super::UtcTimestamp),
12    EndTime(Box<super::TimeframeFilter>),
13    TimeRange(super::TimeRangeFilter),
14    CreatedAt(Box<super::TimeframeFilter>),
15    /// Performs case insensitive exact substring match search on the title.
16    ExactMatch(String),
17    SearchText(String),
18    #[deprecated(note = "Use getRunsByAsset rather than text-based search")]
19    Asset(super::super::super::rids::api::AssetRid),
20    Assets(super::AssetsFilter),
21    /// Search for either only single-asset runs (true), or only multi-asset runs (false).
22    IsSingleAsset(bool),
23    #[deprecated(note = "use labels instead")]
24    Label(super::super::super::super::api::Label),
25    Labels(super::super::super::rids::api::LabelsFilter),
26    #[deprecated(note = "use properties")]
27    Property(super::super::super::super::api::Property),
28    /// Matches runs that have a property with this key, regardless of value.
29    PropertyKey(super::super::super::super::api::PropertyName),
30    Properties(super::super::super::rids::api::PropertiesFilter),
31    DataSourceSeriesTag(super::DataSourceSeriesTag),
32    DataSourceRefName(super::super::super::api::DataSourceRefName),
33    #[deprecated(
34        note = "Use dataSourceRefName, rather than searching directly by DataSource."
35    )]
36    DataSource(Box<super::DataSource>),
37    RunNumber(conjure_object::SafeLong),
38    RunPrefix(String),
39    /// Search for runs where its aggregated check alert satisfy a given operator and threshold.
40    CheckAlertStatesFilter(super::CheckAlertStatesFilter),
41    Archived(bool),
42    And(Vec<super::SearchQuery>),
43    Or(Vec<super::SearchQuery>),
44    Not(Box<super::SearchQuery>),
45    Workspace(super::super::super::super::api::rids::WorkspaceRid),
46    /// An unknown variant.
47    Unknown(Unknown),
48}
49impl ser::Serialize for SearchQuery {
50    fn serialize<S>(&self, s: S) -> Result<S::Ok, S::Error>
51    where
52        S: ser::Serializer,
53    {
54        let mut map = s.serialize_map(Some(2))?;
55        match self {
56            #[allow(deprecated)]
57            SearchQuery::StartTimeInclusive(value) => {
58                map.serialize_entry(&"type", &"startTimeInclusive")?;
59                map.serialize_entry(&"startTimeInclusive", value)?;
60            }
61            SearchQuery::StartTime(value) => {
62                map.serialize_entry(&"type", &"startTime")?;
63                map.serialize_entry(&"startTime", value)?;
64            }
65            #[allow(deprecated)]
66            SearchQuery::EndTimeInclusive(value) => {
67                map.serialize_entry(&"type", &"endTimeInclusive")?;
68                map.serialize_entry(&"endTimeInclusive", value)?;
69            }
70            SearchQuery::EndTime(value) => {
71                map.serialize_entry(&"type", &"endTime")?;
72                map.serialize_entry(&"endTime", value)?;
73            }
74            SearchQuery::TimeRange(value) => {
75                map.serialize_entry(&"type", &"timeRange")?;
76                map.serialize_entry(&"timeRange", value)?;
77            }
78            SearchQuery::CreatedAt(value) => {
79                map.serialize_entry(&"type", &"createdAt")?;
80                map.serialize_entry(&"createdAt", value)?;
81            }
82            SearchQuery::ExactMatch(value) => {
83                map.serialize_entry(&"type", &"exactMatch")?;
84                map.serialize_entry(&"exactMatch", value)?;
85            }
86            SearchQuery::SearchText(value) => {
87                map.serialize_entry(&"type", &"searchText")?;
88                map.serialize_entry(&"searchText", value)?;
89            }
90            #[allow(deprecated)]
91            SearchQuery::Asset(value) => {
92                map.serialize_entry(&"type", &"asset")?;
93                map.serialize_entry(&"asset", value)?;
94            }
95            SearchQuery::Assets(value) => {
96                map.serialize_entry(&"type", &"assets")?;
97                map.serialize_entry(&"assets", value)?;
98            }
99            SearchQuery::IsSingleAsset(value) => {
100                map.serialize_entry(&"type", &"isSingleAsset")?;
101                map.serialize_entry(&"isSingleAsset", value)?;
102            }
103            #[allow(deprecated)]
104            SearchQuery::Label(value) => {
105                map.serialize_entry(&"type", &"label")?;
106                map.serialize_entry(&"label", value)?;
107            }
108            SearchQuery::Labels(value) => {
109                map.serialize_entry(&"type", &"labels")?;
110                map.serialize_entry(&"labels", value)?;
111            }
112            #[allow(deprecated)]
113            SearchQuery::Property(value) => {
114                map.serialize_entry(&"type", &"property")?;
115                map.serialize_entry(&"property", value)?;
116            }
117            SearchQuery::PropertyKey(value) => {
118                map.serialize_entry(&"type", &"propertyKey")?;
119                map.serialize_entry(&"propertyKey", value)?;
120            }
121            SearchQuery::Properties(value) => {
122                map.serialize_entry(&"type", &"properties")?;
123                map.serialize_entry(&"properties", value)?;
124            }
125            SearchQuery::DataSourceSeriesTag(value) => {
126                map.serialize_entry(&"type", &"dataSourceSeriesTag")?;
127                map.serialize_entry(&"dataSourceSeriesTag", value)?;
128            }
129            SearchQuery::DataSourceRefName(value) => {
130                map.serialize_entry(&"type", &"dataSourceRefName")?;
131                map.serialize_entry(&"dataSourceRefName", value)?;
132            }
133            #[allow(deprecated)]
134            SearchQuery::DataSource(value) => {
135                map.serialize_entry(&"type", &"dataSource")?;
136                map.serialize_entry(&"dataSource", value)?;
137            }
138            SearchQuery::RunNumber(value) => {
139                map.serialize_entry(&"type", &"runNumber")?;
140                map.serialize_entry(&"runNumber", value)?;
141            }
142            SearchQuery::RunPrefix(value) => {
143                map.serialize_entry(&"type", &"runPrefix")?;
144                map.serialize_entry(&"runPrefix", value)?;
145            }
146            SearchQuery::CheckAlertStatesFilter(value) => {
147                map.serialize_entry(&"type", &"checkAlertStatesFilter")?;
148                map.serialize_entry(&"checkAlertStatesFilter", value)?;
149            }
150            SearchQuery::Archived(value) => {
151                map.serialize_entry(&"type", &"archived")?;
152                map.serialize_entry(&"archived", value)?;
153            }
154            SearchQuery::And(value) => {
155                map.serialize_entry(&"type", &"and")?;
156                map.serialize_entry(&"and", value)?;
157            }
158            SearchQuery::Or(value) => {
159                map.serialize_entry(&"type", &"or")?;
160                map.serialize_entry(&"or", value)?;
161            }
162            SearchQuery::Not(value) => {
163                map.serialize_entry(&"type", &"not")?;
164                map.serialize_entry(&"not", value)?;
165            }
166            SearchQuery::Workspace(value) => {
167                map.serialize_entry(&"type", &"workspace")?;
168                map.serialize_entry(&"workspace", value)?;
169            }
170            SearchQuery::Unknown(value) => {
171                map.serialize_entry(&"type", &value.type_)?;
172                map.serialize_entry(&value.type_, &value.value)?;
173            }
174        }
175        map.end()
176    }
177}
178impl<'de> de::Deserialize<'de> for SearchQuery {
179    fn deserialize<D>(d: D) -> Result<SearchQuery, D::Error>
180    where
181        D: de::Deserializer<'de>,
182    {
183        d.deserialize_map(Visitor_)
184    }
185}
186struct Visitor_;
187impl<'de> de::Visitor<'de> for Visitor_ {
188    type Value = SearchQuery;
189    fn expecting(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
190        fmt.write_str("union SearchQuery")
191    }
192    fn visit_map<A>(self, mut map: A) -> Result<SearchQuery, A::Error>
193    where
194        A: de::MapAccess<'de>,
195    {
196        let v = match map.next_key::<UnionField_<Variant_>>()? {
197            Some(UnionField_::Type) => {
198                let variant = map.next_value()?;
199                let key = map.next_key()?;
200                match (variant, key) {
201                    #[allow(deprecated)]
202                    (
203                        Variant_::StartTimeInclusive,
204                        Some(Variant_::StartTimeInclusive),
205                    ) => {
206                        let value = map.next_value()?;
207                        SearchQuery::StartTimeInclusive(value)
208                    }
209                    (Variant_::StartTime, Some(Variant_::StartTime)) => {
210                        let value = map.next_value()?;
211                        SearchQuery::StartTime(value)
212                    }
213                    #[allow(deprecated)]
214                    (Variant_::EndTimeInclusive, Some(Variant_::EndTimeInclusive)) => {
215                        let value = map.next_value()?;
216                        SearchQuery::EndTimeInclusive(value)
217                    }
218                    (Variant_::EndTime, Some(Variant_::EndTime)) => {
219                        let value = map.next_value()?;
220                        SearchQuery::EndTime(value)
221                    }
222                    (Variant_::TimeRange, Some(Variant_::TimeRange)) => {
223                        let value = map.next_value()?;
224                        SearchQuery::TimeRange(value)
225                    }
226                    (Variant_::CreatedAt, Some(Variant_::CreatedAt)) => {
227                        let value = map.next_value()?;
228                        SearchQuery::CreatedAt(value)
229                    }
230                    (Variant_::ExactMatch, Some(Variant_::ExactMatch)) => {
231                        let value = map.next_value()?;
232                        SearchQuery::ExactMatch(value)
233                    }
234                    (Variant_::SearchText, Some(Variant_::SearchText)) => {
235                        let value = map.next_value()?;
236                        SearchQuery::SearchText(value)
237                    }
238                    #[allow(deprecated)]
239                    (Variant_::Asset, Some(Variant_::Asset)) => {
240                        let value = map.next_value()?;
241                        SearchQuery::Asset(value)
242                    }
243                    (Variant_::Assets, Some(Variant_::Assets)) => {
244                        let value = map.next_value()?;
245                        SearchQuery::Assets(value)
246                    }
247                    (Variant_::IsSingleAsset, Some(Variant_::IsSingleAsset)) => {
248                        let value = map.next_value()?;
249                        SearchQuery::IsSingleAsset(value)
250                    }
251                    #[allow(deprecated)]
252                    (Variant_::Label, Some(Variant_::Label)) => {
253                        let value = map.next_value()?;
254                        SearchQuery::Label(value)
255                    }
256                    (Variant_::Labels, Some(Variant_::Labels)) => {
257                        let value = map.next_value()?;
258                        SearchQuery::Labels(value)
259                    }
260                    #[allow(deprecated)]
261                    (Variant_::Property, Some(Variant_::Property)) => {
262                        let value = map.next_value()?;
263                        SearchQuery::Property(value)
264                    }
265                    (Variant_::PropertyKey, Some(Variant_::PropertyKey)) => {
266                        let value = map.next_value()?;
267                        SearchQuery::PropertyKey(value)
268                    }
269                    (Variant_::Properties, Some(Variant_::Properties)) => {
270                        let value = map.next_value()?;
271                        SearchQuery::Properties(value)
272                    }
273                    (
274                        Variant_::DataSourceSeriesTag,
275                        Some(Variant_::DataSourceSeriesTag),
276                    ) => {
277                        let value = map.next_value()?;
278                        SearchQuery::DataSourceSeriesTag(value)
279                    }
280                    (Variant_::DataSourceRefName, Some(Variant_::DataSourceRefName)) => {
281                        let value = map.next_value()?;
282                        SearchQuery::DataSourceRefName(value)
283                    }
284                    #[allow(deprecated)]
285                    (Variant_::DataSource, Some(Variant_::DataSource)) => {
286                        let value = map.next_value()?;
287                        SearchQuery::DataSource(value)
288                    }
289                    (Variant_::RunNumber, Some(Variant_::RunNumber)) => {
290                        let value = map.next_value()?;
291                        SearchQuery::RunNumber(value)
292                    }
293                    (Variant_::RunPrefix, Some(Variant_::RunPrefix)) => {
294                        let value = map.next_value()?;
295                        SearchQuery::RunPrefix(value)
296                    }
297                    (
298                        Variant_::CheckAlertStatesFilter,
299                        Some(Variant_::CheckAlertStatesFilter),
300                    ) => {
301                        let value = map.next_value()?;
302                        SearchQuery::CheckAlertStatesFilter(value)
303                    }
304                    (Variant_::Archived, Some(Variant_::Archived)) => {
305                        let value = map.next_value()?;
306                        SearchQuery::Archived(value)
307                    }
308                    (Variant_::And, Some(Variant_::And)) => {
309                        let value = map.next_value()?;
310                        SearchQuery::And(value)
311                    }
312                    (Variant_::Or, Some(Variant_::Or)) => {
313                        let value = map.next_value()?;
314                        SearchQuery::Or(value)
315                    }
316                    (Variant_::Not, Some(Variant_::Not)) => {
317                        let value = map.next_value()?;
318                        SearchQuery::Not(value)
319                    }
320                    (Variant_::Workspace, Some(Variant_::Workspace)) => {
321                        let value = map.next_value()?;
322                        SearchQuery::Workspace(value)
323                    }
324                    (Variant_::Unknown(type_), Some(Variant_::Unknown(b))) => {
325                        if type_ == b {
326                            let value = map.next_value()?;
327                            SearchQuery::Unknown(Unknown { type_, value })
328                        } else {
329                            return Err(
330                                de::Error::invalid_value(de::Unexpected::Str(&type_), &&*b),
331                            )
332                        }
333                    }
334                    (variant, Some(key)) => {
335                        return Err(
336                            de::Error::invalid_value(
337                                de::Unexpected::Str(key.as_str()),
338                                &variant.as_str(),
339                            ),
340                        );
341                    }
342                    (variant, None) => {
343                        return Err(de::Error::missing_field(variant.as_str()));
344                    }
345                }
346            }
347            Some(UnionField_::Value(variant)) => {
348                let value = match &variant {
349                    Variant_::StartTimeInclusive => {
350                        let value = map.next_value()?;
351                        #[allow(deprecated)] SearchQuery::StartTimeInclusive(value)
352                    }
353                    Variant_::StartTime => {
354                        let value = map.next_value()?;
355                        SearchQuery::StartTime(value)
356                    }
357                    Variant_::EndTimeInclusive => {
358                        let value = map.next_value()?;
359                        #[allow(deprecated)] SearchQuery::EndTimeInclusive(value)
360                    }
361                    Variant_::EndTime => {
362                        let value = map.next_value()?;
363                        SearchQuery::EndTime(value)
364                    }
365                    Variant_::TimeRange => {
366                        let value = map.next_value()?;
367                        SearchQuery::TimeRange(value)
368                    }
369                    Variant_::CreatedAt => {
370                        let value = map.next_value()?;
371                        SearchQuery::CreatedAt(value)
372                    }
373                    Variant_::ExactMatch => {
374                        let value = map.next_value()?;
375                        SearchQuery::ExactMatch(value)
376                    }
377                    Variant_::SearchText => {
378                        let value = map.next_value()?;
379                        SearchQuery::SearchText(value)
380                    }
381                    Variant_::Asset => {
382                        let value = map.next_value()?;
383                        #[allow(deprecated)] SearchQuery::Asset(value)
384                    }
385                    Variant_::Assets => {
386                        let value = map.next_value()?;
387                        SearchQuery::Assets(value)
388                    }
389                    Variant_::IsSingleAsset => {
390                        let value = map.next_value()?;
391                        SearchQuery::IsSingleAsset(value)
392                    }
393                    Variant_::Label => {
394                        let value = map.next_value()?;
395                        #[allow(deprecated)] SearchQuery::Label(value)
396                    }
397                    Variant_::Labels => {
398                        let value = map.next_value()?;
399                        SearchQuery::Labels(value)
400                    }
401                    Variant_::Property => {
402                        let value = map.next_value()?;
403                        #[allow(deprecated)] SearchQuery::Property(value)
404                    }
405                    Variant_::PropertyKey => {
406                        let value = map.next_value()?;
407                        SearchQuery::PropertyKey(value)
408                    }
409                    Variant_::Properties => {
410                        let value = map.next_value()?;
411                        SearchQuery::Properties(value)
412                    }
413                    Variant_::DataSourceSeriesTag => {
414                        let value = map.next_value()?;
415                        SearchQuery::DataSourceSeriesTag(value)
416                    }
417                    Variant_::DataSourceRefName => {
418                        let value = map.next_value()?;
419                        SearchQuery::DataSourceRefName(value)
420                    }
421                    Variant_::DataSource => {
422                        let value = map.next_value()?;
423                        #[allow(deprecated)] SearchQuery::DataSource(value)
424                    }
425                    Variant_::RunNumber => {
426                        let value = map.next_value()?;
427                        SearchQuery::RunNumber(value)
428                    }
429                    Variant_::RunPrefix => {
430                        let value = map.next_value()?;
431                        SearchQuery::RunPrefix(value)
432                    }
433                    Variant_::CheckAlertStatesFilter => {
434                        let value = map.next_value()?;
435                        SearchQuery::CheckAlertStatesFilter(value)
436                    }
437                    Variant_::Archived => {
438                        let value = map.next_value()?;
439                        SearchQuery::Archived(value)
440                    }
441                    Variant_::And => {
442                        let value = map.next_value()?;
443                        SearchQuery::And(value)
444                    }
445                    Variant_::Or => {
446                        let value = map.next_value()?;
447                        SearchQuery::Or(value)
448                    }
449                    Variant_::Not => {
450                        let value = map.next_value()?;
451                        SearchQuery::Not(value)
452                    }
453                    Variant_::Workspace => {
454                        let value = map.next_value()?;
455                        SearchQuery::Workspace(value)
456                    }
457                    Variant_::Unknown(type_) => {
458                        let value = map.next_value()?;
459                        SearchQuery::Unknown(Unknown {
460                            type_: type_.clone(),
461                            value,
462                        })
463                    }
464                };
465                if map.next_key::<UnionTypeField_>()?.is_none() {
466                    return Err(de::Error::missing_field("type"));
467                }
468                let type_variant = map.next_value::<Variant_>()?;
469                if variant != type_variant {
470                    return Err(
471                        de::Error::invalid_value(
472                            de::Unexpected::Str(type_variant.as_str()),
473                            &variant.as_str(),
474                        ),
475                    );
476                }
477                value
478            }
479            None => return Err(de::Error::missing_field("type")),
480        };
481        if map.next_key::<UnionField_<Variant_>>()?.is_some() {
482            return Err(de::Error::invalid_length(3, &"type and value fields"));
483        }
484        Ok(v)
485    }
486}
487#[derive(PartialEq)]
488enum Variant_ {
489    StartTimeInclusive,
490    StartTime,
491    EndTimeInclusive,
492    EndTime,
493    TimeRange,
494    CreatedAt,
495    ExactMatch,
496    SearchText,
497    Asset,
498    Assets,
499    IsSingleAsset,
500    Label,
501    Labels,
502    Property,
503    PropertyKey,
504    Properties,
505    DataSourceSeriesTag,
506    DataSourceRefName,
507    DataSource,
508    RunNumber,
509    RunPrefix,
510    CheckAlertStatesFilter,
511    Archived,
512    And,
513    Or,
514    Not,
515    Workspace,
516    Unknown(Box<str>),
517}
518impl Variant_ {
519    fn as_str(&self) -> &'static str {
520        match *self {
521            Variant_::StartTimeInclusive => "startTimeInclusive",
522            Variant_::StartTime => "startTime",
523            Variant_::EndTimeInclusive => "endTimeInclusive",
524            Variant_::EndTime => "endTime",
525            Variant_::TimeRange => "timeRange",
526            Variant_::CreatedAt => "createdAt",
527            Variant_::ExactMatch => "exactMatch",
528            Variant_::SearchText => "searchText",
529            Variant_::Asset => "asset",
530            Variant_::Assets => "assets",
531            Variant_::IsSingleAsset => "isSingleAsset",
532            Variant_::Label => "label",
533            Variant_::Labels => "labels",
534            Variant_::Property => "property",
535            Variant_::PropertyKey => "propertyKey",
536            Variant_::Properties => "properties",
537            Variant_::DataSourceSeriesTag => "dataSourceSeriesTag",
538            Variant_::DataSourceRefName => "dataSourceRefName",
539            Variant_::DataSource => "dataSource",
540            Variant_::RunNumber => "runNumber",
541            Variant_::RunPrefix => "runPrefix",
542            Variant_::CheckAlertStatesFilter => "checkAlertStatesFilter",
543            Variant_::Archived => "archived",
544            Variant_::And => "and",
545            Variant_::Or => "or",
546            Variant_::Not => "not",
547            Variant_::Workspace => "workspace",
548            Variant_::Unknown(_) => "unknown variant",
549        }
550    }
551}
552impl<'de> de::Deserialize<'de> for Variant_ {
553    fn deserialize<D>(d: D) -> Result<Variant_, D::Error>
554    where
555        D: de::Deserializer<'de>,
556    {
557        d.deserialize_str(VariantVisitor_)
558    }
559}
560struct VariantVisitor_;
561impl<'de> de::Visitor<'de> for VariantVisitor_ {
562    type Value = Variant_;
563    fn expecting(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
564        fmt.write_str("string")
565    }
566    fn visit_str<E>(self, value: &str) -> Result<Variant_, E>
567    where
568        E: de::Error,
569    {
570        let v = match value {
571            "startTimeInclusive" => Variant_::StartTimeInclusive,
572            "startTime" => Variant_::StartTime,
573            "endTimeInclusive" => Variant_::EndTimeInclusive,
574            "endTime" => Variant_::EndTime,
575            "timeRange" => Variant_::TimeRange,
576            "createdAt" => Variant_::CreatedAt,
577            "exactMatch" => Variant_::ExactMatch,
578            "searchText" => Variant_::SearchText,
579            "asset" => Variant_::Asset,
580            "assets" => Variant_::Assets,
581            "isSingleAsset" => Variant_::IsSingleAsset,
582            "label" => Variant_::Label,
583            "labels" => Variant_::Labels,
584            "property" => Variant_::Property,
585            "propertyKey" => Variant_::PropertyKey,
586            "properties" => Variant_::Properties,
587            "dataSourceSeriesTag" => Variant_::DataSourceSeriesTag,
588            "dataSourceRefName" => Variant_::DataSourceRefName,
589            "dataSource" => Variant_::DataSource,
590            "runNumber" => Variant_::RunNumber,
591            "runPrefix" => Variant_::RunPrefix,
592            "checkAlertStatesFilter" => Variant_::CheckAlertStatesFilter,
593            "archived" => Variant_::Archived,
594            "and" => Variant_::And,
595            "or" => Variant_::Or,
596            "not" => Variant_::Not,
597            "workspace" => Variant_::Workspace,
598            value => Variant_::Unknown(value.to_string().into_boxed_str()),
599        };
600        Ok(v)
601    }
602}
603///An unknown variant of the SearchQuery union.
604#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
605pub struct Unknown {
606    type_: Box<str>,
607    value: conjure_object::Any,
608}
609impl Unknown {
610    /// Returns the unknown variant's type name.
611    #[inline]
612    pub fn type_(&self) -> &str {
613        &self.type_
614    }
615}
nominal_api/conjure/objects/scout/run/api/search_query.rs

nominal_api/conjure/objects/scout/run/api/
search_query.rs
