nominal_api/conjure/objects/event/
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    Archived(bool),
8    /// Search text to perform fuzzy searching against.
9    SearchText(String),
10    /// Search text to perform exact matching against on the event name and description.
11    ExactMatch(String),
12    /// Filters to events after this timestamp, exclusive.
13    /// This includes events that start before, but end after this time.
14    After(super::super::api::Timestamp),
15    /// Filters to events before this timestamp, exclusive.
16    /// This includes events that start before, but end after this time.
17    Before(super::super::api::Timestamp),
18    AdvancedTimeFilter(super::EventTimeFilter),
19    #[deprecated(note = "use assetRids")]
20    Asset(super::super::scout::rids::api::AssetRid),
21    Assets(super::AssetsFilter),
22    Template(super::super::scout::rids::api::TemplateRid),
23    Workbook(super::super::scout::rids::api::NotebookRid),
24    #[deprecated(note = "use dataReviews instead")]
25    DataReview(super::super::scout::rids::api::DataReviewRid),
26    DataReviews(super::DataReviewsFilter),
27    #[deprecated(note = "use originTypes instead")]
28    OriginType(super::SearchEventOriginType),
29    OriginTypes(super::OriginTypesFilter),
30    #[deprecated(note = "use dataReviewChecks instead")]
31    DataReviewCheck(super::super::scout::rids::api::CheckRid),
32    DataReviewChecks(super::DataReviewChecksFilter),
33    #[deprecated(note = "use dispositionStatuses instead")]
34    DispositionStatus(super::EventDispositionStatus),
35    DispositionStatuses(Vec<super::EventDispositionStatus>),
36    #[deprecated(note = "use priorities instead")]
37    Priority(super::super::scout::api::Priority),
38    Priorities(Vec<super::super::scout::api::Priority>),
39    #[deprecated(note = "use assignees instead")]
40    Assignee(super::super::scout::rids::api::UserRid),
41    Assignees(super::AssigneesFilter),
42    #[deprecated(note = "use eventTypes instead")]
43    EventType(super::EventType),
44    EventTypes(Vec<super::EventType>),
45    CreatedBy(super::super::scout::rids::api::UserRid),
46    CreatedByAnyOf(Vec<super::super::scout::rids::api::UserRid>),
47    #[deprecated(note = "use labels instead")]
48    Label(super::super::api::Label),
49    Labels(super::super::scout::rids::api::LabelsFilter),
50    #[deprecated(note = "use properties instead")]
51    Property(super::super::api::Property),
52    Properties(super::super::scout::rids::api::PropertiesFilter),
53    And(Vec<super::SearchQuery>),
54    Or(Vec<super::SearchQuery>),
55    Not(Box<super::SearchQuery>),
56    Workspace(super::super::api::rids::WorkspaceRid),
57    Procedure(super::super::api::rids::ProcedureRid),
58    ProcedureExecution(super::super::api::rids::ProcedureExecutionRid),
59    StepId(String),
60    /// Filters to events created from a checklist executing in streaming.
61    /// Use `assets` to further filter to a specific streaming checklist instance.
62    StreamingChecklist(super::super::scout::rids::api::ChecklistRid),
63    /// Filters to events created from the check of a checklist executing in streaming.
64    /// Use `assets` to further filter to a specific streaming checklist instance.
65    StreamingCheck(super::super::scout::rids::api::CheckRid),
66    /// An unknown variant.
67    Unknown(Unknown),
68}
69impl ser::Serialize for SearchQuery {
70    fn serialize<S>(&self, s: S) -> Result<S::Ok, S::Error>
71    where
72        S: ser::Serializer,
73    {
74        let mut map = s.serialize_map(Some(2))?;
75        match self {
76            SearchQuery::Archived(value) => {
77                map.serialize_entry(&"type", &"archived")?;
78                map.serialize_entry(&"archived", value)?;
79            }
80            SearchQuery::SearchText(value) => {
81                map.serialize_entry(&"type", &"searchText")?;
82                map.serialize_entry(&"searchText", value)?;
83            }
84            SearchQuery::ExactMatch(value) => {
85                map.serialize_entry(&"type", &"exactMatch")?;
86                map.serialize_entry(&"exactMatch", value)?;
87            }
88            SearchQuery::After(value) => {
89                map.serialize_entry(&"type", &"after")?;
90                map.serialize_entry(&"after", value)?;
91            }
92            SearchQuery::Before(value) => {
93                map.serialize_entry(&"type", &"before")?;
94                map.serialize_entry(&"before", value)?;
95            }
96            SearchQuery::AdvancedTimeFilter(value) => {
97                map.serialize_entry(&"type", &"advancedTimeFilter")?;
98                map.serialize_entry(&"advancedTimeFilter", value)?;
99            }
100            #[allow(deprecated)]
101            SearchQuery::Asset(value) => {
102                map.serialize_entry(&"type", &"asset")?;
103                map.serialize_entry(&"asset", value)?;
104            }
105            SearchQuery::Assets(value) => {
106                map.serialize_entry(&"type", &"assets")?;
107                map.serialize_entry(&"assets", value)?;
108            }
109            SearchQuery::Template(value) => {
110                map.serialize_entry(&"type", &"template")?;
111                map.serialize_entry(&"template", value)?;
112            }
113            SearchQuery::Workbook(value) => {
114                map.serialize_entry(&"type", &"workbook")?;
115                map.serialize_entry(&"workbook", value)?;
116            }
117            #[allow(deprecated)]
118            SearchQuery::DataReview(value) => {
119                map.serialize_entry(&"type", &"dataReview")?;
120                map.serialize_entry(&"dataReview", value)?;
121            }
122            SearchQuery::DataReviews(value) => {
123                map.serialize_entry(&"type", &"dataReviews")?;
124                map.serialize_entry(&"dataReviews", value)?;
125            }
126            #[allow(deprecated)]
127            SearchQuery::OriginType(value) => {
128                map.serialize_entry(&"type", &"originType")?;
129                map.serialize_entry(&"originType", value)?;
130            }
131            SearchQuery::OriginTypes(value) => {
132                map.serialize_entry(&"type", &"originTypes")?;
133                map.serialize_entry(&"originTypes", value)?;
134            }
135            #[allow(deprecated)]
136            SearchQuery::DataReviewCheck(value) => {
137                map.serialize_entry(&"type", &"dataReviewCheck")?;
138                map.serialize_entry(&"dataReviewCheck", value)?;
139            }
140            SearchQuery::DataReviewChecks(value) => {
141                map.serialize_entry(&"type", &"dataReviewChecks")?;
142                map.serialize_entry(&"dataReviewChecks", value)?;
143            }
144            #[allow(deprecated)]
145            SearchQuery::DispositionStatus(value) => {
146                map.serialize_entry(&"type", &"dispositionStatus")?;
147                map.serialize_entry(&"dispositionStatus", value)?;
148            }
149            SearchQuery::DispositionStatuses(value) => {
150                map.serialize_entry(&"type", &"dispositionStatuses")?;
151                map.serialize_entry(&"dispositionStatuses", value)?;
152            }
153            #[allow(deprecated)]
154            SearchQuery::Priority(value) => {
155                map.serialize_entry(&"type", &"priority")?;
156                map.serialize_entry(&"priority", value)?;
157            }
158            SearchQuery::Priorities(value) => {
159                map.serialize_entry(&"type", &"priorities")?;
160                map.serialize_entry(&"priorities", value)?;
161            }
162            #[allow(deprecated)]
163            SearchQuery::Assignee(value) => {
164                map.serialize_entry(&"type", &"assignee")?;
165                map.serialize_entry(&"assignee", value)?;
166            }
167            SearchQuery::Assignees(value) => {
168                map.serialize_entry(&"type", &"assignees")?;
169                map.serialize_entry(&"assignees", value)?;
170            }
171            #[allow(deprecated)]
172            SearchQuery::EventType(value) => {
173                map.serialize_entry(&"type", &"eventType")?;
174                map.serialize_entry(&"eventType", value)?;
175            }
176            SearchQuery::EventTypes(value) => {
177                map.serialize_entry(&"type", &"eventTypes")?;
178                map.serialize_entry(&"eventTypes", value)?;
179            }
180            SearchQuery::CreatedBy(value) => {
181                map.serialize_entry(&"type", &"createdBy")?;
182                map.serialize_entry(&"createdBy", value)?;
183            }
184            SearchQuery::CreatedByAnyOf(value) => {
185                map.serialize_entry(&"type", &"createdByAnyOf")?;
186                map.serialize_entry(&"createdByAnyOf", value)?;
187            }
188            #[allow(deprecated)]
189            SearchQuery::Label(value) => {
190                map.serialize_entry(&"type", &"label")?;
191                map.serialize_entry(&"label", value)?;
192            }
193            SearchQuery::Labels(value) => {
194                map.serialize_entry(&"type", &"labels")?;
195                map.serialize_entry(&"labels", value)?;
196            }
197            #[allow(deprecated)]
198            SearchQuery::Property(value) => {
199                map.serialize_entry(&"type", &"property")?;
200                map.serialize_entry(&"property", value)?;
201            }
202            SearchQuery::Properties(value) => {
203                map.serialize_entry(&"type", &"properties")?;
204                map.serialize_entry(&"properties", value)?;
205            }
206            SearchQuery::And(value) => {
207                map.serialize_entry(&"type", &"and")?;
208                map.serialize_entry(&"and", value)?;
209            }
210            SearchQuery::Or(value) => {
211                map.serialize_entry(&"type", &"or")?;
212                map.serialize_entry(&"or", value)?;
213            }
214            SearchQuery::Not(value) => {
215                map.serialize_entry(&"type", &"not")?;
216                map.serialize_entry(&"not", value)?;
217            }
218            SearchQuery::Workspace(value) => {
219                map.serialize_entry(&"type", &"workspace")?;
220                map.serialize_entry(&"workspace", value)?;
221            }
222            SearchQuery::Procedure(value) => {
223                map.serialize_entry(&"type", &"procedure")?;
224                map.serialize_entry(&"procedure", value)?;
225            }
226            SearchQuery::ProcedureExecution(value) => {
227                map.serialize_entry(&"type", &"procedureExecution")?;
228                map.serialize_entry(&"procedureExecution", value)?;
229            }
230            SearchQuery::StepId(value) => {
231                map.serialize_entry(&"type", &"stepId")?;
232                map.serialize_entry(&"stepId", value)?;
233            }
234            SearchQuery::StreamingChecklist(value) => {
235                map.serialize_entry(&"type", &"streamingChecklist")?;
236                map.serialize_entry(&"streamingChecklist", value)?;
237            }
238            SearchQuery::StreamingCheck(value) => {
239                map.serialize_entry(&"type", &"streamingCheck")?;
240                map.serialize_entry(&"streamingCheck", value)?;
241            }
242            SearchQuery::Unknown(value) => {
243                map.serialize_entry(&"type", &value.type_)?;
244                map.serialize_entry(&value.type_, &value.value)?;
245            }
246        }
247        map.end()
248    }
249}
250impl<'de> de::Deserialize<'de> for SearchQuery {
251    fn deserialize<D>(d: D) -> Result<SearchQuery, D::Error>
252    where
253        D: de::Deserializer<'de>,
254    {
255        d.deserialize_map(Visitor_)
256    }
257}
258struct Visitor_;
259impl<'de> de::Visitor<'de> for Visitor_ {
260    type Value = SearchQuery;
261    fn expecting(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
262        fmt.write_str("union SearchQuery")
263    }
264    fn visit_map<A>(self, mut map: A) -> Result<SearchQuery, A::Error>
265    where
266        A: de::MapAccess<'de>,
267    {
268        let v = match map.next_key::<UnionField_<Variant_>>()? {
269            Some(UnionField_::Type) => {
270                let variant = map.next_value()?;
271                let key = map.next_key()?;
272                match (variant, key) {
273                    (Variant_::Archived, Some(Variant_::Archived)) => {
274                        let value = map.next_value()?;
275                        SearchQuery::Archived(value)
276                    }
277                    (Variant_::SearchText, Some(Variant_::SearchText)) => {
278                        let value = map.next_value()?;
279                        SearchQuery::SearchText(value)
280                    }
281                    (Variant_::ExactMatch, Some(Variant_::ExactMatch)) => {
282                        let value = map.next_value()?;
283                        SearchQuery::ExactMatch(value)
284                    }
285                    (Variant_::After, Some(Variant_::After)) => {
286                        let value = map.next_value()?;
287                        SearchQuery::After(value)
288                    }
289                    (Variant_::Before, Some(Variant_::Before)) => {
290                        let value = map.next_value()?;
291                        SearchQuery::Before(value)
292                    }
293                    (
294                        Variant_::AdvancedTimeFilter,
295                        Some(Variant_::AdvancedTimeFilter),
296                    ) => {
297                        let value = map.next_value()?;
298                        SearchQuery::AdvancedTimeFilter(value)
299                    }
300                    #[allow(deprecated)]
301                    (Variant_::Asset, Some(Variant_::Asset)) => {
302                        let value = map.next_value()?;
303                        SearchQuery::Asset(value)
304                    }
305                    (Variant_::Assets, Some(Variant_::Assets)) => {
306                        let value = map.next_value()?;
307                        SearchQuery::Assets(value)
308                    }
309                    (Variant_::Template, Some(Variant_::Template)) => {
310                        let value = map.next_value()?;
311                        SearchQuery::Template(value)
312                    }
313                    (Variant_::Workbook, Some(Variant_::Workbook)) => {
314                        let value = map.next_value()?;
315                        SearchQuery::Workbook(value)
316                    }
317                    #[allow(deprecated)]
318                    (Variant_::DataReview, Some(Variant_::DataReview)) => {
319                        let value = map.next_value()?;
320                        SearchQuery::DataReview(value)
321                    }
322                    (Variant_::DataReviews, Some(Variant_::DataReviews)) => {
323                        let value = map.next_value()?;
324                        SearchQuery::DataReviews(value)
325                    }
326                    #[allow(deprecated)]
327                    (Variant_::OriginType, Some(Variant_::OriginType)) => {
328                        let value = map.next_value()?;
329                        SearchQuery::OriginType(value)
330                    }
331                    (Variant_::OriginTypes, Some(Variant_::OriginTypes)) => {
332                        let value = map.next_value()?;
333                        SearchQuery::OriginTypes(value)
334                    }
335                    #[allow(deprecated)]
336                    (Variant_::DataReviewCheck, Some(Variant_::DataReviewCheck)) => {
337                        let value = map.next_value()?;
338                        SearchQuery::DataReviewCheck(value)
339                    }
340                    (Variant_::DataReviewChecks, Some(Variant_::DataReviewChecks)) => {
341                        let value = map.next_value()?;
342                        SearchQuery::DataReviewChecks(value)
343                    }
344                    #[allow(deprecated)]
345                    (Variant_::DispositionStatus, Some(Variant_::DispositionStatus)) => {
346                        let value = map.next_value()?;
347                        SearchQuery::DispositionStatus(value)
348                    }
349                    (
350                        Variant_::DispositionStatuses,
351                        Some(Variant_::DispositionStatuses),
352                    ) => {
353                        let value = map.next_value()?;
354                        SearchQuery::DispositionStatuses(value)
355                    }
356                    #[allow(deprecated)]
357                    (Variant_::Priority, Some(Variant_::Priority)) => {
358                        let value = map.next_value()?;
359                        SearchQuery::Priority(value)
360                    }
361                    (Variant_::Priorities, Some(Variant_::Priorities)) => {
362                        let value = map.next_value()?;
363                        SearchQuery::Priorities(value)
364                    }
365                    #[allow(deprecated)]
366                    (Variant_::Assignee, Some(Variant_::Assignee)) => {
367                        let value = map.next_value()?;
368                        SearchQuery::Assignee(value)
369                    }
370                    (Variant_::Assignees, Some(Variant_::Assignees)) => {
371                        let value = map.next_value()?;
372                        SearchQuery::Assignees(value)
373                    }
374                    #[allow(deprecated)]
375                    (Variant_::EventType, Some(Variant_::EventType)) => {
376                        let value = map.next_value()?;
377                        SearchQuery::EventType(value)
378                    }
379                    (Variant_::EventTypes, Some(Variant_::EventTypes)) => {
380                        let value = map.next_value()?;
381                        SearchQuery::EventTypes(value)
382                    }
383                    (Variant_::CreatedBy, Some(Variant_::CreatedBy)) => {
384                        let value = map.next_value()?;
385                        SearchQuery::CreatedBy(value)
386                    }
387                    (Variant_::CreatedByAnyOf, Some(Variant_::CreatedByAnyOf)) => {
388                        let value = map.next_value()?;
389                        SearchQuery::CreatedByAnyOf(value)
390                    }
391                    #[allow(deprecated)]
392                    (Variant_::Label, Some(Variant_::Label)) => {
393                        let value = map.next_value()?;
394                        SearchQuery::Label(value)
395                    }
396                    (Variant_::Labels, Some(Variant_::Labels)) => {
397                        let value = map.next_value()?;
398                        SearchQuery::Labels(value)
399                    }
400                    #[allow(deprecated)]
401                    (Variant_::Property, Some(Variant_::Property)) => {
402                        let value = map.next_value()?;
403                        SearchQuery::Property(value)
404                    }
405                    (Variant_::Properties, Some(Variant_::Properties)) => {
406                        let value = map.next_value()?;
407                        SearchQuery::Properties(value)
408                    }
409                    (Variant_::And, Some(Variant_::And)) => {
410                        let value = map.next_value()?;
411                        SearchQuery::And(value)
412                    }
413                    (Variant_::Or, Some(Variant_::Or)) => {
414                        let value = map.next_value()?;
415                        SearchQuery::Or(value)
416                    }
417                    (Variant_::Not, Some(Variant_::Not)) => {
418                        let value = map.next_value()?;
419                        SearchQuery::Not(value)
420                    }
421                    (Variant_::Workspace, Some(Variant_::Workspace)) => {
422                        let value = map.next_value()?;
423                        SearchQuery::Workspace(value)
424                    }
425                    (Variant_::Procedure, Some(Variant_::Procedure)) => {
426                        let value = map.next_value()?;
427                        SearchQuery::Procedure(value)
428                    }
429                    (
430                        Variant_::ProcedureExecution,
431                        Some(Variant_::ProcedureExecution),
432                    ) => {
433                        let value = map.next_value()?;
434                        SearchQuery::ProcedureExecution(value)
435                    }
436                    (Variant_::StepId, Some(Variant_::StepId)) => {
437                        let value = map.next_value()?;
438                        SearchQuery::StepId(value)
439                    }
440                    (
441                        Variant_::StreamingChecklist,
442                        Some(Variant_::StreamingChecklist),
443                    ) => {
444                        let value = map.next_value()?;
445                        SearchQuery::StreamingChecklist(value)
446                    }
447                    (Variant_::StreamingCheck, Some(Variant_::StreamingCheck)) => {
448                        let value = map.next_value()?;
449                        SearchQuery::StreamingCheck(value)
450                    }
451                    (Variant_::Unknown(type_), Some(Variant_::Unknown(b))) => {
452                        if type_ == b {
453                            let value = map.next_value()?;
454                            SearchQuery::Unknown(Unknown { type_, value })
455                        } else {
456                            return Err(
457                                de::Error::invalid_value(de::Unexpected::Str(&type_), &&*b),
458                            )
459                        }
460                    }
461                    (variant, Some(key)) => {
462                        return Err(
463                            de::Error::invalid_value(
464                                de::Unexpected::Str(key.as_str()),
465                                &variant.as_str(),
466                            ),
467                        );
468                    }
469                    (variant, None) => {
470                        return Err(de::Error::missing_field(variant.as_str()));
471                    }
472                }
473            }
474            Some(UnionField_::Value(variant)) => {
475                let value = match &variant {
476                    Variant_::Archived => {
477                        let value = map.next_value()?;
478                        SearchQuery::Archived(value)
479                    }
480                    Variant_::SearchText => {
481                        let value = map.next_value()?;
482                        SearchQuery::SearchText(value)
483                    }
484                    Variant_::ExactMatch => {
485                        let value = map.next_value()?;
486                        SearchQuery::ExactMatch(value)
487                    }
488                    Variant_::After => {
489                        let value = map.next_value()?;
490                        SearchQuery::After(value)
491                    }
492                    Variant_::Before => {
493                        let value = map.next_value()?;
494                        SearchQuery::Before(value)
495                    }
496                    Variant_::AdvancedTimeFilter => {
497                        let value = map.next_value()?;
498                        SearchQuery::AdvancedTimeFilter(value)
499                    }
500                    Variant_::Asset => {
501                        let value = map.next_value()?;
502                        #[allow(deprecated)] SearchQuery::Asset(value)
503                    }
504                    Variant_::Assets => {
505                        let value = map.next_value()?;
506                        SearchQuery::Assets(value)
507                    }
508                    Variant_::Template => {
509                        let value = map.next_value()?;
510                        SearchQuery::Template(value)
511                    }
512                    Variant_::Workbook => {
513                        let value = map.next_value()?;
514                        SearchQuery::Workbook(value)
515                    }
516                    Variant_::DataReview => {
517                        let value = map.next_value()?;
518                        #[allow(deprecated)] SearchQuery::DataReview(value)
519                    }
520                    Variant_::DataReviews => {
521                        let value = map.next_value()?;
522                        SearchQuery::DataReviews(value)
523                    }
524                    Variant_::OriginType => {
525                        let value = map.next_value()?;
526                        #[allow(deprecated)] SearchQuery::OriginType(value)
527                    }
528                    Variant_::OriginTypes => {
529                        let value = map.next_value()?;
530                        SearchQuery::OriginTypes(value)
531                    }
532                    Variant_::DataReviewCheck => {
533                        let value = map.next_value()?;
534                        #[allow(deprecated)] SearchQuery::DataReviewCheck(value)
535                    }
536                    Variant_::DataReviewChecks => {
537                        let value = map.next_value()?;
538                        SearchQuery::DataReviewChecks(value)
539                    }
540                    Variant_::DispositionStatus => {
541                        let value = map.next_value()?;
542                        #[allow(deprecated)] SearchQuery::DispositionStatus(value)
543                    }
544                    Variant_::DispositionStatuses => {
545                        let value = map.next_value()?;
546                        SearchQuery::DispositionStatuses(value)
547                    }
548                    Variant_::Priority => {
549                        let value = map.next_value()?;
550                        #[allow(deprecated)] SearchQuery::Priority(value)
551                    }
552                    Variant_::Priorities => {
553                        let value = map.next_value()?;
554                        SearchQuery::Priorities(value)
555                    }
556                    Variant_::Assignee => {
557                        let value = map.next_value()?;
558                        #[allow(deprecated)] SearchQuery::Assignee(value)
559                    }
560                    Variant_::Assignees => {
561                        let value = map.next_value()?;
562                        SearchQuery::Assignees(value)
563                    }
564                    Variant_::EventType => {
565                        let value = map.next_value()?;
566                        #[allow(deprecated)] SearchQuery::EventType(value)
567                    }
568                    Variant_::EventTypes => {
569                        let value = map.next_value()?;
570                        SearchQuery::EventTypes(value)
571                    }
572                    Variant_::CreatedBy => {
573                        let value = map.next_value()?;
574                        SearchQuery::CreatedBy(value)
575                    }
576                    Variant_::CreatedByAnyOf => {
577                        let value = map.next_value()?;
578                        SearchQuery::CreatedByAnyOf(value)
579                    }
580                    Variant_::Label => {
581                        let value = map.next_value()?;
582                        #[allow(deprecated)] SearchQuery::Label(value)
583                    }
584                    Variant_::Labels => {
585                        let value = map.next_value()?;
586                        SearchQuery::Labels(value)
587                    }
588                    Variant_::Property => {
589                        let value = map.next_value()?;
590                        #[allow(deprecated)] SearchQuery::Property(value)
591                    }
592                    Variant_::Properties => {
593                        let value = map.next_value()?;
594                        SearchQuery::Properties(value)
595                    }
596                    Variant_::And => {
597                        let value = map.next_value()?;
598                        SearchQuery::And(value)
599                    }
600                    Variant_::Or => {
601                        let value = map.next_value()?;
602                        SearchQuery::Or(value)
603                    }
604                    Variant_::Not => {
605                        let value = map.next_value()?;
606                        SearchQuery::Not(value)
607                    }
608                    Variant_::Workspace => {
609                        let value = map.next_value()?;
610                        SearchQuery::Workspace(value)
611                    }
612                    Variant_::Procedure => {
613                        let value = map.next_value()?;
614                        SearchQuery::Procedure(value)
615                    }
616                    Variant_::ProcedureExecution => {
617                        let value = map.next_value()?;
618                        SearchQuery::ProcedureExecution(value)
619                    }
620                    Variant_::StepId => {
621                        let value = map.next_value()?;
622                        SearchQuery::StepId(value)
623                    }
624                    Variant_::StreamingChecklist => {
625                        let value = map.next_value()?;
626                        SearchQuery::StreamingChecklist(value)
627                    }
628                    Variant_::StreamingCheck => {
629                        let value = map.next_value()?;
630                        SearchQuery::StreamingCheck(value)
631                    }
632                    Variant_::Unknown(type_) => {
633                        let value = map.next_value()?;
634                        SearchQuery::Unknown(Unknown {
635                            type_: type_.clone(),
636                            value,
637                        })
638                    }
639                };
640                if map.next_key::<UnionTypeField_>()?.is_none() {
641                    return Err(de::Error::missing_field("type"));
642                }
643                let type_variant = map.next_value::<Variant_>()?;
644                if variant != type_variant {
645                    return Err(
646                        de::Error::invalid_value(
647                            de::Unexpected::Str(type_variant.as_str()),
648                            &variant.as_str(),
649                        ),
650                    );
651                }
652                value
653            }
654            None => return Err(de::Error::missing_field("type")),
655        };
656        if map.next_key::<UnionField_<Variant_>>()?.is_some() {
657            return Err(de::Error::invalid_length(3, &"type and value fields"));
658        }
659        Ok(v)
660    }
661}
662#[derive(PartialEq)]
663enum Variant_ {
664    Archived,
665    SearchText,
666    ExactMatch,
667    After,
668    Before,
669    AdvancedTimeFilter,
670    Asset,
671    Assets,
672    Template,
673    Workbook,
674    DataReview,
675    DataReviews,
676    OriginType,
677    OriginTypes,
678    DataReviewCheck,
679    DataReviewChecks,
680    DispositionStatus,
681    DispositionStatuses,
682    Priority,
683    Priorities,
684    Assignee,
685    Assignees,
686    EventType,
687    EventTypes,
688    CreatedBy,
689    CreatedByAnyOf,
690    Label,
691    Labels,
692    Property,
693    Properties,
694    And,
695    Or,
696    Not,
697    Workspace,
698    Procedure,
699    ProcedureExecution,
700    StepId,
701    StreamingChecklist,
702    StreamingCheck,
703    Unknown(Box<str>),
704}
705impl Variant_ {
706    fn as_str(&self) -> &'static str {
707        match *self {
708            Variant_::Archived => "archived",
709            Variant_::SearchText => "searchText",
710            Variant_::ExactMatch => "exactMatch",
711            Variant_::After => "after",
712            Variant_::Before => "before",
713            Variant_::AdvancedTimeFilter => "advancedTimeFilter",
714            Variant_::Asset => "asset",
715            Variant_::Assets => "assets",
716            Variant_::Template => "template",
717            Variant_::Workbook => "workbook",
718            Variant_::DataReview => "dataReview",
719            Variant_::DataReviews => "dataReviews",
720            Variant_::OriginType => "originType",
721            Variant_::OriginTypes => "originTypes",
722            Variant_::DataReviewCheck => "dataReviewCheck",
723            Variant_::DataReviewChecks => "dataReviewChecks",
724            Variant_::DispositionStatus => "dispositionStatus",
725            Variant_::DispositionStatuses => "dispositionStatuses",
726            Variant_::Priority => "priority",
727            Variant_::Priorities => "priorities",
728            Variant_::Assignee => "assignee",
729            Variant_::Assignees => "assignees",
730            Variant_::EventType => "eventType",
731            Variant_::EventTypes => "eventTypes",
732            Variant_::CreatedBy => "createdBy",
733            Variant_::CreatedByAnyOf => "createdByAnyOf",
734            Variant_::Label => "label",
735            Variant_::Labels => "labels",
736            Variant_::Property => "property",
737            Variant_::Properties => "properties",
738            Variant_::And => "and",
739            Variant_::Or => "or",
740            Variant_::Not => "not",
741            Variant_::Workspace => "workspace",
742            Variant_::Procedure => "procedure",
743            Variant_::ProcedureExecution => "procedureExecution",
744            Variant_::StepId => "stepId",
745            Variant_::StreamingChecklist => "streamingChecklist",
746            Variant_::StreamingCheck => "streamingCheck",
747            Variant_::Unknown(_) => "unknown variant",
748        }
749    }
750}
751impl<'de> de::Deserialize<'de> for Variant_ {
752    fn deserialize<D>(d: D) -> Result<Variant_, D::Error>
753    where
754        D: de::Deserializer<'de>,
755    {
756        d.deserialize_str(VariantVisitor_)
757    }
758}
759struct VariantVisitor_;
760impl<'de> de::Visitor<'de> for VariantVisitor_ {
761    type Value = Variant_;
762    fn expecting(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
763        fmt.write_str("string")
764    }
765    fn visit_str<E>(self, value: &str) -> Result<Variant_, E>
766    where
767        E: de::Error,
768    {
769        let v = match value {
770            "archived" => Variant_::Archived,
771            "searchText" => Variant_::SearchText,
772            "exactMatch" => Variant_::ExactMatch,
773            "after" => Variant_::After,
774            "before" => Variant_::Before,
775            "advancedTimeFilter" => Variant_::AdvancedTimeFilter,
776            "asset" => Variant_::Asset,
777            "assets" => Variant_::Assets,
778            "template" => Variant_::Template,
779            "workbook" => Variant_::Workbook,
780            "dataReview" => Variant_::DataReview,
781            "dataReviews" => Variant_::DataReviews,
782            "originType" => Variant_::OriginType,
783            "originTypes" => Variant_::OriginTypes,
784            "dataReviewCheck" => Variant_::DataReviewCheck,
785            "dataReviewChecks" => Variant_::DataReviewChecks,
786            "dispositionStatus" => Variant_::DispositionStatus,
787            "dispositionStatuses" => Variant_::DispositionStatuses,
788            "priority" => Variant_::Priority,
789            "priorities" => Variant_::Priorities,
790            "assignee" => Variant_::Assignee,
791            "assignees" => Variant_::Assignees,
792            "eventType" => Variant_::EventType,
793            "eventTypes" => Variant_::EventTypes,
794            "createdBy" => Variant_::CreatedBy,
795            "createdByAnyOf" => Variant_::CreatedByAnyOf,
796            "label" => Variant_::Label,
797            "labels" => Variant_::Labels,
798            "property" => Variant_::Property,
799            "properties" => Variant_::Properties,
800            "and" => Variant_::And,
801            "or" => Variant_::Or,
802            "not" => Variant_::Not,
803            "workspace" => Variant_::Workspace,
804            "procedure" => Variant_::Procedure,
805            "procedureExecution" => Variant_::ProcedureExecution,
806            "stepId" => Variant_::StepId,
807            "streamingChecklist" => Variant_::StreamingChecklist,
808            "streamingCheck" => Variant_::StreamingCheck,
809            value => Variant_::Unknown(value.to_string().into_boxed_str()),
810        };
811        Ok(v)
812    }
813}
814///An unknown variant of the SearchQuery union.
815#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
816pub struct Unknown {
817    type_: Box<str>,
818    value: conjure_object::Any,
819}
820impl Unknown {
821    /// Returns the unknown variant's type name.
822    #[inline]
823    pub fn type_(&self) -> &str {
824        &self.type_
825    }
826}
nominal_api/conjure/objects/event/search_query.rs

nominal_api/conjure/objects/event/
search_query.rs
