nominal_api_conjure/conjure/objects/scout/compute/api/
range_series.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, conjure_object::private::DeriveWith)]
6#[derive_with(PartialEq, Eq, PartialOrd, Ord, Hash)]
7pub enum RangeSeries {
8    ApproximateThreshold(super::ApproximateThresholdRanges),
9    BooleanRanges(super::BooleanRanges),
10    ThresholdRangesV2(super::ThresholdRangesV2),
11    DurationFilter(super::DurationFilterRanges),
12    DurationFilterV2(super::DurationFilterRangesV2),
13    EnumFilter(super::EnumFilterRanges),
14    CategoryFilterRangesV2(super::CategoryFilterRangesV2),
15    CategoricalOnChangeRangesV2(super::CategoricalOnChangeRangesV2),
16    CategoricalStaleRangesV2(super::CategoricalStaleRangesV2),
17    CategoricalEqualityRangesV2(super::CategoricalEqualityRangesV2),
18    EnumSeriesEqualityRangesNode(super::EnumSeriesEqualityRanges),
19    EventsSearch(super::EventsSearchRanges),
20    IntersectRange(super::IntersectRanges),
21    LiteralRanges(super::LiteralRanges),
22    /// Computes ranges where the input time series matches a filter defined by lower and upper bounds, and an operator.
23    MinMaxThreshold(super::MinMaxThresholdRanges),
24    Not(super::NotRanges),
25    OnChange(super::OnChangeRanges),
26    Peak(super::PeakRanges),
27    ExtremaRangesV2(super::ExtremaRangesV2),
28    RangeNumericAggregation(super::RangesNumericAggregation),
29    Raw(super::Reference),
30    Derived(Box<super::DerivedSeries>),
31    SeriesCrossoverRangesNode(super::SeriesCrossoverRanges),
32    SeriesEqualityRangesNode(super::SeriesEqualityRanges),
33    NumericEqualityRangesV2(super::NumericEqualityRangesV2),
34    StabilityDetection(super::StabilityDetectionRanges),
35    StabilityDetectionV2(super::StabilityDetectionRangesV2),
36    StaleRange(super::StaleRanges),
37    NumericStaleRangesV2(super::NumericStaleRangesV2),
38    /// Computes ranges where the input time series matches a filter defined by a single threshold and an operator.
39    Threshold(super::ThresholdingRanges),
40    UnionRange(super::UnionRanges),
41    PaddedRanges(super::PaddedRanges),
42    PaddedRangesV2(super::PaddedRangesV2),
43    /// An unknown variant.
44    Unknown(Unknown),
45}
46impl ser::Serialize for RangeSeries {
47    fn serialize<S>(&self, s: S) -> Result<S::Ok, S::Error>
48    where
49        S: ser::Serializer,
50    {
51        let mut map = s.serialize_map(Some(2))?;
52        match self {
53            RangeSeries::ApproximateThreshold(value) => {
54                map.serialize_entry(&"type", &"approximateThreshold")?;
55                map.serialize_entry(&"approximateThreshold", value)?;
56            }
57            RangeSeries::BooleanRanges(value) => {
58                map.serialize_entry(&"type", &"booleanRanges")?;
59                map.serialize_entry(&"booleanRanges", value)?;
60            }
61            RangeSeries::ThresholdRangesV2(value) => {
62                map.serialize_entry(&"type", &"thresholdRangesV2")?;
63                map.serialize_entry(&"thresholdRangesV2", value)?;
64            }
65            RangeSeries::DurationFilter(value) => {
66                map.serialize_entry(&"type", &"durationFilter")?;
67                map.serialize_entry(&"durationFilter", value)?;
68            }
69            RangeSeries::DurationFilterV2(value) => {
70                map.serialize_entry(&"type", &"durationFilterV2")?;
71                map.serialize_entry(&"durationFilterV2", value)?;
72            }
73            RangeSeries::EnumFilter(value) => {
74                map.serialize_entry(&"type", &"enumFilter")?;
75                map.serialize_entry(&"enumFilter", value)?;
76            }
77            RangeSeries::CategoryFilterRangesV2(value) => {
78                map.serialize_entry(&"type", &"categoryFilterRangesV2")?;
79                map.serialize_entry(&"categoryFilterRangesV2", value)?;
80            }
81            RangeSeries::CategoricalOnChangeRangesV2(value) => {
82                map.serialize_entry(&"type", &"categoricalOnChangeRangesV2")?;
83                map.serialize_entry(&"categoricalOnChangeRangesV2", value)?;
84            }
85            RangeSeries::CategoricalStaleRangesV2(value) => {
86                map.serialize_entry(&"type", &"categoricalStaleRangesV2")?;
87                map.serialize_entry(&"categoricalStaleRangesV2", value)?;
88            }
89            RangeSeries::CategoricalEqualityRangesV2(value) => {
90                map.serialize_entry(&"type", &"categoricalEqualityRangesV2")?;
91                map.serialize_entry(&"categoricalEqualityRangesV2", value)?;
92            }
93            RangeSeries::EnumSeriesEqualityRangesNode(value) => {
94                map.serialize_entry(&"type", &"enumSeriesEqualityRangesNode")?;
95                map.serialize_entry(&"enumSeriesEqualityRangesNode", value)?;
96            }
97            RangeSeries::EventsSearch(value) => {
98                map.serialize_entry(&"type", &"eventsSearch")?;
99                map.serialize_entry(&"eventsSearch", value)?;
100            }
101            RangeSeries::IntersectRange(value) => {
102                map.serialize_entry(&"type", &"intersectRange")?;
103                map.serialize_entry(&"intersectRange", value)?;
104            }
105            RangeSeries::LiteralRanges(value) => {
106                map.serialize_entry(&"type", &"literalRanges")?;
107                map.serialize_entry(&"literalRanges", value)?;
108            }
109            RangeSeries::MinMaxThreshold(value) => {
110                map.serialize_entry(&"type", &"minMaxThreshold")?;
111                map.serialize_entry(&"minMaxThreshold", value)?;
112            }
113            RangeSeries::Not(value) => {
114                map.serialize_entry(&"type", &"not")?;
115                map.serialize_entry(&"not", value)?;
116            }
117            RangeSeries::OnChange(value) => {
118                map.serialize_entry(&"type", &"onChange")?;
119                map.serialize_entry(&"onChange", value)?;
120            }
121            RangeSeries::Peak(value) => {
122                map.serialize_entry(&"type", &"peak")?;
123                map.serialize_entry(&"peak", value)?;
124            }
125            RangeSeries::ExtremaRangesV2(value) => {
126                map.serialize_entry(&"type", &"extremaRangesV2")?;
127                map.serialize_entry(&"extremaRangesV2", value)?;
128            }
129            RangeSeries::RangeNumericAggregation(value) => {
130                map.serialize_entry(&"type", &"rangeNumericAggregation")?;
131                map.serialize_entry(&"rangeNumericAggregation", value)?;
132            }
133            RangeSeries::Raw(value) => {
134                map.serialize_entry(&"type", &"raw")?;
135                map.serialize_entry(&"raw", value)?;
136            }
137            RangeSeries::Derived(value) => {
138                map.serialize_entry(&"type", &"derived")?;
139                map.serialize_entry(&"derived", value)?;
140            }
141            RangeSeries::SeriesCrossoverRangesNode(value) => {
142                map.serialize_entry(&"type", &"seriesCrossoverRangesNode")?;
143                map.serialize_entry(&"seriesCrossoverRangesNode", value)?;
144            }
145            RangeSeries::SeriesEqualityRangesNode(value) => {
146                map.serialize_entry(&"type", &"seriesEqualityRangesNode")?;
147                map.serialize_entry(&"seriesEqualityRangesNode", value)?;
148            }
149            RangeSeries::NumericEqualityRangesV2(value) => {
150                map.serialize_entry(&"type", &"numericEqualityRangesV2")?;
151                map.serialize_entry(&"numericEqualityRangesV2", value)?;
152            }
153            RangeSeries::StabilityDetection(value) => {
154                map.serialize_entry(&"type", &"stabilityDetection")?;
155                map.serialize_entry(&"stabilityDetection", value)?;
156            }
157            RangeSeries::StabilityDetectionV2(value) => {
158                map.serialize_entry(&"type", &"stabilityDetectionV2")?;
159                map.serialize_entry(&"stabilityDetectionV2", value)?;
160            }
161            RangeSeries::StaleRange(value) => {
162                map.serialize_entry(&"type", &"staleRange")?;
163                map.serialize_entry(&"staleRange", value)?;
164            }
165            RangeSeries::NumericStaleRangesV2(value) => {
166                map.serialize_entry(&"type", &"numericStaleRangesV2")?;
167                map.serialize_entry(&"numericStaleRangesV2", value)?;
168            }
169            RangeSeries::Threshold(value) => {
170                map.serialize_entry(&"type", &"threshold")?;
171                map.serialize_entry(&"threshold", value)?;
172            }
173            RangeSeries::UnionRange(value) => {
174                map.serialize_entry(&"type", &"unionRange")?;
175                map.serialize_entry(&"unionRange", value)?;
176            }
177            RangeSeries::PaddedRanges(value) => {
178                map.serialize_entry(&"type", &"paddedRanges")?;
179                map.serialize_entry(&"paddedRanges", value)?;
180            }
181            RangeSeries::PaddedRangesV2(value) => {
182                map.serialize_entry(&"type", &"paddedRangesV2")?;
183                map.serialize_entry(&"paddedRangesV2", value)?;
184            }
185            RangeSeries::Unknown(value) => {
186                map.serialize_entry(&"type", &value.type_)?;
187                map.serialize_entry(&value.type_, &value.value)?;
188            }
189        }
190        map.end()
191    }
192}
193impl<'de> de::Deserialize<'de> for RangeSeries {
194    fn deserialize<D>(d: D) -> Result<RangeSeries, D::Error>
195    where
196        D: de::Deserializer<'de>,
197    {
198        d.deserialize_map(Visitor_)
199    }
200}
201struct Visitor_;
202impl<'de> de::Visitor<'de> for Visitor_ {
203    type Value = RangeSeries;
204    fn expecting(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
205        fmt.write_str("union RangeSeries")
206    }
207    fn visit_map<A>(self, mut map: A) -> Result<RangeSeries, A::Error>
208    where
209        A: de::MapAccess<'de>,
210    {
211        let v = match map.next_key::<UnionField_<Variant_>>()? {
212            Some(UnionField_::Type) => {
213                let variant = map.next_value()?;
214                let key = map.next_key()?;
215                match (variant, key) {
216                    (
217                        Variant_::ApproximateThreshold,
218                        Some(Variant_::ApproximateThreshold),
219                    ) => {
220                        let value = map.next_value()?;
221                        RangeSeries::ApproximateThreshold(value)
222                    }
223                    (Variant_::BooleanRanges, Some(Variant_::BooleanRanges)) => {
224                        let value = map.next_value()?;
225                        RangeSeries::BooleanRanges(value)
226                    }
227                    (Variant_::ThresholdRangesV2, Some(Variant_::ThresholdRangesV2)) => {
228                        let value = map.next_value()?;
229                        RangeSeries::ThresholdRangesV2(value)
230                    }
231                    (Variant_::DurationFilter, Some(Variant_::DurationFilter)) => {
232                        let value = map.next_value()?;
233                        RangeSeries::DurationFilter(value)
234                    }
235                    (Variant_::DurationFilterV2, Some(Variant_::DurationFilterV2)) => {
236                        let value = map.next_value()?;
237                        RangeSeries::DurationFilterV2(value)
238                    }
239                    (Variant_::EnumFilter, Some(Variant_::EnumFilter)) => {
240                        let value = map.next_value()?;
241                        RangeSeries::EnumFilter(value)
242                    }
243                    (
244                        Variant_::CategoryFilterRangesV2,
245                        Some(Variant_::CategoryFilterRangesV2),
246                    ) => {
247                        let value = map.next_value()?;
248                        RangeSeries::CategoryFilterRangesV2(value)
249                    }
250                    (
251                        Variant_::CategoricalOnChangeRangesV2,
252                        Some(Variant_::CategoricalOnChangeRangesV2),
253                    ) => {
254                        let value = map.next_value()?;
255                        RangeSeries::CategoricalOnChangeRangesV2(value)
256                    }
257                    (
258                        Variant_::CategoricalStaleRangesV2,
259                        Some(Variant_::CategoricalStaleRangesV2),
260                    ) => {
261                        let value = map.next_value()?;
262                        RangeSeries::CategoricalStaleRangesV2(value)
263                    }
264                    (
265                        Variant_::CategoricalEqualityRangesV2,
266                        Some(Variant_::CategoricalEqualityRangesV2),
267                    ) => {
268                        let value = map.next_value()?;
269                        RangeSeries::CategoricalEqualityRangesV2(value)
270                    }
271                    (
272                        Variant_::EnumSeriesEqualityRangesNode,
273                        Some(Variant_::EnumSeriesEqualityRangesNode),
274                    ) => {
275                        let value = map.next_value()?;
276                        RangeSeries::EnumSeriesEqualityRangesNode(value)
277                    }
278                    (Variant_::EventsSearch, Some(Variant_::EventsSearch)) => {
279                        let value = map.next_value()?;
280                        RangeSeries::EventsSearch(value)
281                    }
282                    (Variant_::IntersectRange, Some(Variant_::IntersectRange)) => {
283                        let value = map.next_value()?;
284                        RangeSeries::IntersectRange(value)
285                    }
286                    (Variant_::LiteralRanges, Some(Variant_::LiteralRanges)) => {
287                        let value = map.next_value()?;
288                        RangeSeries::LiteralRanges(value)
289                    }
290                    (Variant_::MinMaxThreshold, Some(Variant_::MinMaxThreshold)) => {
291                        let value = map.next_value()?;
292                        RangeSeries::MinMaxThreshold(value)
293                    }
294                    (Variant_::Not, Some(Variant_::Not)) => {
295                        let value = map.next_value()?;
296                        RangeSeries::Not(value)
297                    }
298                    (Variant_::OnChange, Some(Variant_::OnChange)) => {
299                        let value = map.next_value()?;
300                        RangeSeries::OnChange(value)
301                    }
302                    (Variant_::Peak, Some(Variant_::Peak)) => {
303                        let value = map.next_value()?;
304                        RangeSeries::Peak(value)
305                    }
306                    (Variant_::ExtremaRangesV2, Some(Variant_::ExtremaRangesV2)) => {
307                        let value = map.next_value()?;
308                        RangeSeries::ExtremaRangesV2(value)
309                    }
310                    (
311                        Variant_::RangeNumericAggregation,
312                        Some(Variant_::RangeNumericAggregation),
313                    ) => {
314                        let value = map.next_value()?;
315                        RangeSeries::RangeNumericAggregation(value)
316                    }
317                    (Variant_::Raw, Some(Variant_::Raw)) => {
318                        let value = map.next_value()?;
319                        RangeSeries::Raw(value)
320                    }
321                    (Variant_::Derived, Some(Variant_::Derived)) => {
322                        let value = map.next_value()?;
323                        RangeSeries::Derived(value)
324                    }
325                    (
326                        Variant_::SeriesCrossoverRangesNode,
327                        Some(Variant_::SeriesCrossoverRangesNode),
328                    ) => {
329                        let value = map.next_value()?;
330                        RangeSeries::SeriesCrossoverRangesNode(value)
331                    }
332                    (
333                        Variant_::SeriesEqualityRangesNode,
334                        Some(Variant_::SeriesEqualityRangesNode),
335                    ) => {
336                        let value = map.next_value()?;
337                        RangeSeries::SeriesEqualityRangesNode(value)
338                    }
339                    (
340                        Variant_::NumericEqualityRangesV2,
341                        Some(Variant_::NumericEqualityRangesV2),
342                    ) => {
343                        let value = map.next_value()?;
344                        RangeSeries::NumericEqualityRangesV2(value)
345                    }
346                    (
347                        Variant_::StabilityDetection,
348                        Some(Variant_::StabilityDetection),
349                    ) => {
350                        let value = map.next_value()?;
351                        RangeSeries::StabilityDetection(value)
352                    }
353                    (
354                        Variant_::StabilityDetectionV2,
355                        Some(Variant_::StabilityDetectionV2),
356                    ) => {
357                        let value = map.next_value()?;
358                        RangeSeries::StabilityDetectionV2(value)
359                    }
360                    (Variant_::StaleRange, Some(Variant_::StaleRange)) => {
361                        let value = map.next_value()?;
362                        RangeSeries::StaleRange(value)
363                    }
364                    (
365                        Variant_::NumericStaleRangesV2,
366                        Some(Variant_::NumericStaleRangesV2),
367                    ) => {
368                        let value = map.next_value()?;
369                        RangeSeries::NumericStaleRangesV2(value)
370                    }
371                    (Variant_::Threshold, Some(Variant_::Threshold)) => {
372                        let value = map.next_value()?;
373                        RangeSeries::Threshold(value)
374                    }
375                    (Variant_::UnionRange, Some(Variant_::UnionRange)) => {
376                        let value = map.next_value()?;
377                        RangeSeries::UnionRange(value)
378                    }
379                    (Variant_::PaddedRanges, Some(Variant_::PaddedRanges)) => {
380                        let value = map.next_value()?;
381                        RangeSeries::PaddedRanges(value)
382                    }
383                    (Variant_::PaddedRangesV2, Some(Variant_::PaddedRangesV2)) => {
384                        let value = map.next_value()?;
385                        RangeSeries::PaddedRangesV2(value)
386                    }
387                    (Variant_::Unknown(type_), Some(Variant_::Unknown(b))) => {
388                        if type_ == b {
389                            let value = map.next_value()?;
390                            RangeSeries::Unknown(Unknown { type_, value })
391                        } else {
392                            return Err(
393                                de::Error::invalid_value(de::Unexpected::Str(&type_), &&*b),
394                            )
395                        }
396                    }
397                    (variant, Some(key)) => {
398                        return Err(
399                            de::Error::invalid_value(
400                                de::Unexpected::Str(key.as_str()),
401                                &variant.as_str(),
402                            ),
403                        );
404                    }
405                    (variant, None) => {
406                        return Err(de::Error::missing_field(variant.as_str()));
407                    }
408                }
409            }
410            Some(UnionField_::Value(variant)) => {
411                let value = match &variant {
412                    Variant_::ApproximateThreshold => {
413                        let value = map.next_value()?;
414                        RangeSeries::ApproximateThreshold(value)
415                    }
416                    Variant_::BooleanRanges => {
417                        let value = map.next_value()?;
418                        RangeSeries::BooleanRanges(value)
419                    }
420                    Variant_::ThresholdRangesV2 => {
421                        let value = map.next_value()?;
422                        RangeSeries::ThresholdRangesV2(value)
423                    }
424                    Variant_::DurationFilter => {
425                        let value = map.next_value()?;
426                        RangeSeries::DurationFilter(value)
427                    }
428                    Variant_::DurationFilterV2 => {
429                        let value = map.next_value()?;
430                        RangeSeries::DurationFilterV2(value)
431                    }
432                    Variant_::EnumFilter => {
433                        let value = map.next_value()?;
434                        RangeSeries::EnumFilter(value)
435                    }
436                    Variant_::CategoryFilterRangesV2 => {
437                        let value = map.next_value()?;
438                        RangeSeries::CategoryFilterRangesV2(value)
439                    }
440                    Variant_::CategoricalOnChangeRangesV2 => {
441                        let value = map.next_value()?;
442                        RangeSeries::CategoricalOnChangeRangesV2(value)
443                    }
444                    Variant_::CategoricalStaleRangesV2 => {
445                        let value = map.next_value()?;
446                        RangeSeries::CategoricalStaleRangesV2(value)
447                    }
448                    Variant_::CategoricalEqualityRangesV2 => {
449                        let value = map.next_value()?;
450                        RangeSeries::CategoricalEqualityRangesV2(value)
451                    }
452                    Variant_::EnumSeriesEqualityRangesNode => {
453                        let value = map.next_value()?;
454                        RangeSeries::EnumSeriesEqualityRangesNode(value)
455                    }
456                    Variant_::EventsSearch => {
457                        let value = map.next_value()?;
458                        RangeSeries::EventsSearch(value)
459                    }
460                    Variant_::IntersectRange => {
461                        let value = map.next_value()?;
462                        RangeSeries::IntersectRange(value)
463                    }
464                    Variant_::LiteralRanges => {
465                        let value = map.next_value()?;
466                        RangeSeries::LiteralRanges(value)
467                    }
468                    Variant_::MinMaxThreshold => {
469                        let value = map.next_value()?;
470                        RangeSeries::MinMaxThreshold(value)
471                    }
472                    Variant_::Not => {
473                        let value = map.next_value()?;
474                        RangeSeries::Not(value)
475                    }
476                    Variant_::OnChange => {
477                        let value = map.next_value()?;
478                        RangeSeries::OnChange(value)
479                    }
480                    Variant_::Peak => {
481                        let value = map.next_value()?;
482                        RangeSeries::Peak(value)
483                    }
484                    Variant_::ExtremaRangesV2 => {
485                        let value = map.next_value()?;
486                        RangeSeries::ExtremaRangesV2(value)
487                    }
488                    Variant_::RangeNumericAggregation => {
489                        let value = map.next_value()?;
490                        RangeSeries::RangeNumericAggregation(value)
491                    }
492                    Variant_::Raw => {
493                        let value = map.next_value()?;
494                        RangeSeries::Raw(value)
495                    }
496                    Variant_::Derived => {
497                        let value = map.next_value()?;
498                        RangeSeries::Derived(value)
499                    }
500                    Variant_::SeriesCrossoverRangesNode => {
501                        let value = map.next_value()?;
502                        RangeSeries::SeriesCrossoverRangesNode(value)
503                    }
504                    Variant_::SeriesEqualityRangesNode => {
505                        let value = map.next_value()?;
506                        RangeSeries::SeriesEqualityRangesNode(value)
507                    }
508                    Variant_::NumericEqualityRangesV2 => {
509                        let value = map.next_value()?;
510                        RangeSeries::NumericEqualityRangesV2(value)
511                    }
512                    Variant_::StabilityDetection => {
513                        let value = map.next_value()?;
514                        RangeSeries::StabilityDetection(value)
515                    }
516                    Variant_::StabilityDetectionV2 => {
517                        let value = map.next_value()?;
518                        RangeSeries::StabilityDetectionV2(value)
519                    }
520                    Variant_::StaleRange => {
521                        let value = map.next_value()?;
522                        RangeSeries::StaleRange(value)
523                    }
524                    Variant_::NumericStaleRangesV2 => {
525                        let value = map.next_value()?;
526                        RangeSeries::NumericStaleRangesV2(value)
527                    }
528                    Variant_::Threshold => {
529                        let value = map.next_value()?;
530                        RangeSeries::Threshold(value)
531                    }
532                    Variant_::UnionRange => {
533                        let value = map.next_value()?;
534                        RangeSeries::UnionRange(value)
535                    }
536                    Variant_::PaddedRanges => {
537                        let value = map.next_value()?;
538                        RangeSeries::PaddedRanges(value)
539                    }
540                    Variant_::PaddedRangesV2 => {
541                        let value = map.next_value()?;
542                        RangeSeries::PaddedRangesV2(value)
543                    }
544                    Variant_::Unknown(type_) => {
545                        let value = map.next_value()?;
546                        RangeSeries::Unknown(Unknown {
547                            type_: type_.clone(),
548                            value,
549                        })
550                    }
551                };
552                if map.next_key::<UnionTypeField_>()?.is_none() {
553                    return Err(de::Error::missing_field("type"));
554                }
555                let type_variant = map.next_value::<Variant_>()?;
556                if variant != type_variant {
557                    return Err(
558                        de::Error::invalid_value(
559                            de::Unexpected::Str(type_variant.as_str()),
560                            &variant.as_str(),
561                        ),
562                    );
563                }
564                value
565            }
566            None => return Err(de::Error::missing_field("type")),
567        };
568        if map.next_key::<UnionField_<Variant_>>()?.is_some() {
569            return Err(de::Error::invalid_length(3, &"type and value fields"));
570        }
571        Ok(v)
572    }
573}
574#[derive(PartialEq)]
575enum Variant_ {
576    ApproximateThreshold,
577    BooleanRanges,
578    ThresholdRangesV2,
579    DurationFilter,
580    DurationFilterV2,
581    EnumFilter,
582    CategoryFilterRangesV2,
583    CategoricalOnChangeRangesV2,
584    CategoricalStaleRangesV2,
585    CategoricalEqualityRangesV2,
586    EnumSeriesEqualityRangesNode,
587    EventsSearch,
588    IntersectRange,
589    LiteralRanges,
590    MinMaxThreshold,
591    Not,
592    OnChange,
593    Peak,
594    ExtremaRangesV2,
595    RangeNumericAggregation,
596    Raw,
597    Derived,
598    SeriesCrossoverRangesNode,
599    SeriesEqualityRangesNode,
600    NumericEqualityRangesV2,
601    StabilityDetection,
602    StabilityDetectionV2,
603    StaleRange,
604    NumericStaleRangesV2,
605    Threshold,
606    UnionRange,
607    PaddedRanges,
608    PaddedRangesV2,
609    Unknown(Box<str>),
610}
611impl Variant_ {
612    fn as_str(&self) -> &'static str {
613        match *self {
614            Variant_::ApproximateThreshold => "approximateThreshold",
615            Variant_::BooleanRanges => "booleanRanges",
616            Variant_::ThresholdRangesV2 => "thresholdRangesV2",
617            Variant_::DurationFilter => "durationFilter",
618            Variant_::DurationFilterV2 => "durationFilterV2",
619            Variant_::EnumFilter => "enumFilter",
620            Variant_::CategoryFilterRangesV2 => "categoryFilterRangesV2",
621            Variant_::CategoricalOnChangeRangesV2 => "categoricalOnChangeRangesV2",
622            Variant_::CategoricalStaleRangesV2 => "categoricalStaleRangesV2",
623            Variant_::CategoricalEqualityRangesV2 => "categoricalEqualityRangesV2",
624            Variant_::EnumSeriesEqualityRangesNode => "enumSeriesEqualityRangesNode",
625            Variant_::EventsSearch => "eventsSearch",
626            Variant_::IntersectRange => "intersectRange",
627            Variant_::LiteralRanges => "literalRanges",
628            Variant_::MinMaxThreshold => "minMaxThreshold",
629            Variant_::Not => "not",
630            Variant_::OnChange => "onChange",
631            Variant_::Peak => "peak",
632            Variant_::ExtremaRangesV2 => "extremaRangesV2",
633            Variant_::RangeNumericAggregation => "rangeNumericAggregation",
634            Variant_::Raw => "raw",
635            Variant_::Derived => "derived",
636            Variant_::SeriesCrossoverRangesNode => "seriesCrossoverRangesNode",
637            Variant_::SeriesEqualityRangesNode => "seriesEqualityRangesNode",
638            Variant_::NumericEqualityRangesV2 => "numericEqualityRangesV2",
639            Variant_::StabilityDetection => "stabilityDetection",
640            Variant_::StabilityDetectionV2 => "stabilityDetectionV2",
641            Variant_::StaleRange => "staleRange",
642            Variant_::NumericStaleRangesV2 => "numericStaleRangesV2",
643            Variant_::Threshold => "threshold",
644            Variant_::UnionRange => "unionRange",
645            Variant_::PaddedRanges => "paddedRanges",
646            Variant_::PaddedRangesV2 => "paddedRangesV2",
647            Variant_::Unknown(_) => "unknown variant",
648        }
649    }
650}
651impl<'de> de::Deserialize<'de> for Variant_ {
652    fn deserialize<D>(d: D) -> Result<Variant_, D::Error>
653    where
654        D: de::Deserializer<'de>,
655    {
656        d.deserialize_str(VariantVisitor_)
657    }
658}
659struct VariantVisitor_;
660impl<'de> de::Visitor<'de> for VariantVisitor_ {
661    type Value = Variant_;
662    fn expecting(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
663        fmt.write_str("string")
664    }
665    fn visit_str<E>(self, value: &str) -> Result<Variant_, E>
666    where
667        E: de::Error,
668    {
669        let v = match value {
670            "approximateThreshold" => Variant_::ApproximateThreshold,
671            "booleanRanges" => Variant_::BooleanRanges,
672            "thresholdRangesV2" => Variant_::ThresholdRangesV2,
673            "durationFilter" => Variant_::DurationFilter,
674            "durationFilterV2" => Variant_::DurationFilterV2,
675            "enumFilter" => Variant_::EnumFilter,
676            "categoryFilterRangesV2" => Variant_::CategoryFilterRangesV2,
677            "categoricalOnChangeRangesV2" => Variant_::CategoricalOnChangeRangesV2,
678            "categoricalStaleRangesV2" => Variant_::CategoricalStaleRangesV2,
679            "categoricalEqualityRangesV2" => Variant_::CategoricalEqualityRangesV2,
680            "enumSeriesEqualityRangesNode" => Variant_::EnumSeriesEqualityRangesNode,
681            "eventsSearch" => Variant_::EventsSearch,
682            "intersectRange" => Variant_::IntersectRange,
683            "literalRanges" => Variant_::LiteralRanges,
684            "minMaxThreshold" => Variant_::MinMaxThreshold,
685            "not" => Variant_::Not,
686            "onChange" => Variant_::OnChange,
687            "peak" => Variant_::Peak,
688            "extremaRangesV2" => Variant_::ExtremaRangesV2,
689            "rangeNumericAggregation" => Variant_::RangeNumericAggregation,
690            "raw" => Variant_::Raw,
691            "derived" => Variant_::Derived,
692            "seriesCrossoverRangesNode" => Variant_::SeriesCrossoverRangesNode,
693            "seriesEqualityRangesNode" => Variant_::SeriesEqualityRangesNode,
694            "numericEqualityRangesV2" => Variant_::NumericEqualityRangesV2,
695            "stabilityDetection" => Variant_::StabilityDetection,
696            "stabilityDetectionV2" => Variant_::StabilityDetectionV2,
697            "staleRange" => Variant_::StaleRange,
698            "numericStaleRangesV2" => Variant_::NumericStaleRangesV2,
699            "threshold" => Variant_::Threshold,
700            "unionRange" => Variant_::UnionRange,
701            "paddedRanges" => Variant_::PaddedRanges,
702            "paddedRangesV2" => Variant_::PaddedRangesV2,
703            value => Variant_::Unknown(value.to_string().into_boxed_str()),
704        };
705        Ok(v)
706    }
707}
708///An unknown variant of the RangeSeries union.
709#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
710pub struct Unknown {
711    type_: Box<str>,
712    value: conjure_object::Any,
713}
714impl Unknown {
715    /// Returns the unknown variant's type name.
716    #[inline]
717    pub fn type_(&self) -> &str {
718        &self.type_
719    }
720}
nominal_api_conjure/conjure/objects/scout/compute/api/range_series.rs

nominal_api_conjure/conjure/objects/scout/compute/api/
range_series.rs
