nominal_api_proto/proto/
nominal.compute.v1.rs

1// This file is @generated by prost-build.
2#[derive(Clone, PartialEq, ::prost::Message)]
3pub struct TimeSeriesReference {
4    #[prost(string, tag = "1")]
5    pub variable_name: ::prost::alloc::string::String,
6}
7#[derive(Clone, Copy, PartialEq, ::prost::Message)]
8pub struct ComputeDuration {
9    #[prost(int64, tag = "1")]
10    pub seconds: i64,
11    #[prost(int64, tag = "2")]
12    pub nanos: i64,
13}
14#[derive(Clone, Copy, PartialEq, ::prost::Message)]
15pub struct ComputeTimestamp {
16    #[prost(int64, tag = "1")]
17    pub seconds: i64,
18    #[prost(int64, tag = "2")]
19    pub nanos: i64,
20}
21#[derive(Clone, PartialEq, ::prost::Message)]
22pub struct DoubleConstant {
23    #[prost(oneof = "double_constant::Kind", tags = "1, 2, 3")]
24    pub kind: ::core::option::Option<double_constant::Kind>,
25}
26/// Nested message and enum types in `DoubleConstant`.
27pub mod double_constant {
28    #[derive(Clone, PartialEq, ::prost::Oneof)]
29    pub enum Kind {
30        #[prost(double, tag = "1")]
31        Literal(f64),
32        #[prost(string, tag = "2")]
33        VariableName(::prost::alloc::string::String),
34        #[prost(message, tag = "3")]
35        Builtin(super::BuiltinConstant),
36    }
37}
38#[derive(Clone, PartialEq, ::prost::Message)]
39pub struct IntegerConstant {
40    #[prost(oneof = "integer_constant::Kind", tags = "1, 2")]
41    pub kind: ::core::option::Option<integer_constant::Kind>,
42}
43/// Nested message and enum types in `IntegerConstant`.
44pub mod integer_constant {
45    #[derive(Clone, PartialEq, ::prost::Oneof)]
46    pub enum Kind {
47        #[prost(int32, tag = "1")]
48        Literal(i32),
49        #[prost(string, tag = "2")]
50        VariableName(::prost::alloc::string::String),
51    }
52}
53#[derive(Clone, PartialEq, ::prost::Message)]
54pub struct StringConstant {
55    #[prost(oneof = "string_constant::Kind", tags = "1, 2")]
56    pub kind: ::core::option::Option<string_constant::Kind>,
57}
58/// Nested message and enum types in `StringConstant`.
59pub mod string_constant {
60    #[derive(Clone, PartialEq, ::prost::Oneof)]
61    pub enum Kind {
62        #[prost(string, tag = "1")]
63        Literal(::prost::alloc::string::String),
64        #[prost(string, tag = "2")]
65        VariableName(::prost::alloc::string::String),
66    }
67}
68#[derive(Clone, PartialEq, ::prost::Message)]
69pub struct DurationConstant {
70    #[prost(oneof = "duration_constant::Kind", tags = "1, 2")]
71    pub kind: ::core::option::Option<duration_constant::Kind>,
72}
73/// Nested message and enum types in `DurationConstant`.
74pub mod duration_constant {
75    #[derive(Clone, PartialEq, ::prost::Oneof)]
76    pub enum Kind {
77        #[prost(message, tag = "1")]
78        Literal(super::ComputeDuration),
79        #[prost(string, tag = "2")]
80        VariableName(::prost::alloc::string::String),
81    }
82}
83#[derive(Clone, PartialEq, ::prost::Message)]
84pub struct TimestampConstant {
85    #[prost(oneof = "timestamp_constant::Kind", tags = "1, 2")]
86    pub kind: ::core::option::Option<timestamp_constant::Kind>,
87}
88/// Nested message and enum types in `TimestampConstant`.
89pub mod timestamp_constant {
90    #[derive(Clone, PartialEq, ::prost::Oneof)]
91    pub enum Kind {
92        #[prost(message, tag = "1")]
93        Literal(super::ComputeTimestamp),
94        #[prost(string, tag = "2")]
95        VariableName(::prost::alloc::string::String),
96    }
97}
98#[derive(Clone, PartialEq, ::prost::Message)]
99pub struct StringSetConstant {
100    #[prost(oneof = "string_set_constant::Kind", tags = "1, 2")]
101    pub kind: ::core::option::Option<string_set_constant::Kind>,
102}
103/// Nested message and enum types in `StringSetConstant`.
104pub mod string_set_constant {
105    #[derive(Clone, PartialEq, ::prost::Oneof)]
106    pub enum Kind {
107        #[prost(message, tag = "1")]
108        Literal(super::StringSetLiteral),
109        #[prost(string, tag = "2")]
110        VariableName(::prost::alloc::string::String),
111    }
112}
113#[derive(Clone, PartialEq, ::prost::Message)]
114pub struct StringSetLiteral {
115    #[prost(string, repeated, tag = "1")]
116    pub values: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
117}
118#[derive(Clone, PartialEq, ::prost::Message)]
119pub struct ParameterizedStringSet {
120    #[prost(oneof = "parameterized_string_set::Kind", tags = "1, 2")]
121    pub kind: ::core::option::Option<parameterized_string_set::Kind>,
122}
123/// Nested message and enum types in `ParameterizedStringSet`.
124pub mod parameterized_string_set {
125    #[derive(Clone, PartialEq, ::prost::Oneof)]
126    pub enum Kind {
127        #[prost(message, tag = "1")]
128        Literal(super::ParameterizedStringSetLiteral),
129        #[prost(string, tag = "2")]
130        VariableName(::prost::alloc::string::String),
131    }
132}
133#[derive(Clone, PartialEq, ::prost::Message)]
134pub struct ParameterizedStringSetLiteral {
135    #[prost(message, repeated, tag = "1")]
136    pub values: ::prost::alloc::vec::Vec<StringConstant>,
137}
138#[derive(Clone, Copy, PartialEq, ::prost::Message)]
139pub struct BuiltinConstant {
140    #[prost(oneof = "builtin_constant::Kind", tags = "1, 2")]
141    pub kind: ::core::option::Option<builtin_constant::Kind>,
142}
143/// Nested message and enum types in `BuiltinConstant`.
144pub mod builtin_constant {
145    #[derive(Clone, Copy, PartialEq, ::prost::Oneof)]
146    pub enum Kind {
147        #[prost(enumeration = "super::MathConstant", tag = "1")]
148        Math(i32),
149        #[prost(enumeration = "super::PhysicalConstant", tag = "2")]
150        Physical(i32),
151    }
152}
153#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
154#[repr(i32)]
155pub enum MathConstant {
156    Unspecified = 0,
157    Pi = 1,
158    Tau = 2,
159    E = 3,
160}
161impl MathConstant {
162    /// String value of the enum field names used in the ProtoBuf definition.
163    ///
164    /// The values are not transformed in any way and thus are considered stable
165    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
166    pub fn as_str_name(&self) -> &'static str {
167        match self {
168            Self::Unspecified => "MATH_CONSTANT_UNSPECIFIED",
169            Self::Pi => "MATH_CONSTANT_PI",
170            Self::Tau => "MATH_CONSTANT_TAU",
171            Self::E => "MATH_CONSTANT_E",
172        }
173    }
174    /// Creates an enum from field names used in the ProtoBuf definition.
175    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
176        match value {
177            "MATH_CONSTANT_UNSPECIFIED" => Some(Self::Unspecified),
178            "MATH_CONSTANT_PI" => Some(Self::Pi),
179            "MATH_CONSTANT_TAU" => Some(Self::Tau),
180            "MATH_CONSTANT_E" => Some(Self::E),
181            _ => None,
182        }
183    }
184}
185#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
186#[repr(i32)]
187pub enum PhysicalConstant {
188    Unspecified = 0,
189    SpeedOfLight = 1,
190    Avogadro = 2,
191    Boltzmann = 3,
192    Planck = 4,
193    ElementaryCharge = 5,
194    GasConstant = 6,
195    StandardGravity = 7,
196    StandardAtmosphere = 8,
197    AbsoluteZeroCelsius = 9,
198    GravitationalConstant = 10,
199    StefanBoltzmann = 11,
200}
201impl PhysicalConstant {
202    /// String value of the enum field names used in the ProtoBuf definition.
203    ///
204    /// The values are not transformed in any way and thus are considered stable
205    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
206    pub fn as_str_name(&self) -> &'static str {
207        match self {
208            Self::Unspecified => "PHYSICAL_CONSTANT_UNSPECIFIED",
209            Self::SpeedOfLight => "PHYSICAL_CONSTANT_SPEED_OF_LIGHT",
210            Self::Avogadro => "PHYSICAL_CONSTANT_AVOGADRO",
211            Self::Boltzmann => "PHYSICAL_CONSTANT_BOLTZMANN",
212            Self::Planck => "PHYSICAL_CONSTANT_PLANCK",
213            Self::ElementaryCharge => "PHYSICAL_CONSTANT_ELEMENTARY_CHARGE",
214            Self::GasConstant => "PHYSICAL_CONSTANT_GAS_CONSTANT",
215            Self::StandardGravity => "PHYSICAL_CONSTANT_STANDARD_GRAVITY",
216            Self::StandardAtmosphere => "PHYSICAL_CONSTANT_STANDARD_ATMOSPHERE",
217            Self::AbsoluteZeroCelsius => "PHYSICAL_CONSTANT_ABSOLUTE_ZERO_CELSIUS",
218            Self::GravitationalConstant => "PHYSICAL_CONSTANT_GRAVITATIONAL_CONSTANT",
219            Self::StefanBoltzmann => "PHYSICAL_CONSTANT_STEFAN_BOLTZMANN",
220        }
221    }
222    /// Creates an enum from field names used in the ProtoBuf definition.
223    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
224        match value {
225            "PHYSICAL_CONSTANT_UNSPECIFIED" => Some(Self::Unspecified),
226            "PHYSICAL_CONSTANT_SPEED_OF_LIGHT" => Some(Self::SpeedOfLight),
227            "PHYSICAL_CONSTANT_AVOGADRO" => Some(Self::Avogadro),
228            "PHYSICAL_CONSTANT_BOLTZMANN" => Some(Self::Boltzmann),
229            "PHYSICAL_CONSTANT_PLANCK" => Some(Self::Planck),
230            "PHYSICAL_CONSTANT_ELEMENTARY_CHARGE" => Some(Self::ElementaryCharge),
231            "PHYSICAL_CONSTANT_GAS_CONSTANT" => Some(Self::GasConstant),
232            "PHYSICAL_CONSTANT_STANDARD_GRAVITY" => Some(Self::StandardGravity),
233            "PHYSICAL_CONSTANT_STANDARD_ATMOSPHERE" => Some(Self::StandardAtmosphere),
234            "PHYSICAL_CONSTANT_ABSOLUTE_ZERO_CELSIUS" => Some(Self::AbsoluteZeroCelsius),
235            "PHYSICAL_CONSTANT_GRAVITATIONAL_CONSTANT" => {
236                Some(Self::GravitationalConstant)
237            }
238            "PHYSICAL_CONSTANT_STEFAN_BOLTZMANN" => Some(Self::StefanBoltzmann),
239            _ => None,
240        }
241    }
242}
243#[derive(Clone, PartialEq, ::prost::Message)]
244pub struct ScalingFactor {
245    #[prost(message, optional, tag = "1")]
246    pub value: ::core::option::Option<DoubleConstant>,
247    #[prost(string, optional, tag = "2")]
248    pub unit: ::core::option::Option<::prost::alloc::string::String>,
249}
250#[derive(Clone, PartialEq, ::prost::Message)]
251pub struct ResampleFill {
252    #[prost(oneof = "resample_fill::Kind", tags = "1, 2")]
253    pub kind: ::core::option::Option<resample_fill::Kind>,
254}
255/// Nested message and enum types in `ResampleFill`.
256pub mod resample_fill {
257    #[derive(Clone, PartialEq, ::prost::Oneof)]
258    pub enum Kind {
259        #[prost(message, tag = "1")]
260        ForwardFill(super::ForwardFillResample),
261        #[prost(message, tag = "2")]
262        Constant(super::DoubleConstant),
263    }
264}
265#[derive(Clone, Copy, PartialEq, ::prost::Message)]
266pub struct ForwardFillResample {}
267#[derive(Clone, PartialEq, ::prost::Message)]
268pub struct CategoricalReduction {
269    #[prost(oneof = "categorical_reduction::Kind", tags = "1, 2, 3")]
270    pub kind: ::core::option::Option<categorical_reduction::Kind>,
271}
272/// Nested message and enum types in `CategoricalReduction`.
273pub mod categorical_reduction {
274    #[derive(Clone, PartialEq, ::prost::Oneof)]
275    pub enum Kind {
276        #[prost(message, tag = "1")]
277        Min(super::CategoricalMinReduction),
278        #[prost(message, tag = "2")]
279        Max(super::CategoricalMaxReduction),
280        #[prost(message, tag = "3")]
281        Udf(super::super::super::modules::v1::UdfSource),
282    }
283}
284#[derive(Clone, Copy, PartialEq, ::prost::Message)]
285pub struct CategoricalMinReduction {}
286#[derive(Clone, Copy, PartialEq, ::prost::Message)]
287pub struct CategoricalMaxReduction {}
288#[derive(Clone, PartialEq, ::prost::Message)]
289pub struct CategoricalResampleFill {
290    #[prost(oneof = "categorical_resample_fill::Kind", tags = "1, 2")]
291    pub kind: ::core::option::Option<categorical_resample_fill::Kind>,
292}
293/// Nested message and enum types in `CategoricalResampleFill`.
294pub mod categorical_resample_fill {
295    #[derive(Clone, PartialEq, ::prost::Oneof)]
296    pub enum Kind {
297        #[prost(message, tag = "1")]
298        ForwardFill(super::ForwardFillResample),
299        #[prost(message, tag = "2")]
300        Constant(super::StringConstant),
301    }
302}
303#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
304#[repr(i32)]
305pub enum CategoricalMergeOperation {
306    Unspecified = 0,
307    RejectDuplicates = 1,
308    Max = 2,
309    Min = 3,
310}
311impl CategoricalMergeOperation {
312    /// String value of the enum field names used in the ProtoBuf definition.
313    ///
314    /// The values are not transformed in any way and thus are considered stable
315    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
316    pub fn as_str_name(&self) -> &'static str {
317        match self {
318            Self::Unspecified => "CATEGORICAL_MERGE_OPERATION_UNSPECIFIED",
319            Self::RejectDuplicates => "CATEGORICAL_MERGE_OPERATION_REJECT_DUPLICATES",
320            Self::Max => "CATEGORICAL_MERGE_OPERATION_MAX",
321            Self::Min => "CATEGORICAL_MERGE_OPERATION_MIN",
322        }
323    }
324    /// Creates an enum from field names used in the ProtoBuf definition.
325    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
326        match value {
327            "CATEGORICAL_MERGE_OPERATION_UNSPECIFIED" => Some(Self::Unspecified),
328            "CATEGORICAL_MERGE_OPERATION_REJECT_DUPLICATES" => {
329                Some(Self::RejectDuplicates)
330            }
331            "CATEGORICAL_MERGE_OPERATION_MAX" => Some(Self::Max),
332            "CATEGORICAL_MERGE_OPERATION_MIN" => Some(Self::Min),
333            _ => None,
334        }
335    }
336}
337#[derive(Clone, PartialEq, ::prost::Message)]
338pub struct DatasetReference {
339    #[prost(message, optional, tag = "1")]
340    pub name: ::core::option::Option<StringConstant>,
341}
342#[derive(Clone, PartialEq, ::prost::Message)]
343pub struct DurationExpression {
344    #[prost(oneof = "duration_expression::Kind", tags = "1, 2, 3, 4")]
345    pub kind: ::core::option::Option<duration_expression::Kind>,
346}
347/// Nested message and enum types in `DurationExpression`.
348pub mod duration_expression {
349    #[derive(Clone, PartialEq, ::prost::Oneof)]
350    pub enum Kind {
351        #[prost(string, tag = "1")]
352        VariableName(::prost::alloc::string::String),
353        #[prost(message, tag = "2")]
354        Amount(super::DurationAmount),
355        #[prost(message, tag = "3")]
356        Binary(::prost::alloc::boxed::Box<super::BinaryDurationExpression>),
357        #[prost(message, tag = "4")]
358        Negated(::prost::alloc::boxed::Box<super::DurationExpression>),
359    }
360}
361#[derive(Clone, PartialEq, ::prost::Message)]
362pub struct DurationAmount {
363    #[prost(message, optional, tag = "1")]
364    pub count: ::core::option::Option<IntegerConstant>,
365    #[prost(enumeration = "super::super::types::time::TimeUnit", tag = "2")]
366    pub unit: i32,
367}
368#[derive(Clone, PartialEq, ::prost::Message)]
369pub struct BinaryDurationExpression {
370    #[prost(enumeration = "DurationOperation", tag = "1")]
371    pub operation: i32,
372    #[prost(message, optional, boxed, tag = "2")]
373    pub left: ::core::option::Option<::prost::alloc::boxed::Box<DurationExpression>>,
374    #[prost(message, optional, boxed, tag = "3")]
375    pub right: ::core::option::Option<::prost::alloc::boxed::Box<DurationExpression>>,
376}
377#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
378#[repr(i32)]
379pub enum DurationOperation {
380    Unspecified = 0,
381    Add = 1,
382    Subtract = 2,
383}
384impl DurationOperation {
385    /// String value of the enum field names used in the ProtoBuf definition.
386    ///
387    /// The values are not transformed in any way and thus are considered stable
388    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
389    pub fn as_str_name(&self) -> &'static str {
390        match self {
391            Self::Unspecified => "DURATION_OPERATION_UNSPECIFIED",
392            Self::Add => "DURATION_OPERATION_ADD",
393            Self::Subtract => "DURATION_OPERATION_SUBTRACT",
394        }
395    }
396    /// Creates an enum from field names used in the ProtoBuf definition.
397    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
398        match value {
399            "DURATION_OPERATION_UNSPECIFIED" => Some(Self::Unspecified),
400            "DURATION_OPERATION_ADD" => Some(Self::Add),
401            "DURATION_OPERATION_SUBTRACT" => Some(Self::Subtract),
402            _ => None,
403        }
404    }
405}
406#[derive(Clone, PartialEq, ::prost::Message)]
407pub struct TagPredicateExpression {
408    #[prost(oneof = "tag_predicate_expression::Kind", tags = "1, 2, 3")]
409    pub kind: ::core::option::Option<tag_predicate_expression::Kind>,
410}
411/// Nested message and enum types in `TagPredicateExpression`.
412pub mod tag_predicate_expression {
413    #[derive(Clone, PartialEq, ::prost::Oneof)]
414    pub enum Kind {
415        #[prost(message, tag = "1")]
416        In(super::TagMembershipExpression),
417        #[prost(message, tag = "2")]
418        NotIn(super::TagMembershipExpression),
419        #[prost(message, tag = "3")]
420        And(::prost::alloc::boxed::Box<super::TagConjunctionExpression>),
421    }
422}
423#[derive(Clone, PartialEq, ::prost::Message)]
424pub struct TagMembershipExpression {
425    #[prost(message, optional, tag = "1")]
426    pub key: ::core::option::Option<StringConstant>,
427    #[prost(message, optional, tag = "2")]
428    pub values: ::core::option::Option<ParameterizedStringSet>,
429}
430#[derive(Clone, PartialEq, ::prost::Message)]
431pub struct TagConjunctionExpression {
432    #[prost(message, optional, boxed, tag = "1")]
433    pub left: ::core::option::Option<::prost::alloc::boxed::Box<TagPredicateExpression>>,
434    #[prost(message, optional, boxed, tag = "2")]
435    pub right: ::core::option::Option<
436        ::prost::alloc::boxed::Box<TagPredicateExpression>,
437    >,
438}
439#[derive(Clone, PartialEq, ::prost::Message)]
440pub struct TagKeySet {
441    #[prost(message, optional, tag = "1")]
442    pub keys: ::core::option::Option<ParameterizedStringSet>,
443}
444#[derive(Clone, PartialEq, ::prost::Message)]
445pub struct AssetReferenceExpression {
446    #[prost(oneof = "asset_reference_expression::Kind", tags = "1, 2")]
447    pub kind: ::core::option::Option<asset_reference_expression::Kind>,
448}
449/// Nested message and enum types in `AssetReferenceExpression`.
450pub mod asset_reference_expression {
451    #[derive(Clone, PartialEq, ::prost::Oneof)]
452    pub enum Kind {
453        #[prost(string, tag = "1")]
454        Literal(::prost::alloc::string::String),
455        #[prost(string, tag = "2")]
456        VariableName(::prost::alloc::string::String),
457    }
458}
459#[derive(Clone, PartialEq, ::prost::Message)]
460pub struct RunReferenceExpression {
461    #[prost(oneof = "run_reference_expression::Kind", tags = "1, 2")]
462    pub kind: ::core::option::Option<run_reference_expression::Kind>,
463}
464/// Nested message and enum types in `RunReferenceExpression`.
465pub mod run_reference_expression {
466    #[derive(Clone, PartialEq, ::prost::Oneof)]
467    pub enum Kind {
468        #[prost(string, tag = "1")]
469        Literal(::prost::alloc::string::String),
470        #[prost(string, tag = "2")]
471        VariableName(::prost::alloc::string::String),
472    }
473}
474#[derive(Clone, PartialEq, ::prost::Message)]
475pub struct DataSourceReferenceExpression {
476    #[prost(oneof = "data_source_reference_expression::Kind", tags = "1, 2")]
477    pub kind: ::core::option::Option<data_source_reference_expression::Kind>,
478}
479/// Nested message and enum types in `DataSourceReferenceExpression`.
480pub mod data_source_reference_expression {
481    #[derive(Clone, PartialEq, ::prost::Oneof)]
482    pub enum Kind {
483        #[prost(string, tag = "1")]
484        Literal(::prost::alloc::string::String),
485        #[prost(string, tag = "2")]
486        VariableName(::prost::alloc::string::String),
487    }
488}
489#[derive(Clone, PartialEq, ::prost::Message)]
490pub struct ResourceTypeReferenceExpression {
491    #[prost(oneof = "resource_type_reference_expression::Kind", tags = "1, 2")]
492    pub kind: ::core::option::Option<resource_type_reference_expression::Kind>,
493}
494/// Nested message and enum types in `ResourceTypeReferenceExpression`.
495pub mod resource_type_reference_expression {
496    #[derive(Clone, PartialEq, ::prost::Oneof)]
497    pub enum Kind {
498        #[prost(string, tag = "1")]
499        Literal(::prost::alloc::string::String),
500        #[prost(string, tag = "2")]
501        VariableName(::prost::alloc::string::String),
502    }
503}
504#[derive(Clone, PartialEq, ::prost::Message)]
505pub struct ChannelSelection {
506    #[prost(oneof = "channel_selection::Source", tags = "1, 2, 3")]
507    pub source: ::core::option::Option<channel_selection::Source>,
508}
509/// Nested message and enum types in `ChannelSelection`.
510pub mod channel_selection {
511    #[derive(Clone, PartialEq, ::prost::Oneof)]
512    pub enum Source {
513        #[prost(message, tag = "1")]
514        DataSource(super::DataSourceChannelSelection),
515        #[prost(message, tag = "2")]
516        Asset(super::AssetChannelSelection),
517        #[prost(message, tag = "3")]
518        Run(super::RunChannelSelection),
519    }
520}
521#[derive(Clone, PartialEq, ::prost::Message)]
522pub struct DataSourceChannelSelection {
523    #[prost(message, optional, tag = "1")]
524    pub data_source: ::core::option::Option<DataSourceReferenceExpression>,
525    #[prost(message, optional, tag = "2")]
526    pub channel: ::core::option::Option<StringConstant>,
527    #[prost(message, optional, tag = "3")]
528    pub tags: ::core::option::Option<ChannelTagConstraints>,
529    #[prost(message, optional, tag = "4")]
530    pub grouping_keys: ::core::option::Option<TagKeySet>,
531    #[prost(enumeration = "SeriesStorageEngine", optional, tag = "5")]
532    pub storage: ::core::option::Option<i32>,
533}
534#[derive(Clone, PartialEq, ::prost::Message)]
535pub struct AssetChannelSelection {
536    #[prost(message, optional, tag = "1")]
537    pub asset: ::core::option::Option<AssetReferenceExpression>,
538    #[prost(message, optional, tag = "2")]
539    pub data_scope: ::core::option::Option<StringConstant>,
540    #[prost(message, optional, tag = "3")]
541    pub channel: ::core::option::Option<StringConstant>,
542    #[prost(message, optional, tag = "4")]
543    pub tags: ::core::option::Option<ChannelTagConstraints>,
544    #[prost(message, optional, tag = "5")]
545    pub grouping_keys: ::core::option::Option<TagKeySet>,
546}
547#[derive(Clone, PartialEq, ::prost::Message)]
548pub struct RunChannelSelection {
549    #[prost(message, optional, tag = "1")]
550    pub run: ::core::option::Option<RunReferenceExpression>,
551    #[prost(message, optional, tag = "2")]
552    pub asset: ::core::option::Option<AssetReferenceExpression>,
553    #[prost(message, optional, tag = "3")]
554    pub data_scope: ::core::option::Option<StringConstant>,
555    #[prost(message, optional, tag = "4")]
556    pub channel: ::core::option::Option<StringConstant>,
557    #[prost(message, optional, tag = "5")]
558    pub tags: ::core::option::Option<ChannelTagConstraints>,
559    #[prost(message, optional, tag = "6")]
560    pub grouping_keys: ::core::option::Option<TagKeySet>,
561}
562#[derive(Clone, PartialEq, ::prost::Message)]
563pub struct ChannelTagConstraints {
564    #[prost(oneof = "channel_tag_constraints::Kind", tags = "1, 2")]
565    pub kind: ::core::option::Option<channel_tag_constraints::Kind>,
566}
567/// Nested message and enum types in `ChannelTagConstraints`.
568pub mod channel_tag_constraints {
569    #[derive(Clone, PartialEq, ::prost::Oneof)]
570    pub enum Kind {
571        #[prost(message, tag = "1")]
572        ExactValues(super::ExactTagValues),
573        #[prost(message, tag = "2")]
574        Predicate(super::TagPredicateExpression),
575    }
576}
577#[derive(Clone, PartialEq, ::prost::Message)]
578pub struct ExactTagValues {
579    #[prost(map = "string, message", tag = "1")]
580    pub values: ::std::collections::HashMap<
581        ::prost::alloc::string::String,
582        StringConstant,
583    >,
584}
585#[derive(Clone, PartialEq, ::prost::Message)]
586pub struct SeriesSampling {
587    #[prost(oneof = "series_sampling::Kind", tags = "1, 2")]
588    pub kind: ::core::option::Option<series_sampling::Kind>,
589}
590/// Nested message and enum types in `SeriesSampling`.
591pub mod series_sampling {
592    #[derive(Clone, PartialEq, ::prost::Oneof)]
593    pub enum Kind {
594        #[prost(message, tag = "1")]
595        EveryNthPerSeries(super::IntegerConstant),
596        #[prost(message, tag = "2")]
597        HashSubsample(super::IntegerConstant),
598    }
599}
600#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
601#[repr(i32)]
602pub enum SeriesStorageEngine {
603    Unspecified = 0,
604    Iceberg = 1,
605    Clickhouse = 2,
606}
607impl SeriesStorageEngine {
608    /// String value of the enum field names used in the ProtoBuf definition.
609    ///
610    /// The values are not transformed in any way and thus are considered stable
611    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
612    pub fn as_str_name(&self) -> &'static str {
613        match self {
614            Self::Unspecified => "SERIES_STORAGE_ENGINE_UNSPECIFIED",
615            Self::Iceberg => "SERIES_STORAGE_ENGINE_ICEBERG",
616            Self::Clickhouse => "SERIES_STORAGE_ENGINE_CLICKHOUSE",
617        }
618    }
619    /// Creates an enum from field names used in the ProtoBuf definition.
620    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
621        match value {
622            "SERIES_STORAGE_ENGINE_UNSPECIFIED" => Some(Self::Unspecified),
623            "SERIES_STORAGE_ENGINE_ICEBERG" => Some(Self::Iceberg),
624            "SERIES_STORAGE_ENGINE_CLICKHOUSE" => Some(Self::Clickhouse),
625            _ => None,
626        }
627    }
628}
629#[derive(Clone, PartialEq, ::prost::Message)]
630pub struct EventPredicateExpression {
631    #[prost(
632        oneof = "event_predicate_expression::Kind",
633        tags = "1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24"
634    )]
635    pub kind: ::core::option::Option<event_predicate_expression::Kind>,
636}
637/// Nested message and enum types in `EventPredicateExpression`.
638pub mod event_predicate_expression {
639    #[derive(Clone, PartialEq, ::prost::Oneof)]
640    pub enum Kind {
641        #[prost(message, tag = "1")]
642        SearchText(super::StringConstant),
643        #[prost(message, tag = "2")]
644        After(super::TimestampConstant),
645        #[prost(message, tag = "3")]
646        Before(super::TimestampConstant),
647        #[prost(message, tag = "4")]
648        TimestampCondition(super::EventTimestampCondition),
649        #[prost(message, tag = "5")]
650        Asset(super::AssetReferenceExpression),
651        #[prost(message, tag = "6")]
652        TemplateRid(super::StringConstant),
653        #[prost(message, tag = "7")]
654        WorkbookRid(super::StringConstant),
655        #[prost(message, tag = "8")]
656        DataReviewRid(super::StringConstant),
657        #[prost(
658            enumeration = "super::super::super::event::v2::SearchEventOriginType",
659            tag = "9"
660        )]
661        OriginType(i32),
662        #[prost(message, tag = "10")]
663        DataReviewCheckRid(super::StringConstant),
664        #[prost(
665            enumeration = "super::super::super::event::v2::EventDispositionStatus",
666            tag = "11"
667        )]
668        Disposition(i32),
669        #[prost(message, tag = "12")]
670        Priority(super::StringConstant),
671        #[prost(message, tag = "13")]
672        AssigneeRid(super::StringConstant),
673        #[prost(enumeration = "super::super::super::event::v2::EventType", tag = "14")]
674        EventType(i32),
675        #[prost(message, tag = "15")]
676        CreatedByRid(super::StringConstant),
677        #[prost(message, tag = "16")]
678        Label(super::StringConstant),
679        #[prost(message, tag = "17")]
680        Property(super::EventPropertyPredicate),
681        #[prost(message, tag = "18")]
682        All(super::EventPredicateGroup),
683        #[prost(message, tag = "19")]
684        Any(super::EventPredicateGroup),
685        #[prost(message, tag = "20")]
686        Negation(::prost::alloc::boxed::Box<super::EventPredicateExpression>),
687        #[prost(message, tag = "21")]
688        WorkspaceRid(super::StringConstant),
689        #[prost(message, tag = "22")]
690        ProcedureRid(super::StringConstant),
691        #[prost(message, tag = "23")]
692        ProcedureExecutionRid(super::StringConstant),
693        #[prost(message, tag = "24")]
694        StepId(super::StringConstant),
695    }
696}
697#[derive(Clone, PartialEq, ::prost::Message)]
698pub struct EventTimestampCondition {
699    #[prost(message, optional, tag = "1")]
700    pub timestamp: ::core::option::Option<TimestampConstant>,
701    #[prost(
702        enumeration = "super::super::event::v2::EventTimeFilterCondition",
703        tag = "2"
704    )]
705    pub condition: i32,
706}
707#[derive(Clone, PartialEq, ::prost::Message)]
708pub struct EventPropertyPredicate {
709    #[prost(message, optional, tag = "1")]
710    pub name: ::core::option::Option<StringConstant>,
711    #[prost(message, optional, tag = "2")]
712    pub value: ::core::option::Option<StringConstant>,
713}
714#[derive(Clone, PartialEq, ::prost::Message)]
715pub struct EventPredicateGroup {
716    #[prost(message, repeated, tag = "1")]
717    pub predicates: ::prost::alloc::vec::Vec<EventPredicateExpression>,
718}
719#[derive(Clone, PartialEq, ::prost::Message)]
720pub struct LogPredicate {
721    #[prost(oneof = "log_predicate::Kind", tags = "1, 2, 3, 4, 5, 6")]
722    pub kind: ::core::option::Option<log_predicate::Kind>,
723}
724/// Nested message and enum types in `LogPredicate`.
725pub mod log_predicate {
726    #[derive(Clone, PartialEq, ::prost::Oneof)]
727    pub enum Kind {
728        #[prost(string, tag = "1")]
729        MessageRegex(::prost::alloc::string::String),
730        #[prost(string, tag = "2")]
731        MessageContainsCaseInsensitive(::prost::alloc::string::String),
732        #[prost(message, tag = "3")]
733        AttributeRegex(super::LogAttributeRegex),
734        #[prost(message, tag = "4")]
735        All(super::LogPredicateGroup),
736        #[prost(message, tag = "5")]
737        Any(super::LogPredicateGroup),
738        #[prost(message, tag = "6")]
739        Negation(::prost::alloc::boxed::Box<super::LogPredicate>),
740    }
741}
742#[derive(Clone, PartialEq, ::prost::Message)]
743pub struct LogAttributeRegex {
744    #[prost(message, optional, tag = "1")]
745    pub key: ::core::option::Option<StringConstant>,
746    #[prost(string, tag = "2")]
747    pub regex: ::prost::alloc::string::String,
748}
749#[derive(Clone, PartialEq, ::prost::Message)]
750pub struct LogPredicateGroup {
751    #[prost(message, repeated, tag = "1")]
752    pub predicates: ::prost::alloc::vec::Vec<LogPredicate>,
753}
754#[derive(Clone, PartialEq, ::prost::Message)]
755pub struct NumericReduction {
756    #[prost(oneof = "numeric_reduction::Kind", tags = "1, 2, 3, 4, 5, 6, 7, 8, 9")]
757    pub kind: ::core::option::Option<numeric_reduction::Kind>,
758}
759/// Nested message and enum types in `NumericReduction`.
760pub mod numeric_reduction {
761    #[derive(Clone, PartialEq, ::prost::Oneof)]
762    pub enum Kind {
763        #[prost(message, tag = "1")]
764        Sum(super::SumReduction),
765        #[prost(message, tag = "2")]
766        Average(super::AverageReduction),
767        #[prost(message, tag = "3")]
768        Min(super::MinReduction),
769        #[prost(message, tag = "4")]
770        Max(super::MaxReduction),
771        #[prost(message, tag = "5")]
772        Count(super::CountReduction),
773        #[prost(message, tag = "6")]
774        StandardDeviation(super::StandardDeviationReduction),
775        #[prost(message, tag = "7")]
776        RootMeanSquare(super::RootMeanSquareReduction),
777        #[prost(message, tag = "8")]
778        Percentile(super::DoubleConstant),
779        #[prost(message, tag = "9")]
780        Udf(super::super::super::modules::v1::UdfSource),
781    }
782}
783#[derive(Clone, Copy, PartialEq, ::prost::Message)]
784pub struct SumReduction {}
785#[derive(Clone, Copy, PartialEq, ::prost::Message)]
786pub struct AverageReduction {}
787#[derive(Clone, Copy, PartialEq, ::prost::Message)]
788pub struct MinReduction {}
789#[derive(Clone, Copy, PartialEq, ::prost::Message)]
790pub struct MaxReduction {}
791#[derive(Clone, Copy, PartialEq, ::prost::Message)]
792pub struct CountReduction {}
793#[derive(Clone, Copy, PartialEq, ::prost::Message)]
794pub struct StandardDeviationReduction {}
795#[derive(Clone, Copy, PartialEq, ::prost::Message)]
796pub struct RootMeanSquareReduction {}
797#[derive(Clone, PartialEq, ::prost::Message)]
798pub struct DurationInput {
799    #[prost(oneof = "duration_input::Kind", tags = "1, 2")]
800    pub kind: ::core::option::Option<duration_input::Kind>,
801}
802/// Nested message and enum types in `DurationInput`.
803pub mod duration_input {
804    #[derive(Clone, PartialEq, ::prost::Oneof)]
805    pub enum Kind {
806        #[prost(message, tag = "1")]
807        Components(super::DurationConstant),
808        #[prost(message, tag = "2")]
809        Arithmetic(super::DurationExpression),
810    }
811}
812#[derive(Clone, PartialEq, ::prost::Message)]
813pub struct RangePersistence {
814    #[prost(message, optional, tag = "1")]
815    pub min_points: ::core::option::Option<IntegerConstant>,
816    #[prost(message, optional, tag = "2")]
817    pub min_duration: ::core::option::Option<DurationInput>,
818    #[prost(enumeration = "RangeStartSelection", optional, tag = "3")]
819    pub start: ::core::option::Option<i32>,
820}
821#[derive(Clone, PartialEq, ::prost::Message)]
822pub struct SpreadThreshold {
823    #[prost(oneof = "spread_threshold::Kind", tags = "1, 2")]
824    pub kind: ::core::option::Option<spread_threshold::Kind>,
825}
826/// Nested message and enum types in `SpreadThreshold`.
827pub mod spread_threshold {
828    #[derive(Clone, PartialEq, ::prost::Oneof)]
829    pub enum Kind {
830        #[prost(message, tag = "1")]
831        Absolute(super::DoubleConstant),
832        #[prost(message, tag = "2")]
833        Percentage(super::DoubleConstant),
834    }
835}
836#[derive(Clone, PartialEq, ::prost::Message)]
837pub struct TagGrouping {
838    #[prost(map = "string, string", tag = "1")]
839    pub tags: ::std::collections::HashMap<
840        ::prost::alloc::string::String,
841        ::prost::alloc::string::String,
842    >,
843}
844#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
845#[repr(i32)]
846pub enum RangeStartSelection {
847    Unspecified = 0,
848    ConditionStart = 1,
849    PersistenceStart = 2,
850}
851impl RangeStartSelection {
852    /// String value of the enum field names used in the ProtoBuf definition.
853    ///
854    /// The values are not transformed in any way and thus are considered stable
855    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
856    pub fn as_str_name(&self) -> &'static str {
857        match self {
858            Self::Unspecified => "RANGE_START_SELECTION_UNSPECIFIED",
859            Self::ConditionStart => "RANGE_START_SELECTION_CONDITION_START",
860            Self::PersistenceStart => "RANGE_START_SELECTION_PERSISTENCE_START",
861        }
862    }
863    /// Creates an enum from field names used in the ProtoBuf definition.
864    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
865        match value {
866            "RANGE_START_SELECTION_UNSPECIFIED" => Some(Self::Unspecified),
867            "RANGE_START_SELECTION_CONDITION_START" => Some(Self::ConditionStart),
868            "RANGE_START_SELECTION_PERSISTENCE_START" => Some(Self::PersistenceStart),
869            _ => None,
870        }
871    }
872}
873#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
874#[repr(i32)]
875pub enum UnboundedDurationComparison {
876    Unspecified = 0,
877    Infinity = 1,
878    WindowBound = 2,
879}
880impl UnboundedDurationComparison {
881    /// String value of the enum field names used in the ProtoBuf definition.
882    ///
883    /// The values are not transformed in any way and thus are considered stable
884    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
885    pub fn as_str_name(&self) -> &'static str {
886        match self {
887            Self::Unspecified => "UNBOUNDED_DURATION_COMPARISON_UNSPECIFIED",
888            Self::Infinity => "UNBOUNDED_DURATION_COMPARISON_INFINITY",
889            Self::WindowBound => "UNBOUNDED_DURATION_COMPARISON_WINDOW_BOUND",
890        }
891    }
892    /// Creates an enum from field names used in the ProtoBuf definition.
893    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
894        match value {
895            "UNBOUNDED_DURATION_COMPARISON_UNSPECIFIED" => Some(Self::Unspecified),
896            "UNBOUNDED_DURATION_COMPARISON_INFINITY" => Some(Self::Infinity),
897            "UNBOUNDED_DURATION_COMPARISON_WINDOW_BOUND" => Some(Self::WindowBound),
898            _ => None,
899        }
900    }
901}
902#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
903#[repr(i32)]
904pub enum NumericBoundsCondition {
905    Unspecified = 0,
906    Outside = 1,
907    OutsideOrEqual = 2,
908    Inside = 3,
909    InsideOrEqual = 4,
910}
911impl NumericBoundsCondition {
912    /// String value of the enum field names used in the ProtoBuf definition.
913    ///
914    /// The values are not transformed in any way and thus are considered stable
915    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
916    pub fn as_str_name(&self) -> &'static str {
917        match self {
918            Self::Unspecified => "NUMERIC_BOUNDS_CONDITION_UNSPECIFIED",
919            Self::Outside => "NUMERIC_BOUNDS_CONDITION_OUTSIDE",
920            Self::OutsideOrEqual => "NUMERIC_BOUNDS_CONDITION_OUTSIDE_OR_EQUAL",
921            Self::Inside => "NUMERIC_BOUNDS_CONDITION_INSIDE",
922            Self::InsideOrEqual => "NUMERIC_BOUNDS_CONDITION_INSIDE_OR_EQUAL",
923        }
924    }
925    /// Creates an enum from field names used in the ProtoBuf definition.
926    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
927        match value {
928            "NUMERIC_BOUNDS_CONDITION_UNSPECIFIED" => Some(Self::Unspecified),
929            "NUMERIC_BOUNDS_CONDITION_OUTSIDE" => Some(Self::Outside),
930            "NUMERIC_BOUNDS_CONDITION_OUTSIDE_OR_EQUAL" => Some(Self::OutsideOrEqual),
931            "NUMERIC_BOUNDS_CONDITION_INSIDE" => Some(Self::Inside),
932            "NUMERIC_BOUNDS_CONDITION_INSIDE_OR_EQUAL" => Some(Self::InsideOrEqual),
933            _ => None,
934        }
935    }
936}
937#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
938#[repr(i32)]
939pub enum SeriesEqualityMode {
940    Unspecified = 0,
941    AllEqual = 1,
942    NotAllEqual = 2,
943}
944impl SeriesEqualityMode {
945    /// String value of the enum field names used in the ProtoBuf definition.
946    ///
947    /// The values are not transformed in any way and thus are considered stable
948    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
949    pub fn as_str_name(&self) -> &'static str {
950        match self {
951            Self::Unspecified => "SERIES_EQUALITY_MODE_UNSPECIFIED",
952            Self::AllEqual => "SERIES_EQUALITY_MODE_ALL_EQUAL",
953            Self::NotAllEqual => "SERIES_EQUALITY_MODE_NOT_ALL_EQUAL",
954        }
955    }
956    /// Creates an enum from field names used in the ProtoBuf definition.
957    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
958        match value {
959            "SERIES_EQUALITY_MODE_UNSPECIFIED" => Some(Self::Unspecified),
960            "SERIES_EQUALITY_MODE_ALL_EQUAL" => Some(Self::AllEqual),
961            "SERIES_EQUALITY_MODE_NOT_ALL_EQUAL" => Some(Self::NotAllEqual),
962            _ => None,
963        }
964    }
965}
966#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
967#[repr(i32)]
968pub enum CategoricalMembershipOperation {
969    Unspecified = 0,
970    In = 1,
971    NotIn = 2,
972    MatchesAnyRegex = 3,
973}
974impl CategoricalMembershipOperation {
975    /// String value of the enum field names used in the ProtoBuf definition.
976    ///
977    /// The values are not transformed in any way and thus are considered stable
978    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
979    pub fn as_str_name(&self) -> &'static str {
980        match self {
981            Self::Unspecified => "CATEGORICAL_MEMBERSHIP_OPERATION_UNSPECIFIED",
982            Self::In => "CATEGORICAL_MEMBERSHIP_OPERATION_IN",
983            Self::NotIn => "CATEGORICAL_MEMBERSHIP_OPERATION_NOT_IN",
984            Self::MatchesAnyRegex => "CATEGORICAL_MEMBERSHIP_OPERATION_MATCHES_ANY_REGEX",
985        }
986    }
987    /// Creates an enum from field names used in the ProtoBuf definition.
988    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
989        match value {
990            "CATEGORICAL_MEMBERSHIP_OPERATION_UNSPECIFIED" => Some(Self::Unspecified),
991            "CATEGORICAL_MEMBERSHIP_OPERATION_IN" => Some(Self::In),
992            "CATEGORICAL_MEMBERSHIP_OPERATION_NOT_IN" => Some(Self::NotIn),
993            "CATEGORICAL_MEMBERSHIP_OPERATION_MATCHES_ANY_REGEX" => {
994                Some(Self::MatchesAnyRegex)
995            }
996            _ => None,
997        }
998    }
999}
1000#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
1001#[repr(i32)]
1002pub enum ExtremaSelection {
1003    Unspecified = 0,
1004    Peaks = 1,
1005    Troughs = 2,
1006    Both = 3,
1007}
1008impl ExtremaSelection {
1009    /// String value of the enum field names used in the ProtoBuf definition.
1010    ///
1011    /// The values are not transformed in any way and thus are considered stable
1012    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
1013    pub fn as_str_name(&self) -> &'static str {
1014        match self {
1015            Self::Unspecified => "EXTREMA_SELECTION_UNSPECIFIED",
1016            Self::Peaks => "EXTREMA_SELECTION_PEAKS",
1017            Self::Troughs => "EXTREMA_SELECTION_TROUGHS",
1018            Self::Both => "EXTREMA_SELECTION_BOTH",
1019        }
1020    }
1021    /// Creates an enum from field names used in the ProtoBuf definition.
1022    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
1023        match value {
1024            "EXTREMA_SELECTION_UNSPECIFIED" => Some(Self::Unspecified),
1025            "EXTREMA_SELECTION_PEAKS" => Some(Self::Peaks),
1026            "EXTREMA_SELECTION_TROUGHS" => Some(Self::Troughs),
1027            "EXTREMA_SELECTION_BOTH" => Some(Self::Both),
1028            _ => None,
1029        }
1030    }
1031}
1032#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
1033#[repr(i32)]
1034pub enum RangePaddingSides {
1035    Unspecified = 0,
1036    Start = 1,
1037    End = 2,
1038    Both = 3,
1039}
1040impl RangePaddingSides {
1041    /// String value of the enum field names used in the ProtoBuf definition.
1042    ///
1043    /// The values are not transformed in any way and thus are considered stable
1044    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
1045    pub fn as_str_name(&self) -> &'static str {
1046        match self {
1047            Self::Unspecified => "RANGE_PADDING_SIDES_UNSPECIFIED",
1048            Self::Start => "RANGE_PADDING_SIDES_START",
1049            Self::End => "RANGE_PADDING_SIDES_END",
1050            Self::Both => "RANGE_PADDING_SIDES_BOTH",
1051        }
1052    }
1053    /// Creates an enum from field names used in the ProtoBuf definition.
1054    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
1055        match value {
1056            "RANGE_PADDING_SIDES_UNSPECIFIED" => Some(Self::Unspecified),
1057            "RANGE_PADDING_SIDES_START" => Some(Self::Start),
1058            "RANGE_PADDING_SIDES_END" => Some(Self::End),
1059            "RANGE_PADDING_SIDES_BOTH" => Some(Self::Both),
1060            _ => None,
1061        }
1062    }
1063}
1064#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
1065#[repr(i32)]
1066pub enum RefpropSubstance {
1067    Unspecified = 0,
1068    Nitrogen = 1,
1069    Oxygen = 2,
1070    Helium = 3,
1071    Hydrogen = 4,
1072    Methane = 5,
1073    Propane = 6,
1074    Butane = 7,
1075    Water = 8,
1076    Xenon = 9,
1077    Air = 10,
1078    CarbonDioxide = 11,
1079    Argon = 12,
1080    CarbonMonoxide = 13,
1081    JetA4658 = 14,
1082    JetA3638 = 15,
1083}
1084impl RefpropSubstance {
1085    /// String value of the enum field names used in the ProtoBuf definition.
1086    ///
1087    /// The values are not transformed in any way and thus are considered stable
1088    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
1089    pub fn as_str_name(&self) -> &'static str {
1090        match self {
1091            Self::Unspecified => "REFPROP_SUBSTANCE_UNSPECIFIED",
1092            Self::Nitrogen => "REFPROP_SUBSTANCE_NITROGEN",
1093            Self::Oxygen => "REFPROP_SUBSTANCE_OXYGEN",
1094            Self::Helium => "REFPROP_SUBSTANCE_HELIUM",
1095            Self::Hydrogen => "REFPROP_SUBSTANCE_HYDROGEN",
1096            Self::Methane => "REFPROP_SUBSTANCE_METHANE",
1097            Self::Propane => "REFPROP_SUBSTANCE_PROPANE",
1098            Self::Butane => "REFPROP_SUBSTANCE_BUTANE",
1099            Self::Water => "REFPROP_SUBSTANCE_WATER",
1100            Self::Xenon => "REFPROP_SUBSTANCE_XENON",
1101            Self::Air => "REFPROP_SUBSTANCE_AIR",
1102            Self::CarbonDioxide => "REFPROP_SUBSTANCE_CARBON_DIOXIDE",
1103            Self::Argon => "REFPROP_SUBSTANCE_ARGON",
1104            Self::CarbonMonoxide => "REFPROP_SUBSTANCE_CARBON_MONOXIDE",
1105            Self::JetA4658 => "REFPROP_SUBSTANCE_JET_A_4658",
1106            Self::JetA3638 => "REFPROP_SUBSTANCE_JET_A_3638",
1107        }
1108    }
1109    /// Creates an enum from field names used in the ProtoBuf definition.
1110    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
1111        match value {
1112            "REFPROP_SUBSTANCE_UNSPECIFIED" => Some(Self::Unspecified),
1113            "REFPROP_SUBSTANCE_NITROGEN" => Some(Self::Nitrogen),
1114            "REFPROP_SUBSTANCE_OXYGEN" => Some(Self::Oxygen),
1115            "REFPROP_SUBSTANCE_HELIUM" => Some(Self::Helium),
1116            "REFPROP_SUBSTANCE_HYDROGEN" => Some(Self::Hydrogen),
1117            "REFPROP_SUBSTANCE_METHANE" => Some(Self::Methane),
1118            "REFPROP_SUBSTANCE_PROPANE" => Some(Self::Propane),
1119            "REFPROP_SUBSTANCE_BUTANE" => Some(Self::Butane),
1120            "REFPROP_SUBSTANCE_WATER" => Some(Self::Water),
1121            "REFPROP_SUBSTANCE_XENON" => Some(Self::Xenon),
1122            "REFPROP_SUBSTANCE_AIR" => Some(Self::Air),
1123            "REFPROP_SUBSTANCE_CARBON_DIOXIDE" => Some(Self::CarbonDioxide),
1124            "REFPROP_SUBSTANCE_ARGON" => Some(Self::Argon),
1125            "REFPROP_SUBSTANCE_CARBON_MONOXIDE" => Some(Self::CarbonMonoxide),
1126            "REFPROP_SUBSTANCE_JET_A_4658" => Some(Self::JetA4658),
1127            "REFPROP_SUBSTANCE_JET_A_3638" => Some(Self::JetA3638),
1128            _ => None,
1129        }
1130    }
1131}
1132#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
1133#[repr(i32)]
1134pub enum RefpropProperty {
1135    Unspecified = 0,
1136    Temperature = 1,
1137    Pressure = 2,
1138    MassDensity = 3,
1139    MassSpecificEnthalpy = 4,
1140    MassSpecificInternalEnergy = 5,
1141    MassSpecificEntropy = 6,
1142    Viscosity = 7,
1143}
1144impl RefpropProperty {
1145    /// String value of the enum field names used in the ProtoBuf definition.
1146    ///
1147    /// The values are not transformed in any way and thus are considered stable
1148    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
1149    pub fn as_str_name(&self) -> &'static str {
1150        match self {
1151            Self::Unspecified => "REFPROP_PROPERTY_UNSPECIFIED",
1152            Self::Temperature => "REFPROP_PROPERTY_TEMPERATURE",
1153            Self::Pressure => "REFPROP_PROPERTY_PRESSURE",
1154            Self::MassDensity => "REFPROP_PROPERTY_MASS_DENSITY",
1155            Self::MassSpecificEnthalpy => "REFPROP_PROPERTY_MASS_SPECIFIC_ENTHALPY",
1156            Self::MassSpecificInternalEnergy => {
1157                "REFPROP_PROPERTY_MASS_SPECIFIC_INTERNAL_ENERGY"
1158            }
1159            Self::MassSpecificEntropy => "REFPROP_PROPERTY_MASS_SPECIFIC_ENTROPY",
1160            Self::Viscosity => "REFPROP_PROPERTY_VISCOSITY",
1161        }
1162    }
1163    /// Creates an enum from field names used in the ProtoBuf definition.
1164    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
1165        match value {
1166            "REFPROP_PROPERTY_UNSPECIFIED" => Some(Self::Unspecified),
1167            "REFPROP_PROPERTY_TEMPERATURE" => Some(Self::Temperature),
1168            "REFPROP_PROPERTY_PRESSURE" => Some(Self::Pressure),
1169            "REFPROP_PROPERTY_MASS_DENSITY" => Some(Self::MassDensity),
1170            "REFPROP_PROPERTY_MASS_SPECIFIC_ENTHALPY" => Some(Self::MassSpecificEnthalpy),
1171            "REFPROP_PROPERTY_MASS_SPECIFIC_INTERNAL_ENERGY" => {
1172                Some(Self::MassSpecificInternalEnergy)
1173            }
1174            "REFPROP_PROPERTY_MASS_SPECIFIC_ENTROPY" => Some(Self::MassSpecificEntropy),
1175            "REFPROP_PROPERTY_VISCOSITY" => Some(Self::Viscosity),
1176            _ => None,
1177        }
1178    }
1179}
1180#[derive(Clone, PartialEq, ::prost::Message)]
1181pub struct ResourcePredicate {
1182    #[prost(oneof = "resource_predicate::Kind", tags = "1, 2, 3, 4, 5, 6, 7, 8")]
1183    pub kind: ::core::option::Option<resource_predicate::Kind>,
1184}
1185/// Nested message and enum types in `ResourcePredicate`.
1186pub mod resource_predicate {
1187    #[derive(Clone, PartialEq, ::prost::Oneof)]
1188    pub enum Kind {
1189        #[prost(message, tag = "1")]
1190        Properties(super::super::super::types::PropertiesFilter),
1191        #[prost(message, tag = "2")]
1192        NumericProperty(super::super::super::types::NumericPropertyPredicate),
1193        #[prost(message, tag = "3")]
1194        NumericPropertyRange(super::super::super::types::NumericPropertyRangePredicate),
1195        #[prost(message, tag = "4")]
1196        Labels(super::super::super::types::LabelsFilter),
1197        #[prost(message, tag = "5")]
1198        Workspace(super::StringConstant),
1199        #[prost(message, tag = "6")]
1200        All(super::ResourcePredicateGroup),
1201        #[prost(message, tag = "7")]
1202        Any(super::ResourcePredicateGroup),
1203        #[prost(message, tag = "8")]
1204        Negation(::prost::alloc::boxed::Box<super::ResourcePredicate>),
1205    }
1206}
1207#[derive(Clone, PartialEq, ::prost::Message)]
1208pub struct ResourcePredicateGroup {
1209    #[prost(message, repeated, tag = "1")]
1210    pub predicates: ::prost::alloc::vec::Vec<ResourcePredicate>,
1211}
1212#[derive(Clone, PartialEq, ::prost::Message)]
1213pub struct DatasetResourceSearch {
1214    #[prost(int32, optional, tag = "3")]
1215    pub max_results: ::core::option::Option<i32>,
1216    #[prost(oneof = "dataset_resource_search::Target", tags = "1, 2")]
1217    pub target: ::core::option::Option<dataset_resource_search::Target>,
1218}
1219/// Nested message and enum types in `DatasetResourceSearch`.
1220pub mod dataset_resource_search {
1221    #[derive(Clone, PartialEq, ::prost::Oneof)]
1222    pub enum Target {
1223        #[prost(message, tag = "1")]
1224        Assets(super::ResourcePredicate),
1225        #[prost(message, tag = "2")]
1226        Runs(super::ResourcePredicate),
1227    }
1228}
1229#[derive(Clone, PartialEq, ::prost::Message)]
1230pub struct SignalFilterConfiguration {
1231    #[prost(oneof = "signal_filter_configuration::Kind", tags = "1, 2, 3, 4")]
1232    pub kind: ::core::option::Option<signal_filter_configuration::Kind>,
1233}
1234/// Nested message and enum types in `SignalFilterConfiguration`.
1235pub mod signal_filter_configuration {
1236    #[derive(Clone, PartialEq, ::prost::Oneof)]
1237    pub enum Kind {
1238        #[prost(message, tag = "1")]
1239        LowPass(super::SingleCutoffFilter),
1240        #[prost(message, tag = "2")]
1241        HighPass(super::SingleCutoffFilter),
1242        #[prost(message, tag = "3")]
1243        BandPass(super::FrequencyBandFilter),
1244        #[prost(message, tag = "4")]
1245        BandStop(super::FrequencyBandFilter),
1246    }
1247}
1248#[derive(Clone, PartialEq, ::prost::Message)]
1249pub struct SingleCutoffFilter {
1250    #[prost(message, optional, tag = "1")]
1251    pub cutoff_frequency: ::core::option::Option<DoubleConstant>,
1252}
1253#[derive(Clone, PartialEq, ::prost::Message)]
1254pub struct FrequencyBandFilter {
1255    #[prost(message, optional, tag = "1")]
1256    pub lower_frequency: ::core::option::Option<DoubleConstant>,
1257    #[prost(message, optional, tag = "2")]
1258    pub upper_frequency: ::core::option::Option<DoubleConstant>,
1259}
1260#[derive(Clone, PartialEq, ::prost::Message)]
1261pub struct NumericExpression {
1262    #[prost(
1263        oneof = "numeric_expression::Kind",
1264        tags = "1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 57, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56"
1265    )]
1266    pub kind: ::core::option::Option<numeric_expression::Kind>,
1267}
1268/// Nested message and enum types in `NumericExpression`.
1269pub mod numeric_expression {
1270    #[derive(Clone, PartialEq, ::prost::Oneof)]
1271    pub enum Kind {
1272        #[prost(message, tag = "1")]
1273        Reference(super::TimeSeriesReference),
1274        #[prost(message, tag = "2")]
1275        Constant(super::DoubleConstant),
1276        #[prost(message, tag = "3")]
1277        Unary(::prost::alloc::boxed::Box<super::NumericUnaryExpression>),
1278        #[prost(message, tag = "4")]
1279        Binary(::prost::alloc::boxed::Box<super::NumericBinaryExpression>),
1280        #[prost(message, tag = "5")]
1281        Nary(super::NumericNaryExpression),
1282        #[prost(message, tag = "6")]
1283        Bitwise(::prost::alloc::boxed::Box<super::NumericBitwiseExpression>),
1284        #[prost(message, tag = "7")]
1285        Conditional(::prost::alloc::boxed::Box<super::NumericConditionalExpression>),
1286        #[prost(message, tag = "8")]
1287        CumulativeSum(::prost::alloc::boxed::Box<super::NumericCumulativeSumExpression>),
1288        #[prost(message, tag = "9")]
1289        Derivative(::prost::alloc::boxed::Box<super::NumericDerivativeExpression>),
1290        #[prost(message, tag = "10")]
1291        Integral(::prost::alloc::boxed::Box<super::NumericIntegralExpression>),
1292        #[prost(message, tag = "11")]
1293        TimeRangeFilter(
1294            ::prost::alloc::boxed::Box<super::NumericTimeRangeFilterExpression>,
1295        ),
1296        #[prost(message, tag = "12")]
1297        TimeShift(::prost::alloc::boxed::Box<super::NumericTimeShiftExpression>),
1298        #[prost(message, tag = "13")]
1299        ValueDifference(
1300            ::prost::alloc::boxed::Box<super::NumericValueDifferenceExpression>,
1301        ),
1302        #[prost(message, tag = "14")]
1303        PhaseUnwrap(::prost::alloc::boxed::Box<super::NumericPhaseUnwrapExpression>),
1304        #[prost(message, tag = "15")]
1305        PointLimit(::prost::alloc::boxed::Box<super::NumericPointLimitExpression>),
1306        #[prost(message, tag = "16")]
1307        NthPointDownsample(
1308            ::prost::alloc::boxed::Box<super::NumericNthPointDownsampleExpression>,
1309        ),
1310        #[prost(message, tag = "17")]
1311        LargestTriangleThreeBuckets(
1312            ::prost::alloc::boxed::Box<
1313                super::NumericLargestTriangleThreeBucketsExpression,
1314            >,
1315        ),
1316        #[prost(message, tag = "18")]
1317        ConditionFilter(
1318            ::prost::alloc::boxed::Box<super::NumericConditionFilterExpression>,
1319        ),
1320        #[prost(message, tag = "19")]
1321        ThresholdFilter(
1322            ::prost::alloc::boxed::Box<super::NumericThresholdFilterExpression>,
1323        ),
1324        #[prost(message, tag = "57")]
1325        DropNan(::prost::alloc::boxed::Box<super::NumericDropNanExpression>),
1326        #[prost(message, tag = "20")]
1327        ApproximateFilter(
1328            ::prost::alloc::boxed::Box<super::NumericApproximateFilterExpression>,
1329        ),
1330        #[prost(message, tag = "21")]
1331        SignalFilter(::prost::alloc::boxed::Box<super::NumericSignalFilterExpression>),
1332        #[prost(message, tag = "22")]
1333        UnitConversion(
1334            ::prost::alloc::boxed::Box<super::NumericUnitConversionExpression>,
1335        ),
1336        #[prost(message, tag = "23")]
1337        UnitOverride(::prost::alloc::boxed::Box<super::NumericUnitOverrideExpression>),
1338        #[prost(message, tag = "24")]
1339        ZScore(::prost::alloc::boxed::Box<super::NumericZScoreExpression>),
1340        #[prost(message, tag = "25")]
1341        Union(super::NumericUnionExpression),
1342        #[prost(message, tag = "26")]
1343        TimeShiftV2(::prost::alloc::boxed::Box<super::NumericTimeShiftV2Expression>),
1344        #[prost(message, tag = "27")]
1345        ResampleV2(::prost::alloc::boxed::Box<super::NumericResampleV2Expression>),
1346        #[prost(message, tag = "28")]
1347        ToStartOfInterval(
1348            ::prost::alloc::boxed::Box<super::NumericToStartOfIntervalExpression>,
1349        ),
1350        #[prost(message, tag = "29")]
1351        ScalarTransform(
1352            ::prost::alloc::boxed::Box<super::NumericScalarTransformExpression>,
1353        ),
1354        #[prost(message, tag = "30")]
1355        Arithmetic(super::NumericArithmeticExpression),
1356        #[prost(message, tag = "31")]
1357        FormulaFilter(super::NumericFormulaFilterExpression),
1358        #[prost(message, tag = "32")]
1359        LiteralBitwise(
1360            ::prost::alloc::boxed::Box<super::NumericLiteralBitwiseExpression>,
1361        ),
1362        #[prost(message, tag = "33")]
1363        Resample(::prost::alloc::boxed::Box<super::NumericResampleExpression>),
1364        #[prost(message, tag = "34")]
1365        Refprop(super::NumericRefpropExpression),
1366        #[prost(message, tag = "35")]
1367        RollingAggregation(
1368            ::prost::alloc::boxed::Box<super::NumericRollingAggregationExpression>,
1369        ),
1370        #[prost(message, tag = "36")]
1371        DuplicateTimestampAggregation(
1372            ::prost::alloc::boxed::Box<
1373                super::NumericDuplicateTimestampAggregationExpression,
1374            >,
1375        ),
1376        #[prost(message, tag = "37")]
1377        TagFilter(::prost::alloc::boxed::Box<super::NumericTagFilterExpression>),
1378        #[prost(message, tag = "38")]
1379        TagSelection(::prost::alloc::boxed::Box<super::NumericTagSelectionExpression>),
1380        #[prost(message, tag = "39")]
1381        AbsoluteTimestamp(
1382            ::prost::alloc::boxed::Box<super::NumericAbsoluteTimestampExpression>,
1383        ),
1384        #[prost(message, tag = "40")]
1385        ReduceUnderRanges(
1386            ::prost::alloc::boxed::Box<super::NumericReduceUnderRangesExpression>,
1387        ),
1388        #[prost(message, tag = "41")]
1389        ChannelSelection(super::ChannelSelection),
1390        #[prost(message, tag = "42")]
1391        LogMatches(::prost::alloc::boxed::Box<super::NumericLogMatchesExpression>),
1392        #[prost(message, tag = "43")]
1393        CountDuplicates(super::NumericCountDuplicatesExpression),
1394        #[prost(message, tag = "44")]
1395        ModuleFunction(super::ModuleFunctionExpression),
1396        #[prost(message, tag = "45")]
1397        CategoricalMapping(
1398            ::prost::alloc::boxed::Box<super::NumericCategoricalMappingExpression>,
1399        ),
1400        #[prost(message, tag = "46")]
1401        StructField(::prost::alloc::boxed::Box<super::NumericStructFieldExpression>),
1402        #[prost(message, tag = "47")]
1403        RangeFilter(::prost::alloc::boxed::Box<super::NumericRangeFilterExpression>),
1404        #[prost(message, tag = "48")]
1405        GroupWithinRanges(
1406            ::prost::alloc::boxed::Box<super::NumericGroupWithinRangesExpression>,
1407        ),
1408        #[prost(message, tag = "49")]
1409        Aggregation(::prost::alloc::boxed::Box<super::NumericAggregationExpression>),
1410        #[prost(message, tag = "50")]
1411        RangeDuration(::prost::alloc::boxed::Box<super::NumericRangeDurationExpression>),
1412        #[prost(message, tag = "51")]
1413        ScalarUdf(super::ScalarUdfExpression),
1414        #[prost(message, tag = "52")]
1415        ArrayIndex(::prost::alloc::boxed::Box<super::NumericArrayIndexExpression>),
1416        #[prost(message, tag = "53")]
1417        SeriesSelection(::prost::alloc::boxed::Box<super::SeriesSelection>),
1418        #[prost(message, tag = "54")]
1419        ResourceProperty(::prost::alloc::boxed::Box<super::ResourcePropertySelection>),
1420        #[prost(message, tag = "55")]
1421        IntervalTags(::prost::alloc::boxed::Box<super::NumericIntervalTagsExpression>),
1422        #[prost(message, tag = "56")]
1423        TimeDifference(
1424            ::prost::alloc::boxed::Box<super::NumericTimeDifferenceExpression>,
1425        ),
1426    }
1427}
1428#[derive(Clone, PartialEq, ::prost::Message)]
1429pub struct ComputeContext {
1430    #[prost(map = "string, message", tag = "1")]
1431    pub variables: ::std::collections::HashMap<
1432        ::prost::alloc::string::String,
1433        VariableValue,
1434    >,
1435    #[prost(map = "string, message", tag = "2")]
1436    pub datasets: ::std::collections::HashMap<
1437        ::prost::alloc::string::String,
1438        DatasetExpression,
1439    >,
1440    #[prost(message, optional, tag = "3")]
1441    pub default_fill: ::core::option::Option<ComputeFillStrategy>,
1442    #[prost(enumeration = "ComputeAlignmentStrategy", optional, tag = "4")]
1443    pub default_alignment: ::core::option::Option<i32>,
1444    #[prost(bool, optional, tag = "5")]
1445    pub apply_data_scope_offsets: ::core::option::Option<bool>,
1446    #[prost(bool, optional, tag = "6")]
1447    pub resolve_assets_through_datasets: ::core::option::Option<bool>,
1448}
1449#[derive(Clone, PartialEq, ::prost::Message)]
1450pub struct ComputeFillStrategy {
1451    #[prost(oneof = "compute_fill_strategy::Kind", tags = "1")]
1452    pub kind: ::core::option::Option<compute_fill_strategy::Kind>,
1453}
1454/// Nested message and enum types in `ComputeFillStrategy`.
1455pub mod compute_fill_strategy {
1456    #[derive(Clone, PartialEq, ::prost::Oneof)]
1457    pub enum Kind {
1458        #[prost(message, tag = "1")]
1459        ForwardFill(super::DurationConstant),
1460    }
1461}
1462#[derive(Clone, PartialEq, ::prost::Message)]
1463pub struct VariableValue {
1464    #[prost(oneof = "variable_value::Kind", tags = "1, 2, 3, 4, 5, 6, 7, 8, 9, 10")]
1465    pub kind: ::core::option::Option<variable_value::Kind>,
1466}
1467/// Nested message and enum types in `VariableValue`.
1468pub mod variable_value {
1469    #[derive(Clone, PartialEq, ::prost::Oneof)]
1470    pub enum Kind {
1471        #[prost(double, tag = "1")]
1472        DoubleValue(f64),
1473        #[prost(int32, tag = "2")]
1474        IntegerValue(i32),
1475        #[prost(string, tag = "3")]
1476        StringValue(::prost::alloc::string::String),
1477        #[prost(message, tag = "4")]
1478        StringSet(super::StringSetLiteral),
1479        #[prost(message, tag = "5")]
1480        Duration(super::ComputeDuration),
1481        #[prost(message, tag = "6")]
1482        Timestamp(super::ComputeTimestamp),
1483        #[prost(message, tag = "7")]
1484        Expression(super::BoundExpression),
1485        #[prost(message, tag = "8")]
1486        Channel(super::ChannelSelection),
1487        #[prost(message, tag = "9")]
1488        Series(super::SeriesBinding),
1489        #[prost(message, tag = "10")]
1490        ModuleFunction(super::ModuleFunctionExpression),
1491    }
1492}
1493#[derive(Clone, PartialEq, ::prost::Message)]
1494pub struct BoundExpression {
1495    #[prost(message, optional, tag = "1")]
1496    pub expression: ::core::option::Option<ExpressionNode>,
1497    #[prost(message, optional, tag = "2")]
1498    pub context: ::core::option::Option<ComputeContext>,
1499}
1500#[derive(Clone, PartialEq, ::prost::Message)]
1501pub struct SeriesBinding {
1502    #[prost(message, optional, tag = "1")]
1503    pub series_selection: ::core::option::Option<SeriesSelection>,
1504    #[prost(message, optional, tag = "2")]
1505    pub grouping_keys: ::core::option::Option<TagKeySet>,
1506}
1507#[derive(Clone, PartialEq, ::prost::Message)]
1508pub struct ModuleFunctionExpression {
1509    #[prost(message, optional, tag = "1")]
1510    pub module: ::core::option::Option<StringConstant>,
1511    #[prost(message, optional, tag = "2")]
1512    pub function_name: ::core::option::Option<StringConstant>,
1513    #[prost(message, optional, tag = "3")]
1514    pub version: ::core::option::Option<StringConstant>,
1515    #[prost(map = "string, message", tag = "4")]
1516    pub arguments: ::std::collections::HashMap<
1517        ::prost::alloc::string::String,
1518        FunctionArgument,
1519    >,
1520}
1521#[derive(Clone, PartialEq, ::prost::Message)]
1522pub struct FunctionArgument {
1523    #[prost(oneof = "function_argument::Kind", tags = "1, 2")]
1524    pub kind: ::core::option::Option<function_argument::Kind>,
1525}
1526/// Nested message and enum types in `FunctionArgument`.
1527pub mod function_argument {
1528    #[derive(Clone, PartialEq, ::prost::Oneof)]
1529    pub enum Kind {
1530        #[prost(string, tag = "1")]
1531        VariableName(::prost::alloc::string::String),
1532        #[prost(message, tag = "2")]
1533        Value(super::VariableValue),
1534    }
1535}
1536#[derive(Clone, PartialEq, ::prost::Message)]
1537pub struct DatasetExpression {
1538    #[prost(
1539        oneof = "dataset_expression::Kind",
1540        tags = "1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13"
1541    )]
1542    pub kind: ::core::option::Option<dataset_expression::Kind>,
1543}
1544/// Nested message and enum types in `DatasetExpression`.
1545pub mod dataset_expression {
1546    #[derive(Clone, PartialEq, ::prost::Oneof)]
1547    pub enum Kind {
1548        #[prost(message, tag = "1")]
1549        Asset(super::AssetReferenceExpression),
1550        #[prost(message, tag = "2")]
1551        Run(super::RunReferenceExpression),
1552        #[prost(message, tag = "3")]
1553        DataSource(super::DataSourceReferenceExpression),
1554        #[prost(message, tag = "4")]
1555        ResourceSearch(super::DatasetResourceSearch),
1556        #[prost(message, tag = "5")]
1557        Concatenate(super::DatasetConcatenation),
1558        #[prost(message, tag = "6")]
1559        Tag(::prost::alloc::boxed::Box<super::DatasetTagInjection>),
1560        #[prost(message, tag = "7")]
1561        Filter(::prost::alloc::boxed::Box<super::DatasetTagFilter>),
1562        #[prost(message, tag = "8")]
1563        TimeShift(::prost::alloc::boxed::Box<super::DatasetTimeShift>),
1564        #[prost(message, tag = "9")]
1565        AnchorAlignment(::prost::alloc::boxed::Box<super::DatasetAnchorAlignment>),
1566        #[prost(message, tag = "10")]
1567        AddSeries(::prost::alloc::boxed::Box<super::DatasetSeriesAddition>),
1568        #[prost(message, tag = "11")]
1569        RemoveSeries(::prost::alloc::boxed::Box<super::DatasetSeriesRemoval>),
1570        #[prost(message, tag = "12")]
1571        Reference(super::DatasetReference),
1572        #[prost(message, tag = "13")]
1573        Dimensions(::prost::alloc::boxed::Box<super::DatasetDimensions>),
1574    }
1575}
1576#[derive(Clone, PartialEq, ::prost::Message)]
1577pub struct DatasetConcatenation {
1578    #[prost(message, repeated, tag = "1")]
1579    pub inputs: ::prost::alloc::vec::Vec<DatasetExpression>,
1580}
1581#[derive(Clone, PartialEq, ::prost::Message)]
1582pub struct DatasetTagInjection {
1583    #[prost(message, optional, boxed, tag = "1")]
1584    pub input: ::core::option::Option<::prost::alloc::boxed::Box<DatasetExpression>>,
1585    #[prost(message, optional, tag = "2")]
1586    pub key: ::core::option::Option<StringConstant>,
1587    #[prost(message, optional, tag = "3")]
1588    pub value: ::core::option::Option<StringConstant>,
1589}
1590#[derive(Clone, PartialEq, ::prost::Message)]
1591pub struct DatasetTagFilter {
1592    #[prost(message, optional, boxed, tag = "1")]
1593    pub input: ::core::option::Option<::prost::alloc::boxed::Box<DatasetExpression>>,
1594    #[prost(message, optional, tag = "2")]
1595    pub predicate: ::core::option::Option<TagPredicateExpression>,
1596}
1597#[derive(Clone, PartialEq, ::prost::Message)]
1598pub struct DatasetTimeShift {
1599    #[prost(message, optional, boxed, tag = "1")]
1600    pub input: ::core::option::Option<::prost::alloc::boxed::Box<DatasetExpression>>,
1601    #[prost(message, optional, tag = "2")]
1602    pub offset: ::core::option::Option<DurationExpression>,
1603}
1604#[derive(Clone, PartialEq, ::prost::Message)]
1605pub struct DatasetSeriesAddition {
1606    #[prost(message, optional, boxed, tag = "1")]
1607    pub input: ::core::option::Option<::prost::alloc::boxed::Box<DatasetExpression>>,
1608    #[prost(message, repeated, tag = "2")]
1609    pub series: ::prost::alloc::vec::Vec<NamedSeriesExpression>,
1610}
1611#[derive(Clone, PartialEq, ::prost::Message)]
1612pub struct NamedSeriesExpression {
1613    #[prost(message, optional, tag = "1")]
1614    pub name: ::core::option::Option<StringConstant>,
1615    #[prost(message, optional, tag = "2")]
1616    pub definition: ::core::option::Option<SeriesExpression>,
1617}
1618#[derive(Clone, PartialEq, ::prost::Message)]
1619pub struct DatasetSeriesRemoval {
1620    #[prost(message, optional, boxed, tag = "1")]
1621    pub input: ::core::option::Option<::prost::alloc::boxed::Box<DatasetExpression>>,
1622    #[prost(message, repeated, tag = "2")]
1623    pub names: ::prost::alloc::vec::Vec<StringConstant>,
1624}
1625#[derive(Clone, PartialEq, ::prost::Message)]
1626pub struct DatasetDimensions {
1627    #[prost(message, optional, boxed, tag = "1")]
1628    pub input: ::core::option::Option<::prost::alloc::boxed::Box<DatasetExpression>>,
1629    #[prost(message, repeated, tag = "2")]
1630    pub dimensions: ::prost::alloc::vec::Vec<ResourceDimension>,
1631}
1632#[derive(Clone, PartialEq, ::prost::Message)]
1633pub struct ResourceDimension {
1634    #[prost(message, optional, tag = "1")]
1635    pub tag_key: ::core::option::Option<StringConstant>,
1636    #[prost(oneof = "resource_dimension::Value", tags = "2, 3")]
1637    pub value: ::core::option::Option<resource_dimension::Value>,
1638}
1639/// Nested message and enum types in `ResourceDimension`.
1640pub mod resource_dimension {
1641    #[derive(Clone, PartialEq, ::prost::Oneof)]
1642    pub enum Value {
1643        #[prost(message, tag = "2")]
1644        StringProperty(super::StringConstant),
1645        #[prost(message, tag = "3")]
1646        Identity(super::ResourceTypeReferenceExpression),
1647    }
1648}
1649#[derive(Clone, PartialEq, ::prost::Message)]
1650pub struct SeriesSelection {
1651    #[prost(message, optional, tag = "1")]
1652    pub name: ::core::option::Option<StringConstant>,
1653    #[prost(message, optional, boxed, tag = "2")]
1654    pub dataset: ::core::option::Option<::prost::alloc::boxed::Box<DatasetExpression>>,
1655    #[prost(message, optional, tag = "3")]
1656    pub sampling: ::core::option::Option<SeriesSampling>,
1657    #[prost(enumeration = "SeriesStorageEngine", optional, tag = "4")]
1658    pub storage: ::core::option::Option<i32>,
1659}
1660#[derive(Clone, PartialEq, ::prost::Message)]
1661pub struct ResourcePropertySelection {
1662    #[prost(string, tag = "1")]
1663    pub property: ::prost::alloc::string::String,
1664    #[prost(message, optional, boxed, tag = "2")]
1665    pub dataset: ::core::option::Option<::prost::alloc::boxed::Box<DatasetExpression>>,
1666}
1667#[derive(Clone, PartialEq, ::prost::Message)]
1668pub struct ExpressionNode {
1669    #[prost(oneof = "expression_node::Kind", tags = "1, 2, 3, 4, 5, 6, 7, 8, 9")]
1670    pub kind: ::core::option::Option<expression_node::Kind>,
1671}
1672/// Nested message and enum types in `ExpressionNode`.
1673pub mod expression_node {
1674    #[derive(Clone, PartialEq, ::prost::Oneof)]
1675    pub enum Kind {
1676        #[prost(message, tag = "1")]
1677        Numeric(super::NumericExpression),
1678        #[prost(message, tag = "2")]
1679        Categorical(super::CategoricalExpression),
1680        #[prost(message, tag = "3")]
1681        Log(super::LogExpression),
1682        #[prost(message, tag = "4")]
1683        Ranges(super::RangeExpression),
1684        #[prost(message, tag = "5")]
1685        Array(super::ArrayExpression),
1686        #[prost(message, tag = "6")]
1687        Structure(super::StructExpression),
1688        #[prost(message, tag = "7")]
1689        CurveFit(super::CurveFitExpression),
1690        #[prost(message, tag = "8")]
1691        Video(super::TimeSeriesReference),
1692        #[prost(message, tag = "9")]
1693        Reference(super::TimeSeriesReference),
1694    }
1695}
1696#[derive(Clone, PartialEq, ::prost::Message)]
1697pub struct SeriesExpression {
1698    #[prost(oneof = "series_expression::Kind", tags = "1, 2, 3, 4, 5, 6, 7")]
1699    pub kind: ::core::option::Option<series_expression::Kind>,
1700}
1701/// Nested message and enum types in `SeriesExpression`.
1702pub mod series_expression {
1703    #[derive(Clone, PartialEq, ::prost::Oneof)]
1704    pub enum Kind {
1705        #[prost(message, tag = "1")]
1706        Numeric(::prost::alloc::boxed::Box<super::NumericExpression>),
1707        #[prost(message, tag = "2")]
1708        Categorical(::prost::alloc::boxed::Box<super::CategoricalExpression>),
1709        #[prost(message, tag = "3")]
1710        Log(::prost::alloc::boxed::Box<super::LogExpression>),
1711        #[prost(message, tag = "4")]
1712        Array(::prost::alloc::boxed::Box<super::ArrayExpression>),
1713        #[prost(message, tag = "5")]
1714        Structure(::prost::alloc::boxed::Box<super::StructExpression>),
1715        #[prost(message, tag = "6")]
1716        Video(super::TimeSeriesReference),
1717        #[prost(message, tag = "7")]
1718        Reference(super::TimeSeriesReference),
1719    }
1720}
1721#[derive(Clone, PartialEq, ::prost::Message)]
1722pub struct ArrayExpression {
1723    #[prost(oneof = "array_expression::Kind", tags = "1, 2")]
1724    pub kind: ::core::option::Option<array_expression::Kind>,
1725}
1726/// Nested message and enum types in `ArrayExpression`.
1727pub mod array_expression {
1728    #[derive(Clone, PartialEq, ::prost::Oneof)]
1729    pub enum Kind {
1730        #[prost(message, tag = "1")]
1731        Numeric(::prost::alloc::boxed::Box<super::NumericArrayExpression>),
1732        #[prost(message, tag = "2")]
1733        Categorical(::prost::alloc::boxed::Box<super::CategoricalArrayExpression>),
1734    }
1735}
1736#[derive(Clone, PartialEq, ::prost::Message)]
1737pub struct CurveFitExpression {
1738    #[prost(message, optional, tag = "1")]
1739    pub target: ::core::option::Option<CurveSeriesVariable>,
1740    #[prost(message, optional, tag = "2")]
1741    pub interval: ::core::option::Option<CurveFitInterval>,
1742    #[prost(message, optional, tag = "3")]
1743    pub model: ::core::option::Option<CurveModel>,
1744}
1745#[derive(Clone, PartialEq, ::prost::Message)]
1746pub struct CurveFitInterval {
1747    #[prost(message, optional, tag = "1")]
1748    pub start: ::core::option::Option<TimestampConstant>,
1749    #[prost(message, optional, tag = "2")]
1750    pub end: ::core::option::Option<TimestampConstant>,
1751}
1752#[derive(Clone, PartialEq, ::prost::Message)]
1753pub struct CurveSeriesVariable {
1754    #[prost(message, optional, tag = "1")]
1755    pub series: ::core::option::Option<NumericExpression>,
1756    #[prost(message, optional, tag = "2")]
1757    pub bounds: ::core::option::Option<CurveVariableBounds>,
1758}
1759#[derive(Clone, PartialEq, ::prost::Message)]
1760pub struct CurveVariableBounds {
1761    #[prost(message, optional, tag = "1")]
1762    pub min: ::core::option::Option<DoubleConstant>,
1763    #[prost(message, optional, tag = "2")]
1764    pub max: ::core::option::Option<DoubleConstant>,
1765}
1766#[derive(Clone, PartialEq, ::prost::Message)]
1767pub struct CurveVariable {
1768    #[prost(oneof = "curve_variable::Kind", tags = "1, 2")]
1769    pub kind: ::core::option::Option<curve_variable::Kind>,
1770}
1771/// Nested message and enum types in `CurveVariable`.
1772pub mod curve_variable {
1773    #[derive(Clone, PartialEq, ::prost::Oneof)]
1774    pub enum Kind {
1775        #[prost(message, tag = "1")]
1776        Series(super::CurveSeriesVariable),
1777        #[prost(message, tag = "2")]
1778        Time(super::CurveTimeVariable),
1779    }
1780}
1781#[derive(Clone, Copy, PartialEq, ::prost::Message)]
1782pub struct CurveTimeVariable {
1783    #[prost(enumeration = "super::super::types::time::TimeUnit", optional, tag = "1")]
1784    pub unit: ::core::option::Option<i32>,
1785}
1786#[derive(Clone, PartialEq, ::prost::Message)]
1787pub struct CurveModel {
1788    #[prost(oneof = "curve_model::Kind", tags = "1, 2, 3")]
1789    pub kind: ::core::option::Option<curve_model::Kind>,
1790}
1791/// Nested message and enum types in `CurveModel`.
1792pub mod curve_model {
1793    #[derive(Clone, PartialEq, ::prost::Oneof)]
1794    pub enum Kind {
1795        #[prost(message, tag = "1")]
1796        Builtin(super::BuiltinCurveModel),
1797        #[prost(message, tag = "2")]
1798        Polynomial(super::PolynomialCurveModel),
1799        #[prost(message, tag = "3")]
1800        Custom(super::CustomCurveModel),
1801    }
1802}
1803#[derive(Clone, PartialEq, ::prost::Message)]
1804pub struct BuiltinCurveModel {
1805    #[prost(enumeration = "BuiltinCurveForm", tag = "1")]
1806    pub form: i32,
1807    #[prost(message, optional, tag = "2")]
1808    pub independent_variable: ::core::option::Option<CurveVariable>,
1809}
1810#[derive(Clone, PartialEq, ::prost::Message)]
1811pub struct PolynomialCurveModel {
1812    #[prost(message, optional, tag = "1")]
1813    pub independent_variable: ::core::option::Option<CurveVariable>,
1814    #[prost(message, optional, tag = "2")]
1815    pub degree: ::core::option::Option<IntegerConstant>,
1816    #[prost(message, optional, tag = "3")]
1817    pub intercept: ::core::option::Option<DoubleConstant>,
1818}
1819#[derive(Clone, PartialEq, ::prost::Message)]
1820pub struct CustomCurveModel {
1821    #[prost(message, optional, tag = "1")]
1822    pub formula: ::core::option::Option<StringConstant>,
1823    #[prost(map = "string, message", tag = "2")]
1824    pub variables: ::std::collections::HashMap<
1825        ::prost::alloc::string::String,
1826        CurveVariable,
1827    >,
1828    #[prost(map = "string, message", tag = "3")]
1829    pub parameters: ::std::collections::HashMap<
1830        ::prost::alloc::string::String,
1831        DoubleConstant,
1832    >,
1833}
1834#[derive(Clone, PartialEq, ::prost::Message)]
1835pub struct NumericAbsoluteTimestampExpression {
1836    #[prost(message, optional, boxed, tag = "1")]
1837    pub input: ::core::option::Option<::prost::alloc::boxed::Box<SeriesExpression>>,
1838    #[prost(enumeration = "super::super::types::time::TimeUnit", tag = "2")]
1839    pub unit: i32,
1840}
1841#[derive(Clone, PartialEq, ::prost::Message)]
1842pub struct NumericTimeDifferenceExpression {
1843    #[prost(message, optional, boxed, tag = "1")]
1844    pub input: ::core::option::Option<::prost::alloc::boxed::Box<SeriesExpression>>,
1845    #[prost(enumeration = "super::super::types::time::TimeUnit", optional, tag = "2")]
1846    pub unit: ::core::option::Option<i32>,
1847}
1848#[derive(Clone, PartialEq, ::prost::Message)]
1849pub struct NumericReduceUnderRangesExpression {
1850    #[prost(message, optional, boxed, tag = "1")]
1851    pub input: ::core::option::Option<::prost::alloc::boxed::Box<NumericExpression>>,
1852    #[prost(message, optional, boxed, tag = "2")]
1853    pub ranges: ::core::option::Option<::prost::alloc::boxed::Box<RangeExpression>>,
1854    #[prost(message, optional, tag = "3")]
1855    pub reduction: ::core::option::Option<NumericReduction>,
1856}
1857#[derive(Clone, PartialEq, ::prost::Message)]
1858pub struct NumericLogMatchesExpression {
1859    #[prost(message, optional, boxed, tag = "1")]
1860    pub input: ::core::option::Option<::prost::alloc::boxed::Box<LogExpression>>,
1861    #[prost(message, optional, tag = "2")]
1862    pub predicate: ::core::option::Option<LogPredicate>,
1863}
1864#[derive(Clone, PartialEq, ::prost::Message)]
1865pub struct NumericCountDuplicatesExpression {
1866    #[prost(message, repeated, tag = "1")]
1867    pub inputs: ::prost::alloc::vec::Vec<CategoricalExpression>,
1868}
1869#[derive(Clone, PartialEq, ::prost::Message)]
1870pub struct NumericCategoricalMappingExpression {
1871    #[prost(message, optional, boxed, tag = "1")]
1872    pub input: ::core::option::Option<::prost::alloc::boxed::Box<CategoricalExpression>>,
1873    #[prost(map = "string, message", tag = "2")]
1874    pub mapping: ::std::collections::HashMap<
1875        ::prost::alloc::string::String,
1876        DoubleConstant,
1877    >,
1878    #[prost(message, optional, tag = "3")]
1879    pub default_value: ::core::option::Option<DoubleConstant>,
1880}
1881#[derive(Clone, PartialEq, ::prost::Message)]
1882pub struct NumericStructFieldExpression {
1883    #[prost(message, optional, boxed, tag = "1")]
1884    pub input: ::core::option::Option<::prost::alloc::boxed::Box<StructExpression>>,
1885    #[prost(message, repeated, tag = "2")]
1886    pub path: ::prost::alloc::vec::Vec<StringConstant>,
1887    #[prost(
1888        enumeration = "super::super::types::series::SeriesDataType",
1889        optional,
1890        tag = "3"
1891    )]
1892    pub numeric_type: ::core::option::Option<i32>,
1893}
1894#[derive(Clone, PartialEq, ::prost::Message)]
1895pub struct NumericRangeFilterExpression {
1896    #[prost(message, optional, boxed, tag = "1")]
1897    pub input: ::core::option::Option<::prost::alloc::boxed::Box<NumericExpression>>,
1898    #[prost(message, optional, boxed, tag = "2")]
1899    pub ranges: ::core::option::Option<::prost::alloc::boxed::Box<RangeExpression>>,
1900}
1901#[derive(Clone, PartialEq, ::prost::Message)]
1902pub struct NumericGroupWithinRangesExpression {
1903    #[prost(message, optional, boxed, tag = "1")]
1904    pub input: ::core::option::Option<::prost::alloc::boxed::Box<NumericExpression>>,
1905    #[prost(message, optional, boxed, tag = "2")]
1906    pub ranges: ::core::option::Option<::prost::alloc::boxed::Box<RangeExpression>>,
1907    #[prost(message, optional, tag = "3")]
1908    pub reduction: ::core::option::Option<NumericReduction>,
1909}
1910#[derive(Clone, PartialEq, ::prost::Message)]
1911pub struct NumericAggregationExpression {
1912    #[prost(message, optional, boxed, tag = "1")]
1913    pub input: ::core::option::Option<::prost::alloc::boxed::Box<AggregationInput>>,
1914    #[prost(message, optional, tag = "2")]
1915    pub reduction: ::core::option::Option<NumericReduction>,
1916}
1917#[derive(Clone, PartialEq, ::prost::Message)]
1918pub struct AggregationInput {
1919    #[prost(oneof = "aggregation_input::Kind", tags = "1, 2, 3")]
1920    pub kind: ::core::option::Option<aggregation_input::Kind>,
1921}
1922/// Nested message and enum types in `AggregationInput`.
1923pub mod aggregation_input {
1924    #[derive(Clone, PartialEq, ::prost::Oneof)]
1925    pub enum Kind {
1926        #[prost(message, tag = "1")]
1927        TimeWindow(::prost::alloc::boxed::Box<super::TimeWindowAggregation>),
1928        #[prost(message, tag = "2")]
1929        PointWindow(::prost::alloc::boxed::Box<super::PointWindowAggregation>),
1930        #[prost(message, tag = "3")]
1931        Grouping(::prost::alloc::boxed::Box<super::GroupedSeriesAggregation>),
1932    }
1933}
1934#[derive(Clone, PartialEq, ::prost::Message)]
1935pub struct TimeWindowAggregation {
1936    #[prost(message, optional, boxed, tag = "1")]
1937    pub input: ::core::option::Option<::prost::alloc::boxed::Box<SeriesExpression>>,
1938    #[prost(message, optional, tag = "2")]
1939    pub window: ::core::option::Option<DurationExpression>,
1940}
1941#[derive(Clone, PartialEq, ::prost::Message)]
1942pub struct PointWindowAggregation {
1943    #[prost(message, optional, boxed, tag = "1")]
1944    pub input: ::core::option::Option<::prost::alloc::boxed::Box<SeriesExpression>>,
1945    #[prost(message, optional, tag = "2")]
1946    pub points: ::core::option::Option<IntegerConstant>,
1947}
1948#[derive(Clone, PartialEq, ::prost::Message)]
1949pub struct GroupedSeriesAggregation {
1950    #[prost(message, optional, boxed, tag = "1")]
1951    pub input: ::core::option::Option<::prost::alloc::boxed::Box<SeriesExpression>>,
1952    #[prost(message, optional, tag = "2")]
1953    pub keys: ::core::option::Option<AggregationGroupingKeys>,
1954    #[prost(message, optional, tag = "3")]
1955    pub timestamp: ::core::option::Option<AggregationTimestamp>,
1956    #[prost(bool, tag = "4")]
1957    pub use_context_alignment: bool,
1958}
1959#[derive(Clone, PartialEq, ::prost::Message)]
1960pub struct AggregationGroupingKeys {
1961    #[prost(oneof = "aggregation_grouping_keys::Kind", tags = "1, 2")]
1962    pub kind: ::core::option::Option<aggregation_grouping_keys::Kind>,
1963}
1964/// Nested message and enum types in `AggregationGroupingKeys`.
1965pub mod aggregation_grouping_keys {
1966    #[derive(Clone, PartialEq, ::prost::Oneof)]
1967    pub enum Kind {
1968        #[prost(message, tag = "1")]
1969        Current(super::CurrentGroupingKeys),
1970        #[prost(message, tag = "2")]
1971        Subset(super::TagKeySet),
1972    }
1973}
1974#[derive(Clone, Copy, PartialEq, ::prost::Message)]
1975pub struct CurrentGroupingKeys {}
1976#[derive(Clone, PartialEq, ::prost::Message)]
1977pub struct AggregationTimestamp {
1978    #[prost(oneof = "aggregation_timestamp::Kind", tags = "1, 2")]
1979    pub kind: ::core::option::Option<aggregation_timestamp::Kind>,
1980}
1981/// Nested message and enum types in `AggregationTimestamp`.
1982pub mod aggregation_timestamp {
1983    #[derive(Clone, PartialEq, ::prost::Oneof)]
1984    pub enum Kind {
1985        #[prost(message, tag = "1")]
1986        Current(super::CurrentTimestamps),
1987        #[prost(message, tag = "2")]
1988        Every(super::DurationExpression),
1989    }
1990}
1991#[derive(Clone, Copy, PartialEq, ::prost::Message)]
1992pub struct CurrentTimestamps {}
1993#[derive(Clone, PartialEq, ::prost::Message)]
1994pub struct NumericRangeDurationExpression {
1995    #[prost(message, optional, boxed, tag = "1")]
1996    pub input: ::core::option::Option<::prost::alloc::boxed::Box<RangeExpression>>,
1997    #[prost(enumeration = "UnboundedRangePolicy", tag = "2")]
1998    pub unbounded: i32,
1999    #[prost(enumeration = "super::super::types::time::TimeUnit", optional, tag = "3")]
2000    pub unit: ::core::option::Option<i32>,
2001}
2002#[derive(Clone, PartialEq, ::prost::Message)]
2003pub struct ScalarUdfExpression {
2004    #[prost(message, repeated, tag = "1")]
2005    pub inputs: ::prost::alloc::vec::Vec<SeriesExpression>,
2006    #[prost(message, optional, tag = "2")]
2007    pub source: ::core::option::Option<super::super::modules::v1::UdfSource>,
2008}
2009#[derive(Clone, PartialEq, ::prost::Message)]
2010pub struct NumericArrayIndexExpression {
2011    #[prost(message, optional, boxed, tag = "1")]
2012    pub input: ::core::option::Option<
2013        ::prost::alloc::boxed::Box<NumericArrayExpression>,
2014    >,
2015    #[prost(message, optional, tag = "2")]
2016    pub index: ::core::option::Option<IntegerConstant>,
2017}
2018#[derive(Clone, PartialEq, ::prost::Message)]
2019pub struct NumericIntervalTagsExpression {
2020    #[prost(message, optional, boxed, tag = "1")]
2021    pub input: ::core::option::Option<::prost::alloc::boxed::Box<NumericExpression>>,
2022    #[prost(message, optional, boxed, tag = "2")]
2023    pub intervals: ::core::option::Option<
2024        ::prost::alloc::boxed::Box<IntervalSourceExpression>,
2025    >,
2026    #[prost(message, optional, tag = "3")]
2027    pub time_shift: ::core::option::Option<IntervalTimeShift>,
2028}
2029#[derive(Clone, PartialEq, ::prost::Message)]
2030pub struct IntervalSourceExpression {
2031    #[prost(oneof = "interval_source_expression::Kind", tags = "1, 2")]
2032    pub kind: ::core::option::Option<interval_source_expression::Kind>,
2033}
2034/// Nested message and enum types in `IntervalSourceExpression`.
2035pub mod interval_source_expression {
2036    #[derive(Clone, PartialEq, ::prost::Oneof)]
2037    pub enum Kind {
2038        #[prost(message, tag = "1")]
2039        Events(super::EventIntervals),
2040        #[prost(message, tag = "2")]
2041        Ranges(::prost::alloc::boxed::Box<super::RangeIntervals>),
2042    }
2043}
2044#[derive(Clone, PartialEq, ::prost::Message)]
2045pub struct EventIntervals {
2046    #[prost(message, optional, tag = "1")]
2047    pub query: ::core::option::Option<EventPredicateExpression>,
2048    #[prost(message, repeated, tag = "2")]
2049    pub tags: ::prost::alloc::vec::Vec<EventIntervalTag>,
2050}
2051#[derive(Clone, PartialEq, ::prost::Message)]
2052pub struct RangeIntervals {
2053    #[prost(message, optional, boxed, tag = "1")]
2054    pub input: ::core::option::Option<::prost::alloc::boxed::Box<RangeExpression>>,
2055    #[prost(message, repeated, tag = "2")]
2056    pub tags: ::prost::alloc::vec::Vec<RangeIntervalTag>,
2057}
2058#[derive(Clone, PartialEq, ::prost::Message)]
2059pub struct EventIntervalTag {
2060    #[prost(oneof = "event_interval_tag::Kind", tags = "1, 2, 3, 4, 5")]
2061    pub kind: ::core::option::Option<event_interval_tag::Kind>,
2062}
2063/// Nested message and enum types in `EventIntervalTag`.
2064pub mod event_interval_tag {
2065    #[derive(Clone, PartialEq, ::prost::Oneof)]
2066    pub enum Kind {
2067        #[prost(message, tag = "1")]
2068        IntervalIndex(super::IntervalIndexTag),
2069        #[prost(message, tag = "2")]
2070        IntervalStart(super::IntervalStartTag),
2071        #[prost(message, tag = "3")]
2072        EventLevel(super::EventLevelTag),
2073        #[prost(message, tag = "4")]
2074        EventProperty(super::StringConstant),
2075        #[prost(message, tag = "5")]
2076        EventLabel(super::StringConstant),
2077    }
2078}
2079#[derive(Clone, Copy, PartialEq, ::prost::Message)]
2080pub struct RangeIntervalTag {
2081    #[prost(oneof = "range_interval_tag::Kind", tags = "1, 2")]
2082    pub kind: ::core::option::Option<range_interval_tag::Kind>,
2083}
2084/// Nested message and enum types in `RangeIntervalTag`.
2085pub mod range_interval_tag {
2086    #[derive(Clone, Copy, PartialEq, ::prost::Oneof)]
2087    pub enum Kind {
2088        #[prost(message, tag = "1")]
2089        IntervalIndex(super::IntervalIndexTag),
2090        #[prost(message, tag = "2")]
2091        IntervalStart(super::IntervalStartTag),
2092    }
2093}
2094#[derive(Clone, Copy, PartialEq, ::prost::Message)]
2095pub struct IntervalIndexTag {}
2096#[derive(Clone, Copy, PartialEq, ::prost::Message)]
2097pub struct IntervalStartTag {}
2098#[derive(Clone, Copy, PartialEq, ::prost::Message)]
2099pub struct EventLevelTag {}
2100#[derive(Clone, PartialEq, ::prost::Message)]
2101pub struct IntervalTimeShift {
2102    #[prost(oneof = "interval_time_shift::Kind", tags = "1, 2, 3")]
2103    pub kind: ::core::option::Option<interval_time_shift::Kind>,
2104}
2105/// Nested message and enum types in `IntervalTimeShift`.
2106pub mod interval_time_shift {
2107    #[derive(Clone, PartialEq, ::prost::Oneof)]
2108    pub enum Kind {
2109        #[prost(message, tag = "1")]
2110        IntervalStart(super::IntervalStartAnchor),
2111        #[prost(message, tag = "2")]
2112        IntervalEnd(super::IntervalEndAnchor),
2113        #[prost(message, tag = "3")]
2114        Event(super::EventOrdinalSelection),
2115    }
2116}
2117#[derive(Clone, Copy, PartialEq, ::prost::Message)]
2118pub struct IntervalStartAnchor {}
2119#[derive(Clone, Copy, PartialEq, ::prost::Message)]
2120pub struct IntervalEndAnchor {}
2121#[derive(Clone, PartialEq, ::prost::Message)]
2122pub struct EventOrdinalSelection {
2123    #[prost(message, optional, tag = "1")]
2124    pub query: ::core::option::Option<EventPredicateExpression>,
2125    #[prost(message, optional, tag = "2")]
2126    pub index: ::core::option::Option<IntegerConstant>,
2127    #[prost(enumeration = "ChronologicalOrder", optional, tag = "3")]
2128    pub order: ::core::option::Option<i32>,
2129}
2130#[derive(Clone, PartialEq, ::prost::Message)]
2131pub struct RangeOrdinalSelection {
2132    #[prost(message, optional, boxed, tag = "1")]
2133    pub input: ::core::option::Option<::prost::alloc::boxed::Box<RangeExpression>>,
2134    #[prost(message, optional, tag = "2")]
2135    pub index: ::core::option::Option<IntegerConstant>,
2136    #[prost(enumeration = "ChronologicalOrder", optional, tag = "3")]
2137    pub order: ::core::option::Option<i32>,
2138}
2139#[derive(Clone, PartialEq, ::prost::Message)]
2140pub struct RunAnchorExpression {
2141    #[prost(oneof = "run_anchor_expression::Kind", tags = "1, 2, 3, 4")]
2142    pub kind: ::core::option::Option<run_anchor_expression::Kind>,
2143}
2144/// Nested message and enum types in `RunAnchorExpression`.
2145pub mod run_anchor_expression {
2146    #[derive(Clone, PartialEq, ::prost::Oneof)]
2147    pub enum Kind {
2148        #[prost(message, tag = "1")]
2149        IntervalStart(super::IntervalStartAnchor),
2150        #[prost(message, tag = "2")]
2151        IntervalEnd(super::IntervalEndAnchor),
2152        #[prost(message, tag = "3")]
2153        Event(super::EventOrdinalSelection),
2154        #[prost(message, tag = "4")]
2155        Ranges(::prost::alloc::boxed::Box<super::RangeOrdinalSelection>),
2156    }
2157}
2158#[derive(Clone, PartialEq, ::prost::Message)]
2159pub struct DatasetAnchorAlignment {
2160    #[prost(message, optional, boxed, tag = "1")]
2161    pub input: ::core::option::Option<::prost::alloc::boxed::Box<DatasetExpression>>,
2162    #[prost(message, optional, boxed, tag = "2")]
2163    pub anchor: ::core::option::Option<::prost::alloc::boxed::Box<RunAnchorExpression>>,
2164    #[prost(bool, tag = "3")]
2165    pub align_to_earliest: bool,
2166}
2167#[derive(Clone, PartialEq, ::prost::Message)]
2168pub struct CategoricalExpression {
2169    #[prost(
2170        oneof = "categorical_expression::Kind",
2171        tags = "1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23"
2172    )]
2173    pub kind: ::core::option::Option<categorical_expression::Kind>,
2174}
2175/// Nested message and enum types in `CategoricalExpression`.
2176pub mod categorical_expression {
2177    #[derive(Clone, PartialEq, ::prost::Oneof)]
2178    pub enum Kind {
2179        #[prost(message, tag = "1")]
2180        Reference(super::TimeSeriesReference),
2181        #[prost(message, tag = "2")]
2182        ChannelSelection(super::ChannelSelection),
2183        #[prost(message, tag = "3")]
2184        ModuleFunction(super::ModuleFunctionExpression),
2185        #[prost(message, tag = "4")]
2186        SeriesSelection(::prost::alloc::boxed::Box<super::SeriesSelection>),
2187        #[prost(message, tag = "5")]
2188        ResourceProperty(::prost::alloc::boxed::Box<super::ResourcePropertySelection>),
2189        #[prost(message, tag = "6")]
2190        DuplicateTimestampAggregation(
2191            ::prost::alloc::boxed::Box<
2192                super::CategoricalDuplicateTimestampAggregationExpression,
2193            >,
2194        ),
2195        #[prost(message, tag = "7")]
2196        Resample(::prost::alloc::boxed::Box<super::CategoricalResampleExpression>),
2197        #[prost(message, tag = "8")]
2198        ResampleV2(::prost::alloc::boxed::Box<super::CategoricalResampleV2Expression>),
2199        #[prost(message, tag = "9")]
2200        NthPointDownsample(
2201            ::prost::alloc::boxed::Box<super::CategoricalNthPointDownsampleExpression>,
2202        ),
2203        #[prost(message, tag = "10")]
2204        TimeRangeFilter(
2205            ::prost::alloc::boxed::Box<super::CategoricalTimeRangeFilterExpression>,
2206        ),
2207        #[prost(message, tag = "11")]
2208        TimeShift(::prost::alloc::boxed::Box<super::CategoricalTimeShiftExpression>),
2209        #[prost(message, tag = "12")]
2210        TimeShiftV2(::prost::alloc::boxed::Box<super::CategoricalTimeShiftV2Expression>),
2211        #[prost(message, tag = "13")]
2212        Union(super::CategoricalUnionExpression),
2213        #[prost(message, tag = "14")]
2214        RangeFilter(::prost::alloc::boxed::Box<super::CategoricalRangeFilterExpression>),
2215        #[prost(message, tag = "15")]
2216        NumericMapping(
2217            ::prost::alloc::boxed::Box<super::CategoricalNumericMappingExpression>,
2218        ),
2219        #[prost(message, tag = "16")]
2220        ArrayIndex(::prost::alloc::boxed::Box<super::CategoricalArrayIndexExpression>),
2221        #[prost(message, tag = "17")]
2222        StructField(::prost::alloc::boxed::Box<super::CategoricalStructFieldExpression>),
2223        #[prost(message, tag = "18")]
2224        Events(super::CategoricalEventsExpression),
2225        #[prost(message, tag = "19")]
2226        Aggregation(::prost::alloc::boxed::Box<super::CategoricalAggregationExpression>),
2227        #[prost(message, tag = "20")]
2228        TagFilter(::prost::alloc::boxed::Box<super::CategoricalTagFilterExpression>),
2229        #[prost(message, tag = "21")]
2230        TagSelection(
2231            ::prost::alloc::boxed::Box<super::CategoricalTagSelectionExpression>,
2232        ),
2233        #[prost(message, tag = "22")]
2234        ScalarUdf(super::ScalarUdfExpression),
2235        #[prost(message, tag = "23")]
2236        ToStartOfInterval(
2237            ::prost::alloc::boxed::Box<super::CategoricalToStartOfIntervalExpression>,
2238        ),
2239    }
2240}
2241#[derive(Clone, PartialEq, ::prost::Message)]
2242pub struct CategoricalDuplicateTimestampAggregationExpression {
2243    #[prost(message, optional, boxed, tag = "1")]
2244    pub input: ::core::option::Option<::prost::alloc::boxed::Box<CategoricalExpression>>,
2245    #[prost(message, optional, tag = "2")]
2246    pub reduction: ::core::option::Option<CategoricalReduction>,
2247}
2248#[derive(Clone, PartialEq, ::prost::Message)]
2249pub struct CategoricalResampleExpression {
2250    #[prost(message, optional, boxed, tag = "1")]
2251    pub input: ::core::option::Option<::prost::alloc::boxed::Box<CategoricalExpression>>,
2252    #[prost(message, optional, tag = "2")]
2253    pub interval: ::core::option::Option<DurationConstant>,
2254    #[prost(message, optional, tag = "3")]
2255    pub fill: ::core::option::Option<CategoricalResampleFill>,
2256}
2257#[derive(Clone, PartialEq, ::prost::Message)]
2258pub struct CategoricalResampleV2Expression {
2259    #[prost(message, optional, boxed, tag = "1")]
2260    pub input: ::core::option::Option<::prost::alloc::boxed::Box<CategoricalExpression>>,
2261    #[prost(message, optional, tag = "2")]
2262    pub interval: ::core::option::Option<DurationExpression>,
2263}
2264#[derive(Clone, PartialEq, ::prost::Message)]
2265pub struct CategoricalNthPointDownsampleExpression {
2266    #[prost(message, optional, boxed, tag = "1")]
2267    pub input: ::core::option::Option<::prost::alloc::boxed::Box<CategoricalExpression>>,
2268    #[prost(message, optional, tag = "2")]
2269    pub every_nth: ::core::option::Option<IntegerConstant>,
2270}
2271#[derive(Clone, PartialEq, ::prost::Message)]
2272pub struct CategoricalTimeRangeFilterExpression {
2273    #[prost(message, optional, boxed, tag = "1")]
2274    pub input: ::core::option::Option<::prost::alloc::boxed::Box<CategoricalExpression>>,
2275    #[prost(message, optional, tag = "2")]
2276    pub start: ::core::option::Option<TimestampConstant>,
2277    #[prost(message, optional, tag = "3")]
2278    pub end: ::core::option::Option<TimestampConstant>,
2279}
2280#[derive(Clone, PartialEq, ::prost::Message)]
2281pub struct CategoricalTimeShiftExpression {
2282    #[prost(message, optional, boxed, tag = "1")]
2283    pub input: ::core::option::Option<::prost::alloc::boxed::Box<CategoricalExpression>>,
2284    #[prost(message, optional, tag = "2")]
2285    pub duration: ::core::option::Option<DurationConstant>,
2286}
2287#[derive(Clone, PartialEq, ::prost::Message)]
2288pub struct CategoricalTimeShiftV2Expression {
2289    #[prost(message, optional, boxed, tag = "1")]
2290    pub input: ::core::option::Option<::prost::alloc::boxed::Box<CategoricalExpression>>,
2291    #[prost(message, optional, tag = "2")]
2292    pub duration: ::core::option::Option<DurationExpression>,
2293}
2294#[derive(Clone, PartialEq, ::prost::Message)]
2295pub struct CategoricalUnionExpression {
2296    #[prost(message, repeated, tag = "1")]
2297    pub inputs: ::prost::alloc::vec::Vec<CategoricalExpression>,
2298    #[prost(enumeration = "CategoricalMergeOperation", tag = "2")]
2299    pub operation: i32,
2300}
2301#[derive(Clone, PartialEq, ::prost::Message)]
2302pub struct CategoricalRangeFilterExpression {
2303    #[prost(message, optional, boxed, tag = "1")]
2304    pub input: ::core::option::Option<::prost::alloc::boxed::Box<CategoricalExpression>>,
2305    #[prost(message, optional, boxed, tag = "2")]
2306    pub ranges: ::core::option::Option<::prost::alloc::boxed::Box<RangeExpression>>,
2307}
2308#[derive(Clone, PartialEq, ::prost::Message)]
2309pub struct CategoricalNumericMappingExpression {
2310    #[prost(message, optional, boxed, tag = "1")]
2311    pub input: ::core::option::Option<::prost::alloc::boxed::Box<NumericExpression>>,
2312    #[prost(message, repeated, tag = "2")]
2313    pub mapping: ::prost::alloc::vec::Vec<NumericCategoricalInterval>,
2314    #[prost(message, optional, tag = "3")]
2315    pub default_value: ::core::option::Option<StringConstant>,
2316}
2317#[derive(Clone, PartialEq, ::prost::Message)]
2318pub struct NumericCategoricalInterval {
2319    #[prost(message, optional, tag = "1")]
2320    pub start: ::core::option::Option<DoubleConstant>,
2321    #[prost(message, optional, tag = "2")]
2322    pub end: ::core::option::Option<DoubleConstant>,
2323    #[prost(message, optional, tag = "3")]
2324    pub value: ::core::option::Option<StringConstant>,
2325}
2326#[derive(Clone, PartialEq, ::prost::Message)]
2327pub struct CategoricalArrayIndexExpression {
2328    #[prost(message, optional, boxed, tag = "1")]
2329    pub input: ::core::option::Option<
2330        ::prost::alloc::boxed::Box<CategoricalArrayExpression>,
2331    >,
2332    #[prost(message, optional, tag = "2")]
2333    pub index: ::core::option::Option<IntegerConstant>,
2334}
2335#[derive(Clone, PartialEq, ::prost::Message)]
2336pub struct CategoricalStructFieldExpression {
2337    #[prost(message, optional, boxed, tag = "1")]
2338    pub input: ::core::option::Option<::prost::alloc::boxed::Box<StructExpression>>,
2339    #[prost(message, repeated, tag = "2")]
2340    pub path: ::prost::alloc::vec::Vec<StringConstant>,
2341}
2342#[derive(Clone, PartialEq, ::prost::Message)]
2343pub struct CategoricalEventsExpression {
2344    #[prost(message, optional, tag = "1")]
2345    pub query: ::core::option::Option<EventPredicateExpression>,
2346    #[prost(oneof = "categorical_events_expression::Value", tags = "2, 3")]
2347    pub value: ::core::option::Option<categorical_events_expression::Value>,
2348}
2349/// Nested message and enum types in `CategoricalEventsExpression`.
2350pub mod categorical_events_expression {
2351    #[derive(Clone, PartialEq, ::prost::Oneof)]
2352    pub enum Value {
2353        #[prost(message, tag = "2")]
2354        Property(super::StringConstant),
2355        #[prost(message, tag = "3")]
2356        Level(super::EventLevelValue),
2357    }
2358}
2359#[derive(Clone, Copy, PartialEq, ::prost::Message)]
2360pub struct EventLevelValue {}
2361#[derive(Clone, PartialEq, ::prost::Message)]
2362pub struct CategoricalAggregationExpression {
2363    #[prost(message, optional, boxed, tag = "1")]
2364    pub input: ::core::option::Option<::prost::alloc::boxed::Box<AggregationInput>>,
2365    #[prost(message, optional, tag = "2")]
2366    pub reduction: ::core::option::Option<CategoricalReduction>,
2367}
2368#[derive(Clone, PartialEq, ::prost::Message)]
2369pub struct CategoricalTagFilterExpression {
2370    #[prost(message, optional, boxed, tag = "1")]
2371    pub input: ::core::option::Option<::prost::alloc::boxed::Box<CategoricalExpression>>,
2372    #[prost(message, optional, tag = "2")]
2373    pub predicate: ::core::option::Option<TagPredicateExpression>,
2374}
2375#[derive(Clone, PartialEq, ::prost::Message)]
2376pub struct CategoricalTagSelectionExpression {
2377    #[prost(message, optional, boxed, tag = "1")]
2378    pub input: ::core::option::Option<::prost::alloc::boxed::Box<CategoricalExpression>>,
2379    #[prost(message, optional, tag = "2")]
2380    pub keys: ::core::option::Option<TagKeySet>,
2381}
2382#[derive(Clone, PartialEq, ::prost::Message)]
2383pub struct CategoricalToStartOfIntervalExpression {
2384    #[prost(message, optional, boxed, tag = "1")]
2385    pub input: ::core::option::Option<::prost::alloc::boxed::Box<CategoricalExpression>>,
2386    #[prost(message, optional, tag = "2")]
2387    pub interval: ::core::option::Option<DurationExpression>,
2388}
2389#[derive(Clone, PartialEq, ::prost::Message)]
2390pub struct BooleanExpression {
2391    #[prost(oneof = "boolean_expression::Kind", tags = "1, 2")]
2392    pub kind: ::core::option::Option<boolean_expression::Kind>,
2393}
2394/// Nested message and enum types in `BooleanExpression`.
2395pub mod boolean_expression {
2396    #[derive(Clone, PartialEq, ::prost::Oneof)]
2397    pub enum Kind {
2398        #[prost(message, tag = "1")]
2399        Comparison(::prost::alloc::boxed::Box<super::ComparisonExpression>),
2400        #[prost(message, tag = "2")]
2401        Logical(::prost::alloc::boxed::Box<super::LogicalExpression>),
2402    }
2403}
2404#[derive(Clone, PartialEq, ::prost::Message)]
2405pub struct NumericUnaryExpression {
2406    #[prost(enumeration = "UnaryNumericOperation", tag = "1")]
2407    pub operation: i32,
2408    #[prost(message, optional, boxed, tag = "2")]
2409    pub input: ::core::option::Option<::prost::alloc::boxed::Box<NumericExpression>>,
2410}
2411#[derive(Clone, PartialEq, ::prost::Message)]
2412pub struct NumericBinaryExpression {
2413    #[prost(enumeration = "BinaryNumericOperation", tag = "1")]
2414    pub operation: i32,
2415    #[prost(message, optional, boxed, tag = "2")]
2416    pub left: ::core::option::Option<::prost::alloc::boxed::Box<NumericExpression>>,
2417    #[prost(message, optional, boxed, tag = "3")]
2418    pub right: ::core::option::Option<::prost::alloc::boxed::Box<NumericExpression>>,
2419    #[deprecated]
2420    #[prost(message, optional, tag = "4")]
2421    pub interpolation: ::core::option::Option<InterpolationConfiguration>,
2422}
2423#[derive(Clone, PartialEq, ::prost::Message)]
2424pub struct NumericNaryExpression {
2425    #[prost(enumeration = "NaryNumericOperation", tag = "1")]
2426    pub operation: i32,
2427    #[prost(message, repeated, tag = "2")]
2428    pub inputs: ::prost::alloc::vec::Vec<NumericExpression>,
2429    #[deprecated]
2430    #[prost(message, optional, tag = "3")]
2431    pub interpolation: ::core::option::Option<InterpolationConfiguration>,
2432}
2433#[derive(Clone, PartialEq, ::prost::Message)]
2434pub struct NumericBitwiseExpression {
2435    #[prost(enumeration = "BitwiseOperation", tag = "1")]
2436    pub operation: i32,
2437    #[prost(message, optional, boxed, tag = "2")]
2438    pub input: ::core::option::Option<::prost::alloc::boxed::Box<NumericExpression>>,
2439    #[prost(message, optional, tag = "3")]
2440    pub operand: ::core::option::Option<IntegerConstant>,
2441}
2442#[derive(Clone, PartialEq, ::prost::Message)]
2443pub struct NumericConditionalExpression {
2444    #[prost(message, optional, boxed, tag = "1")]
2445    pub condition: ::core::option::Option<::prost::alloc::boxed::Box<BooleanExpression>>,
2446    #[prost(message, optional, boxed, tag = "2")]
2447    pub true_value: ::core::option::Option<
2448        ::prost::alloc::boxed::Box<NumericExpression>,
2449    >,
2450    #[prost(message, optional, boxed, tag = "3")]
2451    pub false_value: ::core::option::Option<
2452        ::prost::alloc::boxed::Box<NumericExpression>,
2453    >,
2454}
2455#[derive(Clone, PartialEq, ::prost::Message)]
2456pub struct ComparisonExpression {
2457    #[prost(enumeration = "ComparisonOperation", tag = "1")]
2458    pub operation: i32,
2459    #[prost(message, optional, boxed, tag = "2")]
2460    pub left: ::core::option::Option<::prost::alloc::boxed::Box<NumericExpression>>,
2461    #[prost(message, optional, boxed, tag = "3")]
2462    pub right: ::core::option::Option<::prost::alloc::boxed::Box<NumericExpression>>,
2463}
2464#[derive(Clone, PartialEq, ::prost::Message)]
2465pub struct LogicalExpression {
2466    #[prost(enumeration = "LogicalOperation", tag = "1")]
2467    pub operation: i32,
2468    #[prost(message, optional, boxed, tag = "2")]
2469    pub left: ::core::option::Option<::prost::alloc::boxed::Box<BooleanExpression>>,
2470    #[prost(message, optional, boxed, tag = "3")]
2471    pub right: ::core::option::Option<::prost::alloc::boxed::Box<BooleanExpression>>,
2472}
2473#[derive(Clone, PartialEq, ::prost::Message)]
2474pub struct InterpolationConfiguration {
2475    #[prost(oneof = "interpolation_configuration::Kind", tags = "1")]
2476    pub kind: ::core::option::Option<interpolation_configuration::Kind>,
2477}
2478/// Nested message and enum types in `InterpolationConfiguration`.
2479pub mod interpolation_configuration {
2480    #[derive(Clone, PartialEq, ::prost::Oneof)]
2481    pub enum Kind {
2482        #[prost(message, tag = "1")]
2483        ForwardFill(super::ForwardFillInterpolation),
2484    }
2485}
2486#[derive(Clone, PartialEq, ::prost::Message)]
2487pub struct ForwardFillInterpolation {
2488    #[prost(message, optional, tag = "1")]
2489    pub max_fill_duration: ::core::option::Option<DurationConstant>,
2490}
2491#[derive(Clone, PartialEq, ::prost::Message)]
2492pub struct NumericCumulativeSumExpression {
2493    #[prost(message, optional, boxed, tag = "1")]
2494    pub input: ::core::option::Option<::prost::alloc::boxed::Box<NumericExpression>>,
2495    #[prost(message, optional, tag = "2")]
2496    pub start: ::core::option::Option<TimestampConstant>,
2497}
2498#[derive(Clone, PartialEq, ::prost::Message)]
2499pub struct NumericDerivativeExpression {
2500    #[prost(message, optional, boxed, tag = "1")]
2501    pub input: ::core::option::Option<::prost::alloc::boxed::Box<NumericExpression>>,
2502    #[prost(enumeration = "super::super::types::time::TimeUnit", optional, tag = "2")]
2503    pub time_unit: ::core::option::Option<i32>,
2504    #[prost(enumeration = "NegativeValuePolicy", optional, tag = "3")]
2505    pub negative_value_policy: ::core::option::Option<i32>,
2506}
2507#[derive(Clone, PartialEq, ::prost::Message)]
2508pub struct NumericIntegralExpression {
2509    #[prost(message, optional, boxed, tag = "1")]
2510    pub input: ::core::option::Option<::prost::alloc::boxed::Box<NumericExpression>>,
2511    #[prost(message, optional, tag = "2")]
2512    pub start: ::core::option::Option<TimestampConstant>,
2513    #[prost(enumeration = "super::super::types::time::TimeUnit", optional, tag = "3")]
2514    pub time_unit: ::core::option::Option<i32>,
2515}
2516#[derive(Clone, PartialEq, ::prost::Message)]
2517pub struct NumericTimeRangeFilterExpression {
2518    #[prost(message, optional, boxed, tag = "1")]
2519    pub input: ::core::option::Option<::prost::alloc::boxed::Box<NumericExpression>>,
2520    #[prost(message, optional, tag = "2")]
2521    pub start: ::core::option::Option<TimestampConstant>,
2522    #[prost(message, optional, tag = "3")]
2523    pub end: ::core::option::Option<TimestampConstant>,
2524}
2525#[derive(Clone, PartialEq, ::prost::Message)]
2526pub struct NumericTimeShiftExpression {
2527    #[prost(message, optional, boxed, tag = "1")]
2528    pub input: ::core::option::Option<::prost::alloc::boxed::Box<NumericExpression>>,
2529    #[prost(message, optional, tag = "2")]
2530    pub duration: ::core::option::Option<DurationConstant>,
2531}
2532#[derive(Clone, PartialEq, ::prost::Message)]
2533pub struct NumericValueDifferenceExpression {
2534    #[prost(message, optional, boxed, tag = "1")]
2535    pub input: ::core::option::Option<::prost::alloc::boxed::Box<NumericExpression>>,
2536    #[prost(enumeration = "NegativeValuePolicy", optional, tag = "2")]
2537    pub negative_value_policy: ::core::option::Option<i32>,
2538}
2539#[derive(Clone, PartialEq, ::prost::Message)]
2540pub struct NumericPhaseUnwrapExpression {
2541    #[prost(message, optional, boxed, tag = "1")]
2542    pub input: ::core::option::Option<::prost::alloc::boxed::Box<NumericExpression>>,
2543    #[prost(message, optional, tag = "2")]
2544    pub period: ::core::option::Option<DoubleConstant>,
2545}
2546#[derive(Clone, PartialEq, ::prost::Message)]
2547pub struct NumericPointLimitExpression {
2548    #[prost(message, optional, boxed, tag = "1")]
2549    pub input: ::core::option::Option<::prost::alloc::boxed::Box<NumericExpression>>,
2550    #[prost(message, optional, tag = "2")]
2551    pub count: ::core::option::Option<IntegerConstant>,
2552    #[prost(enumeration = "PointLimitOrder", tag = "3")]
2553    pub order: i32,
2554}
2555#[derive(Clone, PartialEq, ::prost::Message)]
2556pub struct NumericNthPointDownsampleExpression {
2557    #[prost(message, optional, boxed, tag = "1")]
2558    pub input: ::core::option::Option<::prost::alloc::boxed::Box<NumericExpression>>,
2559    #[prost(message, optional, tag = "2")]
2560    pub n: ::core::option::Option<IntegerConstant>,
2561}
2562#[derive(Clone, PartialEq, ::prost::Message)]
2563pub struct NumericLargestTriangleThreeBucketsExpression {
2564    #[prost(message, optional, boxed, tag = "1")]
2565    pub input: ::core::option::Option<::prost::alloc::boxed::Box<NumericExpression>>,
2566    #[prost(message, optional, tag = "2")]
2567    pub max_points: ::core::option::Option<IntegerConstant>,
2568}
2569#[derive(Clone, PartialEq, ::prost::Message)]
2570pub struct NumericConditionFilterExpression {
2571    #[prost(message, optional, boxed, tag = "1")]
2572    pub input: ::core::option::Option<::prost::alloc::boxed::Box<NumericExpression>>,
2573    #[prost(message, optional, boxed, tag = "2")]
2574    pub condition: ::core::option::Option<::prost::alloc::boxed::Box<BooleanExpression>>,
2575}
2576#[derive(Clone, PartialEq, ::prost::Message)]
2577pub struct NumericThresholdFilterExpression {
2578    #[prost(message, optional, boxed, tag = "1")]
2579    pub input: ::core::option::Option<::prost::alloc::boxed::Box<NumericExpression>>,
2580    #[prost(message, optional, tag = "2")]
2581    pub threshold: ::core::option::Option<DoubleConstant>,
2582    #[prost(enumeration = "ComparisonOperation", tag = "3")]
2583    pub operation: i32,
2584}
2585#[derive(Clone, PartialEq, ::prost::Message)]
2586pub struct NumericApproximateFilterExpression {
2587    #[prost(message, optional, boxed, tag = "1")]
2588    pub input: ::core::option::Option<::prost::alloc::boxed::Box<NumericExpression>>,
2589    #[prost(message, optional, tag = "2")]
2590    pub threshold: ::core::option::Option<DoubleConstant>,
2591    #[prost(message, optional, tag = "3")]
2592    pub tolerance: ::core::option::Option<DoubleConstant>,
2593    #[prost(enumeration = "ApproximateComparisonOperation", tag = "4")]
2594    pub operation: i32,
2595}
2596#[derive(Clone, PartialEq, ::prost::Message)]
2597pub struct NumericSignalFilterExpression {
2598    #[prost(message, optional, boxed, tag = "1")]
2599    pub input: ::core::option::Option<::prost::alloc::boxed::Box<NumericExpression>>,
2600    #[prost(message, optional, tag = "2")]
2601    pub configuration: ::core::option::Option<SignalFilterConfiguration>,
2602    #[prost(message, optional, tag = "3")]
2603    pub order: ::core::option::Option<IntegerConstant>,
2604    #[prost(message, optional, tag = "4")]
2605    pub sampling_frequency: ::core::option::Option<DoubleConstant>,
2606}
2607#[derive(Clone, PartialEq, ::prost::Message)]
2608pub struct NumericUnitConversionExpression {
2609    #[prost(message, optional, boxed, tag = "1")]
2610    pub input: ::core::option::Option<::prost::alloc::boxed::Box<NumericExpression>>,
2611    #[prost(string, tag = "2")]
2612    pub output_unit: ::prost::alloc::string::String,
2613}
2614#[derive(Clone, PartialEq, ::prost::Message)]
2615pub struct NumericUnitOverrideExpression {
2616    #[prost(message, optional, boxed, tag = "1")]
2617    pub input: ::core::option::Option<::prost::alloc::boxed::Box<NumericExpression>>,
2618    #[prost(string, optional, tag = "2")]
2619    pub unit: ::core::option::Option<::prost::alloc::string::String>,
2620}
2621#[derive(Clone, PartialEq, ::prost::Message)]
2622pub struct NumericZScoreExpression {
2623    #[prost(message, optional, boxed, tag = "1")]
2624    pub input: ::core::option::Option<::prost::alloc::boxed::Box<NumericExpression>>,
2625    #[prost(message, repeated, tag = "2")]
2626    pub group_by_tags: ::prost::alloc::vec::Vec<StringConstant>,
2627    #[deprecated]
2628    #[prost(message, optional, tag = "3")]
2629    pub interpolation: ::core::option::Option<InterpolationConfiguration>,
2630}
2631#[derive(Clone, PartialEq, ::prost::Message)]
2632pub struct NumericUnionExpression {
2633    #[prost(message, repeated, tag = "1")]
2634    pub inputs: ::prost::alloc::vec::Vec<NumericExpression>,
2635    #[deprecated]
2636    #[prost(enumeration = "DuplicateMergeOperation", optional, tag = "2")]
2637    pub duplicate_merge_operation: ::core::option::Option<i32>,
2638}
2639#[derive(Clone, PartialEq, ::prost::Message)]
2640pub struct NumericDropNanExpression {
2641    #[prost(message, optional, boxed, tag = "1")]
2642    pub input: ::core::option::Option<::prost::alloc::boxed::Box<NumericExpression>>,
2643}
2644#[derive(Clone, PartialEq, ::prost::Message)]
2645pub struct NumericTimeShiftV2Expression {
2646    #[prost(message, optional, boxed, tag = "1")]
2647    pub input: ::core::option::Option<::prost::alloc::boxed::Box<NumericExpression>>,
2648    #[prost(message, optional, tag = "2")]
2649    pub duration: ::core::option::Option<DurationExpression>,
2650}
2651#[derive(Clone, PartialEq, ::prost::Message)]
2652pub struct NumericResampleV2Expression {
2653    #[prost(message, optional, boxed, tag = "1")]
2654    pub input: ::core::option::Option<::prost::alloc::boxed::Box<NumericExpression>>,
2655    #[prost(message, optional, tag = "2")]
2656    pub interval: ::core::option::Option<DurationExpression>,
2657}
2658#[derive(Clone, PartialEq, ::prost::Message)]
2659pub struct NumericToStartOfIntervalExpression {
2660    #[prost(message, optional, boxed, tag = "1")]
2661    pub input: ::core::option::Option<::prost::alloc::boxed::Box<NumericExpression>>,
2662    #[prost(message, optional, tag = "2")]
2663    pub interval: ::core::option::Option<DurationExpression>,
2664}
2665#[derive(Clone, PartialEq, ::prost::Message)]
2666pub struct NumericScalarTransformExpression {
2667    #[prost(message, optional, boxed, tag = "1")]
2668    pub input: ::core::option::Option<::prost::alloc::boxed::Box<NumericExpression>>,
2669    #[prost(oneof = "numeric_scalar_transform_expression::Transform", tags = "2, 3")]
2670    pub transform: ::core::option::Option<
2671        numeric_scalar_transform_expression::Transform,
2672    >,
2673}
2674/// Nested message and enum types in `NumericScalarTransformExpression`.
2675pub mod numeric_scalar_transform_expression {
2676    #[derive(Clone, PartialEq, ::prost::Oneof)]
2677    pub enum Transform {
2678        #[prost(message, tag = "2")]
2679        Offset(super::DoubleConstant),
2680        #[prost(message, tag = "3")]
2681        Scale(super::ScalingFactor),
2682    }
2683}
2684#[derive(Clone, PartialEq, ::prost::Message)]
2685pub struct NumericArithmeticExpression {
2686    #[prost(map = "string, message", tag = "1")]
2687    pub inputs: ::std::collections::HashMap<
2688        ::prost::alloc::string::String,
2689        NumericExpression,
2690    >,
2691    #[prost(string, tag = "2")]
2692    pub formula: ::prost::alloc::string::String,
2693    #[deprecated]
2694    #[prost(message, optional, tag = "3")]
2695    pub interpolation: ::core::option::Option<InterpolationConfiguration>,
2696}
2697#[derive(Clone, PartialEq, ::prost::Message)]
2698pub struct NumericFormulaFilterExpression {
2699    #[prost(string, tag = "1")]
2700    pub filtered_input_name: ::prost::alloc::string::String,
2701    #[prost(map = "string, message", tag = "2")]
2702    pub inputs: ::std::collections::HashMap<
2703        ::prost::alloc::string::String,
2704        NumericExpression,
2705    >,
2706    #[prost(string, tag = "3")]
2707    pub formula: ::prost::alloc::string::String,
2708    #[deprecated]
2709    #[prost(message, optional, tag = "4")]
2710    pub interpolation: ::core::option::Option<InterpolationConfiguration>,
2711}
2712#[derive(Clone, PartialEq, ::prost::Message)]
2713pub struct NumericLiteralBitwiseExpression {
2714    #[prost(message, optional, boxed, tag = "1")]
2715    pub input: ::core::option::Option<::prost::alloc::boxed::Box<NumericExpression>>,
2716    #[prost(message, optional, tag = "2")]
2717    pub function: ::core::option::Option<LiteralBitFunction>,
2718}
2719#[derive(Clone, Copy, PartialEq, ::prost::Message)]
2720pub struct LiteralBitFunction {
2721    #[prost(oneof = "literal_bit_function::Kind", tags = "1, 2, 3")]
2722    pub kind: ::core::option::Option<literal_bit_function::Kind>,
2723}
2724/// Nested message and enum types in `LiteralBitFunction`.
2725pub mod literal_bit_function {
2726    #[derive(Clone, Copy, PartialEq, ::prost::Oneof)]
2727    pub enum Kind {
2728        #[prost(message, tag = "1")]
2729        Bitwise(super::LiteralBitwiseFunction),
2730        #[prost(message, tag = "2")]
2731        Shift(super::LiteralShiftFunction),
2732        #[prost(message, tag = "3")]
2733        BitTest(super::BitTestIndex),
2734    }
2735}
2736#[derive(Clone, Copy, PartialEq, ::prost::Message)]
2737pub struct LiteralBitwiseFunction {
2738    #[prost(enumeration = "LiteralBitwiseOperation", tag = "1")]
2739    pub operation: i32,
2740    #[prost(int64, tag = "2")]
2741    pub operand: i64,
2742}
2743#[derive(Clone, Copy, PartialEq, ::prost::Message)]
2744pub struct LiteralShiftFunction {
2745    #[prost(enumeration = "ShiftDirection", tag = "1")]
2746    pub direction: i32,
2747    #[prost(int32, tag = "2")]
2748    pub distance: i32,
2749}
2750#[derive(Clone, Copy, PartialEq, ::prost::Message)]
2751pub struct BitTestIndex {
2752    #[prost(int32, tag = "1")]
2753    pub index: i32,
2754}
2755#[derive(Clone, PartialEq, ::prost::Message)]
2756pub struct NumericResampleExpression {
2757    #[prost(message, optional, boxed, tag = "1")]
2758    pub input: ::core::option::Option<::prost::alloc::boxed::Box<NumericExpression>>,
2759    #[prost(message, optional, tag = "2")]
2760    pub interval: ::core::option::Option<DurationConstant>,
2761    #[prost(message, optional, tag = "3")]
2762    pub fill: ::core::option::Option<ResampleFill>,
2763}
2764#[derive(Clone, PartialEq, ::prost::Message)]
2765pub struct NumericRefpropExpression {
2766    #[prost(message, repeated, tag = "1")]
2767    pub inputs: ::prost::alloc::vec::Vec<RefpropInput>,
2768    #[prost(enumeration = "RefpropProperty", tag = "2")]
2769    pub output_property: i32,
2770    #[prost(enumeration = "RefpropSubstance", tag = "3")]
2771    pub substance: i32,
2772    #[deprecated]
2773    #[prost(message, optional, tag = "4")]
2774    pub interpolation: ::core::option::Option<InterpolationConfiguration>,
2775}
2776#[derive(Clone, PartialEq, ::prost::Message)]
2777pub struct RefpropInput {
2778    #[prost(enumeration = "RefpropProperty", tag = "1")]
2779    pub property: i32,
2780    #[prost(message, optional, tag = "2")]
2781    pub value: ::core::option::Option<NumericExpression>,
2782}
2783#[derive(Clone, PartialEq, ::prost::Message)]
2784pub struct NumericRollingAggregationExpression {
2785    #[prost(message, optional, boxed, tag = "1")]
2786    pub input: ::core::option::Option<::prost::alloc::boxed::Box<NumericExpression>>,
2787    #[prost(message, optional, tag = "2")]
2788    pub window: ::core::option::Option<DurationConstant>,
2789    #[prost(message, optional, tag = "3")]
2790    pub reduction: ::core::option::Option<NumericReduction>,
2791}
2792#[derive(Clone, PartialEq, ::prost::Message)]
2793pub struct NumericDuplicateTimestampAggregationExpression {
2794    #[prost(message, optional, boxed, tag = "1")]
2795    pub input: ::core::option::Option<::prost::alloc::boxed::Box<NumericExpression>>,
2796    #[prost(message, optional, tag = "2")]
2797    pub reduction: ::core::option::Option<NumericReduction>,
2798    #[prost(message, repeated, tag = "3")]
2799    pub grouping_keys: ::prost::alloc::vec::Vec<StringConstant>,
2800    #[prost(bool, optional, tag = "4")]
2801    pub aggregate_across_all_series: ::core::option::Option<bool>,
2802    #[deprecated]
2803    #[prost(message, optional, tag = "5")]
2804    pub interpolation: ::core::option::Option<InterpolationConfiguration>,
2805}
2806#[derive(Clone, PartialEq, ::prost::Message)]
2807pub struct NumericTagFilterExpression {
2808    #[prost(message, optional, boxed, tag = "1")]
2809    pub input: ::core::option::Option<::prost::alloc::boxed::Box<NumericExpression>>,
2810    #[prost(message, optional, tag = "2")]
2811    pub predicate: ::core::option::Option<TagPredicateExpression>,
2812}
2813#[derive(Clone, PartialEq, ::prost::Message)]
2814pub struct NumericTagSelectionExpression {
2815    #[prost(message, optional, boxed, tag = "1")]
2816    pub input: ::core::option::Option<::prost::alloc::boxed::Box<NumericExpression>>,
2817    #[prost(message, repeated, tag = "2")]
2818    pub retained_tag_keys: ::prost::alloc::vec::Vec<StringConstant>,
2819}
2820#[derive(Clone, PartialEq, ::prost::Message)]
2821pub struct NumericArrayExpression {
2822    #[prost(
2823        oneof = "numeric_array_expression::Kind",
2824        tags = "1, 2, 3, 4, 5, 6, 7, 8, 9"
2825    )]
2826    pub kind: ::core::option::Option<numeric_array_expression::Kind>,
2827}
2828/// Nested message and enum types in `NumericArrayExpression`.
2829pub mod numeric_array_expression {
2830    #[derive(Clone, PartialEq, ::prost::Oneof)]
2831    pub enum Kind {
2832        #[prost(message, tag = "1")]
2833        Reference(super::TimeSeriesReference),
2834        #[prost(message, tag = "2")]
2835        ChannelSelection(super::ChannelSelection),
2836        #[prost(message, tag = "3")]
2837        ModuleFunction(super::ModuleFunctionExpression),
2838        #[prost(message, tag = "4")]
2839        SeriesSelection(::prost::alloc::boxed::Box<super::SeriesSelection>),
2840        #[prost(message, tag = "5")]
2841        StructField(
2842            ::prost::alloc::boxed::Box<super::NumericArrayStructFieldExpression>,
2843        ),
2844        #[prost(message, tag = "6")]
2845        TimeShift(::prost::alloc::boxed::Box<super::NumericArrayTimeShiftExpression>),
2846        #[prost(message, tag = "7")]
2847        ToStartOfInterval(
2848            ::prost::alloc::boxed::Box<super::NumericArrayToStartOfIntervalExpression>,
2849        ),
2850        #[prost(message, tag = "8")]
2851        TagFilter(::prost::alloc::boxed::Box<super::NumericArrayTagFilterExpression>),
2852        #[prost(message, tag = "9")]
2853        TagSelection(
2854            ::prost::alloc::boxed::Box<super::NumericArrayTagSelectionExpression>,
2855        ),
2856    }
2857}
2858#[derive(Clone, PartialEq, ::prost::Message)]
2859pub struct NumericArrayStructFieldExpression {
2860    #[prost(message, optional, boxed, tag = "1")]
2861    pub input: ::core::option::Option<::prost::alloc::boxed::Box<StructExpression>>,
2862    #[prost(message, repeated, tag = "2")]
2863    pub path: ::prost::alloc::vec::Vec<StringConstant>,
2864}
2865#[derive(Clone, PartialEq, ::prost::Message)]
2866pub struct NumericArrayTimeShiftExpression {
2867    #[prost(message, optional, boxed, tag = "1")]
2868    pub input: ::core::option::Option<
2869        ::prost::alloc::boxed::Box<NumericArrayExpression>,
2870    >,
2871    #[prost(message, optional, tag = "2")]
2872    pub duration: ::core::option::Option<DurationConstant>,
2873}
2874#[derive(Clone, PartialEq, ::prost::Message)]
2875pub struct NumericArrayToStartOfIntervalExpression {
2876    #[prost(message, optional, boxed, tag = "1")]
2877    pub input: ::core::option::Option<
2878        ::prost::alloc::boxed::Box<NumericArrayExpression>,
2879    >,
2880    #[prost(message, optional, tag = "2")]
2881    pub interval: ::core::option::Option<DurationExpression>,
2882}
2883#[derive(Clone, PartialEq, ::prost::Message)]
2884pub struct NumericArrayTagFilterExpression {
2885    #[prost(message, optional, boxed, tag = "1")]
2886    pub input: ::core::option::Option<
2887        ::prost::alloc::boxed::Box<NumericArrayExpression>,
2888    >,
2889    #[prost(message, optional, tag = "2")]
2890    pub predicate: ::core::option::Option<TagPredicateExpression>,
2891}
2892#[derive(Clone, PartialEq, ::prost::Message)]
2893pub struct NumericArrayTagSelectionExpression {
2894    #[prost(message, optional, boxed, tag = "1")]
2895    pub input: ::core::option::Option<
2896        ::prost::alloc::boxed::Box<NumericArrayExpression>,
2897    >,
2898    #[prost(message, optional, tag = "2")]
2899    pub keys: ::core::option::Option<TagKeySet>,
2900}
2901#[derive(Clone, PartialEq, ::prost::Message)]
2902pub struct CategoricalArrayExpression {
2903    #[prost(
2904        oneof = "categorical_array_expression::Kind",
2905        tags = "1, 2, 3, 4, 5, 6, 7, 8, 9"
2906    )]
2907    pub kind: ::core::option::Option<categorical_array_expression::Kind>,
2908}
2909/// Nested message and enum types in `CategoricalArrayExpression`.
2910pub mod categorical_array_expression {
2911    #[derive(Clone, PartialEq, ::prost::Oneof)]
2912    pub enum Kind {
2913        #[prost(message, tag = "1")]
2914        Reference(super::TimeSeriesReference),
2915        #[prost(message, tag = "2")]
2916        ChannelSelection(super::ChannelSelection),
2917        #[prost(message, tag = "3")]
2918        ModuleFunction(super::ModuleFunctionExpression),
2919        #[prost(message, tag = "4")]
2920        SeriesSelection(::prost::alloc::boxed::Box<super::SeriesSelection>),
2921        #[prost(message, tag = "5")]
2922        StructField(
2923            ::prost::alloc::boxed::Box<super::CategoricalArrayStructFieldExpression>,
2924        ),
2925        #[prost(message, tag = "6")]
2926        TimeShift(
2927            ::prost::alloc::boxed::Box<super::CategoricalArrayTimeShiftExpression>,
2928        ),
2929        #[prost(message, tag = "7")]
2930        ToStartOfInterval(
2931            ::prost::alloc::boxed::Box<
2932                super::CategoricalArrayToStartOfIntervalExpression,
2933            >,
2934        ),
2935        #[prost(message, tag = "8")]
2936        TagFilter(
2937            ::prost::alloc::boxed::Box<super::CategoricalArrayTagFilterExpression>,
2938        ),
2939        #[prost(message, tag = "9")]
2940        TagSelection(
2941            ::prost::alloc::boxed::Box<super::CategoricalArrayTagSelectionExpression>,
2942        ),
2943    }
2944}
2945#[derive(Clone, PartialEq, ::prost::Message)]
2946pub struct CategoricalArrayStructFieldExpression {
2947    #[prost(message, optional, boxed, tag = "1")]
2948    pub input: ::core::option::Option<::prost::alloc::boxed::Box<StructExpression>>,
2949    #[prost(message, repeated, tag = "2")]
2950    pub path: ::prost::alloc::vec::Vec<StringConstant>,
2951}
2952#[derive(Clone, PartialEq, ::prost::Message)]
2953pub struct CategoricalArrayTimeShiftExpression {
2954    #[prost(message, optional, boxed, tag = "1")]
2955    pub input: ::core::option::Option<
2956        ::prost::alloc::boxed::Box<CategoricalArrayExpression>,
2957    >,
2958    #[prost(message, optional, tag = "2")]
2959    pub duration: ::core::option::Option<DurationConstant>,
2960}
2961#[derive(Clone, PartialEq, ::prost::Message)]
2962pub struct CategoricalArrayToStartOfIntervalExpression {
2963    #[prost(message, optional, boxed, tag = "1")]
2964    pub input: ::core::option::Option<
2965        ::prost::alloc::boxed::Box<CategoricalArrayExpression>,
2966    >,
2967    #[prost(message, optional, tag = "2")]
2968    pub interval: ::core::option::Option<DurationExpression>,
2969}
2970#[derive(Clone, PartialEq, ::prost::Message)]
2971pub struct CategoricalArrayTagFilterExpression {
2972    #[prost(message, optional, boxed, tag = "1")]
2973    pub input: ::core::option::Option<
2974        ::prost::alloc::boxed::Box<CategoricalArrayExpression>,
2975    >,
2976    #[prost(message, optional, tag = "2")]
2977    pub predicate: ::core::option::Option<TagPredicateExpression>,
2978}
2979#[derive(Clone, PartialEq, ::prost::Message)]
2980pub struct CategoricalArrayTagSelectionExpression {
2981    #[prost(message, optional, boxed, tag = "1")]
2982    pub input: ::core::option::Option<
2983        ::prost::alloc::boxed::Box<CategoricalArrayExpression>,
2984    >,
2985    #[prost(message, optional, tag = "2")]
2986    pub keys: ::core::option::Option<TagKeySet>,
2987}
2988#[derive(Clone, PartialEq, ::prost::Message)]
2989pub struct StructExpression {
2990    #[prost(oneof = "struct_expression::Kind", tags = "1, 2, 3, 4, 5, 6, 7, 8, 9, 10")]
2991    pub kind: ::core::option::Option<struct_expression::Kind>,
2992}
2993/// Nested message and enum types in `StructExpression`.
2994pub mod struct_expression {
2995    #[derive(Clone, PartialEq, ::prost::Oneof)]
2996    pub enum Kind {
2997        #[prost(message, tag = "1")]
2998        Reference(super::TimeSeriesReference),
2999        #[prost(message, tag = "2")]
3000        ChannelSelection(super::ChannelSelection),
3001        #[prost(message, tag = "3")]
3002        ModuleFunction(super::ModuleFunctionExpression),
3003        #[prost(message, tag = "4")]
3004        SeriesSelection(::prost::alloc::boxed::Box<super::SeriesSelection>),
3005        #[prost(message, tag = "5")]
3006        Combine(super::StructCombineExpression),
3007        #[prost(message, tag = "6")]
3008        StructField(::prost::alloc::boxed::Box<super::StructFieldExpression>),
3009        #[prost(message, tag = "7")]
3010        TimeShift(::prost::alloc::boxed::Box<super::StructTimeShiftExpression>),
3011        #[prost(message, tag = "8")]
3012        ToStartOfInterval(
3013            ::prost::alloc::boxed::Box<super::StructToStartOfIntervalExpression>,
3014        ),
3015        #[prost(message, tag = "9")]
3016        TagFilter(::prost::alloc::boxed::Box<super::StructTagFilterExpression>),
3017        #[prost(message, tag = "10")]
3018        TagSelection(::prost::alloc::boxed::Box<super::StructTagSelectionExpression>),
3019    }
3020}
3021#[derive(Clone, PartialEq, ::prost::Message)]
3022pub struct StructFieldExpression {
3023    #[prost(message, optional, boxed, tag = "1")]
3024    pub input: ::core::option::Option<::prost::alloc::boxed::Box<StructExpression>>,
3025    #[prost(message, repeated, tag = "2")]
3026    pub path: ::prost::alloc::vec::Vec<StringConstant>,
3027}
3028#[derive(Clone, PartialEq, ::prost::Message)]
3029pub struct StructTimeShiftExpression {
3030    #[prost(message, optional, boxed, tag = "1")]
3031    pub input: ::core::option::Option<::prost::alloc::boxed::Box<StructExpression>>,
3032    #[prost(message, optional, tag = "2")]
3033    pub duration: ::core::option::Option<DurationConstant>,
3034}
3035#[derive(Clone, PartialEq, ::prost::Message)]
3036pub struct StructToStartOfIntervalExpression {
3037    #[prost(message, optional, boxed, tag = "1")]
3038    pub input: ::core::option::Option<::prost::alloc::boxed::Box<StructExpression>>,
3039    #[prost(message, optional, tag = "2")]
3040    pub interval: ::core::option::Option<DurationExpression>,
3041}
3042#[derive(Clone, PartialEq, ::prost::Message)]
3043pub struct StructTagFilterExpression {
3044    #[prost(message, optional, boxed, tag = "1")]
3045    pub input: ::core::option::Option<::prost::alloc::boxed::Box<StructExpression>>,
3046    #[prost(message, optional, tag = "2")]
3047    pub predicate: ::core::option::Option<TagPredicateExpression>,
3048}
3049#[derive(Clone, PartialEq, ::prost::Message)]
3050pub struct StructTagSelectionExpression {
3051    #[prost(message, optional, boxed, tag = "1")]
3052    pub input: ::core::option::Option<::prost::alloc::boxed::Box<StructExpression>>,
3053    #[prost(message, optional, tag = "2")]
3054    pub keys: ::core::option::Option<TagKeySet>,
3055}
3056#[derive(Clone, PartialEq, ::prost::Message)]
3057pub struct LogExpression {
3058    #[prost(oneof = "log_expression::Kind", tags = "1, 2, 3, 4, 5, 6, 7, 8, 9, 10")]
3059    pub kind: ::core::option::Option<log_expression::Kind>,
3060}
3061/// Nested message and enum types in `LogExpression`.
3062pub mod log_expression {
3063    #[derive(Clone, PartialEq, ::prost::Oneof)]
3064    pub enum Kind {
3065        #[prost(message, tag = "1")]
3066        Reference(super::TimeSeriesReference),
3067        #[prost(message, tag = "2")]
3068        ChannelSelection(super::ChannelSelection),
3069        #[prost(message, tag = "3")]
3070        ModuleFunction(super::ModuleFunctionExpression),
3071        #[prost(message, tag = "4")]
3072        SeriesSelection(::prost::alloc::boxed::Box<super::SeriesSelection>),
3073        #[prost(message, tag = "5")]
3074        Concatenate(super::LogConcatenateExpression),
3075        #[prost(message, tag = "6")]
3076        Filter(::prost::alloc::boxed::Box<super::LogFilterExpression>),
3077        #[prost(message, tag = "7")]
3078        TimeShift(::prost::alloc::boxed::Box<super::LogTimeShiftExpression>),
3079        #[prost(message, tag = "8")]
3080        ToStartOfInterval(
3081            ::prost::alloc::boxed::Box<super::LogToStartOfIntervalExpression>,
3082        ),
3083        #[prost(message, tag = "9")]
3084        TagFilter(::prost::alloc::boxed::Box<super::LogTagFilterExpression>),
3085        #[prost(message, tag = "10")]
3086        TagSelection(::prost::alloc::boxed::Box<super::LogTagSelectionExpression>),
3087    }
3088}
3089#[derive(Clone, PartialEq, ::prost::Message)]
3090pub struct LogTimeShiftExpression {
3091    #[prost(message, optional, boxed, tag = "1")]
3092    pub input: ::core::option::Option<::prost::alloc::boxed::Box<LogExpression>>,
3093    #[prost(message, optional, tag = "2")]
3094    pub duration: ::core::option::Option<DurationConstant>,
3095}
3096#[derive(Clone, PartialEq, ::prost::Message)]
3097pub struct LogToStartOfIntervalExpression {
3098    #[prost(message, optional, boxed, tag = "1")]
3099    pub input: ::core::option::Option<::prost::alloc::boxed::Box<LogExpression>>,
3100    #[prost(message, optional, tag = "2")]
3101    pub interval: ::core::option::Option<DurationExpression>,
3102}
3103#[derive(Clone, PartialEq, ::prost::Message)]
3104pub struct LogTagFilterExpression {
3105    #[prost(message, optional, boxed, tag = "1")]
3106    pub input: ::core::option::Option<::prost::alloc::boxed::Box<LogExpression>>,
3107    #[prost(message, optional, tag = "2")]
3108    pub predicate: ::core::option::Option<TagPredicateExpression>,
3109}
3110#[derive(Clone, PartialEq, ::prost::Message)]
3111pub struct LogTagSelectionExpression {
3112    #[prost(message, optional, boxed, tag = "1")]
3113    pub input: ::core::option::Option<::prost::alloc::boxed::Box<LogExpression>>,
3114    #[prost(message, optional, tag = "2")]
3115    pub keys: ::core::option::Option<TagKeySet>,
3116}
3117#[derive(Clone, PartialEq, ::prost::Message)]
3118pub struct StructCombineExpression {
3119    #[prost(map = "string, message", tag = "1")]
3120    pub fields: ::std::collections::HashMap<
3121        ::prost::alloc::string::String,
3122        SeriesExpression,
3123    >,
3124    #[prost(message, optional, tag = "2")]
3125    pub interpolation: ::core::option::Option<InterpolationConfiguration>,
3126}
3127#[derive(Clone, PartialEq, ::prost::Message)]
3128pub struct LogConcatenateExpression {
3129    #[prost(message, repeated, tag = "1")]
3130    pub inputs: ::prost::alloc::vec::Vec<LogExpression>,
3131}
3132#[derive(Clone, PartialEq, ::prost::Message)]
3133pub struct LogFilterExpression {
3134    #[prost(message, optional, boxed, tag = "1")]
3135    pub input: ::core::option::Option<::prost::alloc::boxed::Box<LogExpression>>,
3136    #[prost(message, optional, tag = "2")]
3137    pub predicate: ::core::option::Option<LogPredicate>,
3138}
3139#[derive(Clone, PartialEq, ::prost::Message)]
3140pub struct RangeExpression {
3141    #[prost(
3142        oneof = "range_expression::Kind",
3143        tags = "1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21"
3144    )]
3145    pub kind: ::core::option::Option<range_expression::Kind>,
3146}
3147/// Nested message and enum types in `RangeExpression`.
3148pub mod range_expression {
3149    #[derive(Clone, PartialEq, ::prost::Oneof)]
3150    pub enum Kind {
3151        #[prost(string, tag = "1")]
3152        VariableName(::prost::alloc::string::String),
3153        #[prost(message, tag = "2")]
3154        ModuleFunction(super::ModuleFunctionExpression),
3155        #[prost(message, tag = "3")]
3156        Literal(super::LiteralRangeCollection),
3157        #[prost(message, tag = "4")]
3158        Events(super::EventPredicateExpression),
3159        #[prost(message, tag = "5")]
3160        BooleanCondition(::prost::alloc::boxed::Box<super::BooleanRangeExpression>),
3161        #[prost(message, tag = "6")]
3162        NumericThreshold(::prost::alloc::boxed::Box<super::NumericThresholdRanges>),
3163        #[prost(message, tag = "7")]
3164        NumericBounds(::prost::alloc::boxed::Box<super::NumericBoundsRanges>),
3165        #[prost(message, tag = "8")]
3166        CategoricalMembership(
3167            ::prost::alloc::boxed::Box<super::CategoricalMembershipRanges>,
3168        ),
3169        #[prost(message, tag = "9")]
3170        NumericEquality(super::NumericEqualityRanges),
3171        #[prost(message, tag = "10")]
3172        CategoricalEquality(super::CategoricalEqualityRanges),
3173        #[prost(message, tag = "11")]
3174        NumericCrossover(::prost::alloc::boxed::Box<super::NumericCrossoverRanges>),
3175        #[prost(message, tag = "12")]
3176        OnChange(::prost::alloc::boxed::Box<super::SeriesChangeRanges>),
3177        #[prost(message, tag = "13")]
3178        Staleness(::prost::alloc::boxed::Box<super::SeriesStalenessRanges>),
3179        #[prost(message, tag = "14")]
3180        DurationFilter(::prost::alloc::boxed::Box<super::RangeDurationFilter>),
3181        #[prost(message, tag = "15")]
3182        Stability(::prost::alloc::boxed::Box<super::NumericStabilityRanges>),
3183        #[prost(message, tag = "16")]
3184        Extrema(::prost::alloc::boxed::Box<super::NumericExtremaRanges>),
3185        #[prost(message, tag = "17")]
3186        Intersection(super::RangeExpressionCollection),
3187        #[prost(message, tag = "18")]
3188        Union(super::RangeExpressionCollection),
3189        #[prost(message, tag = "19")]
3190        Complement(::prost::alloc::boxed::Box<super::RangeExpression>),
3191        #[prost(message, tag = "20")]
3192        Padding(::prost::alloc::boxed::Box<super::RangePaddingExpression>),
3193        #[prost(message, tag = "21")]
3194        Statistics(::prost::alloc::boxed::Box<super::RangeStatisticsExpression>),
3195    }
3196}
3197#[derive(Clone, PartialEq, ::prost::Message)]
3198pub struct LiteralRangeCollection {
3199    #[prost(message, repeated, tag = "1")]
3200    pub ranges: ::prost::alloc::vec::Vec<LiteralRange>,
3201}
3202#[derive(Clone, PartialEq, ::prost::Message)]
3203pub struct LiteralRange {
3204    #[prost(message, optional, tag = "1")]
3205    pub start: ::core::option::Option<TimestampConstant>,
3206    #[prost(message, optional, tag = "2")]
3207    pub end: ::core::option::Option<TimestampConstant>,
3208    #[prost(message, optional, tag = "3")]
3209    pub grouping: ::core::option::Option<TagGrouping>,
3210}
3211#[derive(Clone, PartialEq, ::prost::Message)]
3212pub struct BooleanRangeExpression {
3213    #[prost(message, optional, boxed, tag = "1")]
3214    pub input: ::core::option::Option<::prost::alloc::boxed::Box<BooleanExpression>>,
3215    #[prost(message, optional, tag = "2")]
3216    pub persistence: ::core::option::Option<RangePersistence>,
3217}
3218#[derive(Clone, PartialEq, ::prost::Message)]
3219pub struct NumericThresholdRanges {
3220    #[prost(message, optional, boxed, tag = "1")]
3221    pub input: ::core::option::Option<::prost::alloc::boxed::Box<NumericExpression>>,
3222    #[prost(enumeration = "ComparisonOperation", tag = "2")]
3223    pub comparison: i32,
3224    #[prost(message, optional, tag = "3")]
3225    pub threshold: ::core::option::Option<DoubleConstant>,
3226    #[prost(message, optional, tag = "4")]
3227    pub tolerance: ::core::option::Option<DoubleConstant>,
3228    #[prost(message, optional, tag = "5")]
3229    pub persistence: ::core::option::Option<RangePersistence>,
3230}
3231#[derive(Clone, PartialEq, ::prost::Message)]
3232pub struct NumericBoundsRanges {
3233    #[prost(message, optional, boxed, tag = "1")]
3234    pub input: ::core::option::Option<::prost::alloc::boxed::Box<NumericExpression>>,
3235    #[prost(message, optional, tag = "2")]
3236    pub lower: ::core::option::Option<DoubleConstant>,
3237    #[prost(message, optional, tag = "3")]
3238    pub upper: ::core::option::Option<DoubleConstant>,
3239    #[prost(enumeration = "NumericBoundsCondition", tag = "4")]
3240    pub condition: i32,
3241    #[prost(message, optional, tag = "5")]
3242    pub persistence: ::core::option::Option<RangePersistence>,
3243}
3244#[derive(Clone, PartialEq, ::prost::Message)]
3245pub struct CategoricalMembershipRanges {
3246    #[prost(message, optional, boxed, tag = "1")]
3247    pub input: ::core::option::Option<::prost::alloc::boxed::Box<CategoricalExpression>>,
3248    #[prost(message, optional, tag = "2")]
3249    pub values: ::core::option::Option<ParameterizedStringSet>,
3250    #[prost(enumeration = "CategoricalMembershipOperation", tag = "3")]
3251    pub operation: i32,
3252    #[prost(message, optional, tag = "4")]
3253    pub persistence: ::core::option::Option<RangePersistence>,
3254}
3255#[derive(Clone, PartialEq, ::prost::Message)]
3256pub struct NumericEqualityRanges {
3257    #[prost(message, repeated, tag = "1")]
3258    pub inputs: ::prost::alloc::vec::Vec<NumericExpression>,
3259    #[prost(enumeration = "SeriesEqualityMode", tag = "2")]
3260    pub mode: i32,
3261    #[prost(message, optional, tag = "3")]
3262    pub tolerance: ::core::option::Option<DoubleConstant>,
3263    #[prost(message, optional, tag = "4")]
3264    pub persistence: ::core::option::Option<RangePersistence>,
3265    #[deprecated]
3266    #[prost(message, optional, tag = "5")]
3267    pub interpolation: ::core::option::Option<InterpolationConfiguration>,
3268}
3269#[derive(Clone, PartialEq, ::prost::Message)]
3270pub struct CategoricalEqualityRanges {
3271    #[prost(message, repeated, tag = "1")]
3272    pub inputs: ::prost::alloc::vec::Vec<CategoricalExpression>,
3273    #[prost(enumeration = "SeriesEqualityMode", tag = "2")]
3274    pub mode: i32,
3275    #[prost(message, optional, tag = "3")]
3276    pub persistence: ::core::option::Option<RangePersistence>,
3277    #[deprecated]
3278    #[prost(message, optional, tag = "4")]
3279    pub interpolation: ::core::option::Option<InterpolationConfiguration>,
3280}
3281#[derive(Clone, PartialEq, ::prost::Message)]
3282pub struct NumericCrossoverRanges {
3283    #[prost(message, optional, boxed, tag = "1")]
3284    pub left: ::core::option::Option<::prost::alloc::boxed::Box<NumericExpression>>,
3285    #[prost(message, optional, boxed, tag = "2")]
3286    pub right: ::core::option::Option<::prost::alloc::boxed::Box<NumericExpression>>,
3287}
3288#[derive(Clone, PartialEq, ::prost::Message)]
3289pub struct SeriesChangeRanges {
3290    #[prost(message, optional, boxed, tag = "1")]
3291    pub input: ::core::option::Option<::prost::alloc::boxed::Box<SeriesExpression>>,
3292}
3293#[derive(Clone, PartialEq, ::prost::Message)]
3294pub struct SeriesStalenessRanges {
3295    #[prost(message, optional, boxed, tag = "1")]
3296    pub input: ::core::option::Option<::prost::alloc::boxed::Box<SeriesExpression>>,
3297    #[prost(message, optional, tag = "2")]
3298    pub threshold: ::core::option::Option<DurationInput>,
3299    #[prost(message, optional, tag = "3")]
3300    pub start: ::core::option::Option<TimestampConstant>,
3301    #[deprecated]
3302    #[prost(message, optional, tag = "4")]
3303    pub end: ::core::option::Option<TimestampConstant>,
3304}
3305#[derive(Clone, PartialEq, ::prost::Message)]
3306pub struct RangeDurationFilter {
3307    #[prost(message, optional, boxed, tag = "1")]
3308    pub input: ::core::option::Option<::prost::alloc::boxed::Box<RangeExpression>>,
3309    #[prost(message, optional, tag = "2")]
3310    pub threshold: ::core::option::Option<DurationInput>,
3311    #[prost(enumeration = "ComparisonOperation", tag = "3")]
3312    pub comparison: i32,
3313    #[prost(enumeration = "UnboundedDurationComparison", optional, tag = "4")]
3314    pub unbounded: ::core::option::Option<i32>,
3315}
3316#[derive(Clone, PartialEq, ::prost::Message)]
3317pub struct NumericStabilityRanges {
3318    #[prost(message, optional, boxed, tag = "1")]
3319    pub input: ::core::option::Option<::prost::alloc::boxed::Box<NumericExpression>>,
3320    #[prost(message, optional, tag = "2")]
3321    pub window: ::core::option::Option<DurationInput>,
3322    #[prost(message, optional, tag = "3")]
3323    pub min_points: ::core::option::Option<IntegerConstant>,
3324    #[prost(message, optional, tag = "4")]
3325    pub threshold: ::core::option::Option<SpreadThreshold>,
3326}
3327#[derive(Clone, PartialEq, ::prost::Message)]
3328pub struct NumericExtremaRanges {
3329    #[prost(message, optional, boxed, tag = "1")]
3330    pub input: ::core::option::Option<::prost::alloc::boxed::Box<NumericExpression>>,
3331    #[prost(enumeration = "ExtremaSelection", tag = "2")]
3332    pub selection: i32,
3333    #[prost(message, optional, tag = "3")]
3334    pub min_prominence: ::core::option::Option<DoubleConstant>,
3335}
3336#[derive(Clone, PartialEq, ::prost::Message)]
3337pub struct RangeExpressionCollection {
3338    #[prost(message, repeated, tag = "1")]
3339    pub inputs: ::prost::alloc::vec::Vec<RangeExpression>,
3340}
3341#[derive(Clone, PartialEq, ::prost::Message)]
3342pub struct RangePaddingExpression {
3343    #[prost(message, optional, boxed, tag = "1")]
3344    pub input: ::core::option::Option<::prost::alloc::boxed::Box<RangeExpression>>,
3345    #[prost(message, optional, tag = "2")]
3346    pub padding: ::core::option::Option<DurationInput>,
3347    #[prost(enumeration = "RangePaddingSides", optional, tag = "3")]
3348    pub sides: ::core::option::Option<i32>,
3349}
3350#[derive(Clone, PartialEq, ::prost::Message)]
3351pub struct RangeStatisticsExpression {
3352    #[prost(message, optional, boxed, tag = "1")]
3353    pub ranges: ::core::option::Option<::prost::alloc::boxed::Box<RangeExpression>>,
3354    #[prost(message, optional, boxed, tag = "2")]
3355    pub input: ::core::option::Option<::prost::alloc::boxed::Box<NumericExpression>>,
3356    #[prost(oneof = "range_statistics_expression::Statistics", tags = "3, 4")]
3357    pub statistics: ::core::option::Option<range_statistics_expression::Statistics>,
3358}
3359/// Nested message and enum types in `RangeStatisticsExpression`.
3360pub mod range_statistics_expression {
3361    #[derive(Clone, PartialEq, ::prost::Oneof)]
3362    pub enum Statistics {
3363        #[prost(message, tag = "3")]
3364        Reduction(super::NumericReduction),
3365        #[prost(message, tag = "4")]
3366        All(super::AllStatistics),
3367    }
3368}
3369#[derive(Clone, Copy, PartialEq, ::prost::Message)]
3370pub struct AllStatistics {}
3371#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
3372#[repr(i32)]
3373pub enum ComputeAlignmentStrategy {
3374    Unspecified = 0,
3375    DriverSeries = 1,
3376    Union = 2,
3377}
3378impl ComputeAlignmentStrategy {
3379    /// String value of the enum field names used in the ProtoBuf definition.
3380    ///
3381    /// The values are not transformed in any way and thus are considered stable
3382    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
3383    pub fn as_str_name(&self) -> &'static str {
3384        match self {
3385            Self::Unspecified => "COMPUTE_ALIGNMENT_STRATEGY_UNSPECIFIED",
3386            Self::DriverSeries => "COMPUTE_ALIGNMENT_STRATEGY_DRIVER_SERIES",
3387            Self::Union => "COMPUTE_ALIGNMENT_STRATEGY_UNION",
3388        }
3389    }
3390    /// Creates an enum from field names used in the ProtoBuf definition.
3391    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
3392        match value {
3393            "COMPUTE_ALIGNMENT_STRATEGY_UNSPECIFIED" => Some(Self::Unspecified),
3394            "COMPUTE_ALIGNMENT_STRATEGY_DRIVER_SERIES" => Some(Self::DriverSeries),
3395            "COMPUTE_ALIGNMENT_STRATEGY_UNION" => Some(Self::Union),
3396            _ => None,
3397        }
3398    }
3399}
3400#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
3401#[repr(i32)]
3402pub enum BuiltinCurveForm {
3403    Unspecified = 0,
3404    Exponential = 1,
3405    Logarithmic = 2,
3406    Power = 3,
3407}
3408impl BuiltinCurveForm {
3409    /// String value of the enum field names used in the ProtoBuf definition.
3410    ///
3411    /// The values are not transformed in any way and thus are considered stable
3412    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
3413    pub fn as_str_name(&self) -> &'static str {
3414        match self {
3415            Self::Unspecified => "BUILTIN_CURVE_FORM_UNSPECIFIED",
3416            Self::Exponential => "BUILTIN_CURVE_FORM_EXPONENTIAL",
3417            Self::Logarithmic => "BUILTIN_CURVE_FORM_LOGARITHMIC",
3418            Self::Power => "BUILTIN_CURVE_FORM_POWER",
3419        }
3420    }
3421    /// Creates an enum from field names used in the ProtoBuf definition.
3422    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
3423        match value {
3424            "BUILTIN_CURVE_FORM_UNSPECIFIED" => Some(Self::Unspecified),
3425            "BUILTIN_CURVE_FORM_EXPONENTIAL" => Some(Self::Exponential),
3426            "BUILTIN_CURVE_FORM_LOGARITHMIC" => Some(Self::Logarithmic),
3427            "BUILTIN_CURVE_FORM_POWER" => Some(Self::Power),
3428            _ => None,
3429        }
3430    }
3431}
3432#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
3433#[repr(i32)]
3434pub enum UnboundedRangePolicy {
3435    Unspecified = 0,
3436    ClampToWindow = 1,
3437    Drop = 2,
3438}
3439impl UnboundedRangePolicy {
3440    /// String value of the enum field names used in the ProtoBuf definition.
3441    ///
3442    /// The values are not transformed in any way and thus are considered stable
3443    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
3444    pub fn as_str_name(&self) -> &'static str {
3445        match self {
3446            Self::Unspecified => "UNBOUNDED_RANGE_POLICY_UNSPECIFIED",
3447            Self::ClampToWindow => "UNBOUNDED_RANGE_POLICY_CLAMP_TO_WINDOW",
3448            Self::Drop => "UNBOUNDED_RANGE_POLICY_DROP",
3449        }
3450    }
3451    /// Creates an enum from field names used in the ProtoBuf definition.
3452    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
3453        match value {
3454            "UNBOUNDED_RANGE_POLICY_UNSPECIFIED" => Some(Self::Unspecified),
3455            "UNBOUNDED_RANGE_POLICY_CLAMP_TO_WINDOW" => Some(Self::ClampToWindow),
3456            "UNBOUNDED_RANGE_POLICY_DROP" => Some(Self::Drop),
3457            _ => None,
3458        }
3459    }
3460}
3461#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
3462#[repr(i32)]
3463pub enum ChronologicalOrder {
3464    Unspecified = 0,
3465    Ascending = 1,
3466    Descending = 2,
3467}
3468impl ChronologicalOrder {
3469    /// String value of the enum field names used in the ProtoBuf definition.
3470    ///
3471    /// The values are not transformed in any way and thus are considered stable
3472    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
3473    pub fn as_str_name(&self) -> &'static str {
3474        match self {
3475            Self::Unspecified => "CHRONOLOGICAL_ORDER_UNSPECIFIED",
3476            Self::Ascending => "CHRONOLOGICAL_ORDER_ASCENDING",
3477            Self::Descending => "CHRONOLOGICAL_ORDER_DESCENDING",
3478        }
3479    }
3480    /// Creates an enum from field names used in the ProtoBuf definition.
3481    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
3482        match value {
3483            "CHRONOLOGICAL_ORDER_UNSPECIFIED" => Some(Self::Unspecified),
3484            "CHRONOLOGICAL_ORDER_ASCENDING" => Some(Self::Ascending),
3485            "CHRONOLOGICAL_ORDER_DESCENDING" => Some(Self::Descending),
3486            _ => None,
3487        }
3488    }
3489}
3490#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
3491#[repr(i32)]
3492pub enum UnaryNumericOperation {
3493    Unspecified = 0,
3494    Abs = 1,
3495    Negate = 2,
3496    Cos = 3,
3497    Sin = 4,
3498    Tan = 5,
3499    Acos = 6,
3500    Asin = 7,
3501    Ln = 8,
3502    Log10 = 9,
3503    Sqrt = 10,
3504}
3505impl UnaryNumericOperation {
3506    /// String value of the enum field names used in the ProtoBuf definition.
3507    ///
3508    /// The values are not transformed in any way and thus are considered stable
3509    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
3510    pub fn as_str_name(&self) -> &'static str {
3511        match self {
3512            Self::Unspecified => "UNARY_NUMERIC_OPERATION_UNSPECIFIED",
3513            Self::Abs => "UNARY_NUMERIC_OPERATION_ABS",
3514            Self::Negate => "UNARY_NUMERIC_OPERATION_NEGATE",
3515            Self::Cos => "UNARY_NUMERIC_OPERATION_COS",
3516            Self::Sin => "UNARY_NUMERIC_OPERATION_SIN",
3517            Self::Tan => "UNARY_NUMERIC_OPERATION_TAN",
3518            Self::Acos => "UNARY_NUMERIC_OPERATION_ACOS",
3519            Self::Asin => "UNARY_NUMERIC_OPERATION_ASIN",
3520            Self::Ln => "UNARY_NUMERIC_OPERATION_LN",
3521            Self::Log10 => "UNARY_NUMERIC_OPERATION_LOG10",
3522            Self::Sqrt => "UNARY_NUMERIC_OPERATION_SQRT",
3523        }
3524    }
3525    /// Creates an enum from field names used in the ProtoBuf definition.
3526    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
3527        match value {
3528            "UNARY_NUMERIC_OPERATION_UNSPECIFIED" => Some(Self::Unspecified),
3529            "UNARY_NUMERIC_OPERATION_ABS" => Some(Self::Abs),
3530            "UNARY_NUMERIC_OPERATION_NEGATE" => Some(Self::Negate),
3531            "UNARY_NUMERIC_OPERATION_COS" => Some(Self::Cos),
3532            "UNARY_NUMERIC_OPERATION_SIN" => Some(Self::Sin),
3533            "UNARY_NUMERIC_OPERATION_TAN" => Some(Self::Tan),
3534            "UNARY_NUMERIC_OPERATION_ACOS" => Some(Self::Acos),
3535            "UNARY_NUMERIC_OPERATION_ASIN" => Some(Self::Asin),
3536            "UNARY_NUMERIC_OPERATION_LN" => Some(Self::Ln),
3537            "UNARY_NUMERIC_OPERATION_LOG10" => Some(Self::Log10),
3538            "UNARY_NUMERIC_OPERATION_SQRT" => Some(Self::Sqrt),
3539            _ => None,
3540        }
3541    }
3542}
3543#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
3544#[repr(i32)]
3545pub enum BinaryNumericOperation {
3546    Unspecified = 0,
3547    Add = 1,
3548    Subtract = 2,
3549    Multiply = 3,
3550    Divide = 4,
3551    FloorDivide = 5,
3552    Power = 6,
3553    Modulo = 7,
3554    Atan2 = 8,
3555}
3556impl BinaryNumericOperation {
3557    /// String value of the enum field names used in the ProtoBuf definition.
3558    ///
3559    /// The values are not transformed in any way and thus are considered stable
3560    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
3561    pub fn as_str_name(&self) -> &'static str {
3562        match self {
3563            Self::Unspecified => "BINARY_NUMERIC_OPERATION_UNSPECIFIED",
3564            Self::Add => "BINARY_NUMERIC_OPERATION_ADD",
3565            Self::Subtract => "BINARY_NUMERIC_OPERATION_SUBTRACT",
3566            Self::Multiply => "BINARY_NUMERIC_OPERATION_MULTIPLY",
3567            Self::Divide => "BINARY_NUMERIC_OPERATION_DIVIDE",
3568            Self::FloorDivide => "BINARY_NUMERIC_OPERATION_FLOOR_DIVIDE",
3569            Self::Power => "BINARY_NUMERIC_OPERATION_POWER",
3570            Self::Modulo => "BINARY_NUMERIC_OPERATION_MODULO",
3571            Self::Atan2 => "BINARY_NUMERIC_OPERATION_ATAN2",
3572        }
3573    }
3574    /// Creates an enum from field names used in the ProtoBuf definition.
3575    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
3576        match value {
3577            "BINARY_NUMERIC_OPERATION_UNSPECIFIED" => Some(Self::Unspecified),
3578            "BINARY_NUMERIC_OPERATION_ADD" => Some(Self::Add),
3579            "BINARY_NUMERIC_OPERATION_SUBTRACT" => Some(Self::Subtract),
3580            "BINARY_NUMERIC_OPERATION_MULTIPLY" => Some(Self::Multiply),
3581            "BINARY_NUMERIC_OPERATION_DIVIDE" => Some(Self::Divide),
3582            "BINARY_NUMERIC_OPERATION_FLOOR_DIVIDE" => Some(Self::FloorDivide),
3583            "BINARY_NUMERIC_OPERATION_POWER" => Some(Self::Power),
3584            "BINARY_NUMERIC_OPERATION_MODULO" => Some(Self::Modulo),
3585            "BINARY_NUMERIC_OPERATION_ATAN2" => Some(Self::Atan2),
3586            _ => None,
3587        }
3588    }
3589}
3590#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
3591#[repr(i32)]
3592pub enum NaryNumericOperation {
3593    Unspecified = 0,
3594    Max = 1,
3595    Mean = 2,
3596    Min = 3,
3597    Sum = 4,
3598    Product = 5,
3599}
3600impl NaryNumericOperation {
3601    /// String value of the enum field names used in the ProtoBuf definition.
3602    ///
3603    /// The values are not transformed in any way and thus are considered stable
3604    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
3605    pub fn as_str_name(&self) -> &'static str {
3606        match self {
3607            Self::Unspecified => "NARY_NUMERIC_OPERATION_UNSPECIFIED",
3608            Self::Max => "NARY_NUMERIC_OPERATION_MAX",
3609            Self::Mean => "NARY_NUMERIC_OPERATION_MEAN",
3610            Self::Min => "NARY_NUMERIC_OPERATION_MIN",
3611            Self::Sum => "NARY_NUMERIC_OPERATION_SUM",
3612            Self::Product => "NARY_NUMERIC_OPERATION_PRODUCT",
3613        }
3614    }
3615    /// Creates an enum from field names used in the ProtoBuf definition.
3616    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
3617        match value {
3618            "NARY_NUMERIC_OPERATION_UNSPECIFIED" => Some(Self::Unspecified),
3619            "NARY_NUMERIC_OPERATION_MAX" => Some(Self::Max),
3620            "NARY_NUMERIC_OPERATION_MEAN" => Some(Self::Mean),
3621            "NARY_NUMERIC_OPERATION_MIN" => Some(Self::Min),
3622            "NARY_NUMERIC_OPERATION_SUM" => Some(Self::Sum),
3623            "NARY_NUMERIC_OPERATION_PRODUCT" => Some(Self::Product),
3624            _ => None,
3625        }
3626    }
3627}
3628#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
3629#[repr(i32)]
3630pub enum BitwiseOperation {
3631    Unspecified = 0,
3632    And = 1,
3633    Or = 2,
3634    Xor = 3,
3635    ShiftRight = 4,
3636    ShiftLeft = 5,
3637    Test = 6,
3638}
3639impl BitwiseOperation {
3640    /// String value of the enum field names used in the ProtoBuf definition.
3641    ///
3642    /// The values are not transformed in any way and thus are considered stable
3643    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
3644    pub fn as_str_name(&self) -> &'static str {
3645        match self {
3646            Self::Unspecified => "BITWISE_OPERATION_UNSPECIFIED",
3647            Self::And => "BITWISE_OPERATION_AND",
3648            Self::Or => "BITWISE_OPERATION_OR",
3649            Self::Xor => "BITWISE_OPERATION_XOR",
3650            Self::ShiftRight => "BITWISE_OPERATION_SHIFT_RIGHT",
3651            Self::ShiftLeft => "BITWISE_OPERATION_SHIFT_LEFT",
3652            Self::Test => "BITWISE_OPERATION_TEST",
3653        }
3654    }
3655    /// Creates an enum from field names used in the ProtoBuf definition.
3656    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
3657        match value {
3658            "BITWISE_OPERATION_UNSPECIFIED" => Some(Self::Unspecified),
3659            "BITWISE_OPERATION_AND" => Some(Self::And),
3660            "BITWISE_OPERATION_OR" => Some(Self::Or),
3661            "BITWISE_OPERATION_XOR" => Some(Self::Xor),
3662            "BITWISE_OPERATION_SHIFT_RIGHT" => Some(Self::ShiftRight),
3663            "BITWISE_OPERATION_SHIFT_LEFT" => Some(Self::ShiftLeft),
3664            "BITWISE_OPERATION_TEST" => Some(Self::Test),
3665            _ => None,
3666        }
3667    }
3668}
3669#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
3670#[repr(i32)]
3671pub enum ComparisonOperation {
3672    Unspecified = 0,
3673    GreaterThan = 1,
3674    LessThan = 2,
3675    EqualTo = 3,
3676    NotEqualTo = 4,
3677    GreaterThanOrEqualTo = 5,
3678    LessThanOrEqualTo = 6,
3679}
3680impl ComparisonOperation {
3681    /// String value of the enum field names used in the ProtoBuf definition.
3682    ///
3683    /// The values are not transformed in any way and thus are considered stable
3684    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
3685    pub fn as_str_name(&self) -> &'static str {
3686        match self {
3687            Self::Unspecified => "COMPARISON_OPERATION_UNSPECIFIED",
3688            Self::GreaterThan => "COMPARISON_OPERATION_GREATER_THAN",
3689            Self::LessThan => "COMPARISON_OPERATION_LESS_THAN",
3690            Self::EqualTo => "COMPARISON_OPERATION_EQUAL_TO",
3691            Self::NotEqualTo => "COMPARISON_OPERATION_NOT_EQUAL_TO",
3692            Self::GreaterThanOrEqualTo => "COMPARISON_OPERATION_GREATER_THAN_OR_EQUAL_TO",
3693            Self::LessThanOrEqualTo => "COMPARISON_OPERATION_LESS_THAN_OR_EQUAL_TO",
3694        }
3695    }
3696    /// Creates an enum from field names used in the ProtoBuf definition.
3697    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
3698        match value {
3699            "COMPARISON_OPERATION_UNSPECIFIED" => Some(Self::Unspecified),
3700            "COMPARISON_OPERATION_GREATER_THAN" => Some(Self::GreaterThan),
3701            "COMPARISON_OPERATION_LESS_THAN" => Some(Self::LessThan),
3702            "COMPARISON_OPERATION_EQUAL_TO" => Some(Self::EqualTo),
3703            "COMPARISON_OPERATION_NOT_EQUAL_TO" => Some(Self::NotEqualTo),
3704            "COMPARISON_OPERATION_GREATER_THAN_OR_EQUAL_TO" => {
3705                Some(Self::GreaterThanOrEqualTo)
3706            }
3707            "COMPARISON_OPERATION_LESS_THAN_OR_EQUAL_TO" => Some(Self::LessThanOrEqualTo),
3708            _ => None,
3709        }
3710    }
3711}
3712#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
3713#[repr(i32)]
3714pub enum LogicalOperation {
3715    Unspecified = 0,
3716    And = 1,
3717    Or = 2,
3718}
3719impl LogicalOperation {
3720    /// String value of the enum field names used in the ProtoBuf definition.
3721    ///
3722    /// The values are not transformed in any way and thus are considered stable
3723    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
3724    pub fn as_str_name(&self) -> &'static str {
3725        match self {
3726            Self::Unspecified => "LOGICAL_OPERATION_UNSPECIFIED",
3727            Self::And => "LOGICAL_OPERATION_AND",
3728            Self::Or => "LOGICAL_OPERATION_OR",
3729        }
3730    }
3731    /// Creates an enum from field names used in the ProtoBuf definition.
3732    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
3733        match value {
3734            "LOGICAL_OPERATION_UNSPECIFIED" => Some(Self::Unspecified),
3735            "LOGICAL_OPERATION_AND" => Some(Self::And),
3736            "LOGICAL_OPERATION_OR" => Some(Self::Or),
3737            _ => None,
3738        }
3739    }
3740}
3741#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
3742#[repr(i32)]
3743pub enum NegativeValuePolicy {
3744    Unspecified = 0,
3745    Allow = 1,
3746    ClampToZero = 2,
3747    Exclude = 3,
3748}
3749impl NegativeValuePolicy {
3750    /// String value of the enum field names used in the ProtoBuf definition.
3751    ///
3752    /// The values are not transformed in any way and thus are considered stable
3753    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
3754    pub fn as_str_name(&self) -> &'static str {
3755        match self {
3756            Self::Unspecified => "NEGATIVE_VALUE_POLICY_UNSPECIFIED",
3757            Self::Allow => "NEGATIVE_VALUE_POLICY_ALLOW",
3758            Self::ClampToZero => "NEGATIVE_VALUE_POLICY_CLAMP_TO_ZERO",
3759            Self::Exclude => "NEGATIVE_VALUE_POLICY_EXCLUDE",
3760        }
3761    }
3762    /// Creates an enum from field names used in the ProtoBuf definition.
3763    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
3764        match value {
3765            "NEGATIVE_VALUE_POLICY_UNSPECIFIED" => Some(Self::Unspecified),
3766            "NEGATIVE_VALUE_POLICY_ALLOW" => Some(Self::Allow),
3767            "NEGATIVE_VALUE_POLICY_CLAMP_TO_ZERO" => Some(Self::ClampToZero),
3768            "NEGATIVE_VALUE_POLICY_EXCLUDE" => Some(Self::Exclude),
3769            _ => None,
3770        }
3771    }
3772}
3773#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
3774#[repr(i32)]
3775pub enum PointLimitOrder {
3776    Unspecified = 0,
3777    Newest = 1,
3778    Oldest = 2,
3779}
3780impl PointLimitOrder {
3781    /// String value of the enum field names used in the ProtoBuf definition.
3782    ///
3783    /// The values are not transformed in any way and thus are considered stable
3784    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
3785    pub fn as_str_name(&self) -> &'static str {
3786        match self {
3787            Self::Unspecified => "POINT_LIMIT_ORDER_UNSPECIFIED",
3788            Self::Newest => "POINT_LIMIT_ORDER_NEWEST",
3789            Self::Oldest => "POINT_LIMIT_ORDER_OLDEST",
3790        }
3791    }
3792    /// Creates an enum from field names used in the ProtoBuf definition.
3793    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
3794        match value {
3795            "POINT_LIMIT_ORDER_UNSPECIFIED" => Some(Self::Unspecified),
3796            "POINT_LIMIT_ORDER_NEWEST" => Some(Self::Newest),
3797            "POINT_LIMIT_ORDER_OLDEST" => Some(Self::Oldest),
3798            _ => None,
3799        }
3800    }
3801}
3802#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
3803#[repr(i32)]
3804pub enum ApproximateComparisonOperation {
3805    Unspecified = 0,
3806    EqualTo = 1,
3807    NotEqualTo = 2,
3808}
3809impl ApproximateComparisonOperation {
3810    /// String value of the enum field names used in the ProtoBuf definition.
3811    ///
3812    /// The values are not transformed in any way and thus are considered stable
3813    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
3814    pub fn as_str_name(&self) -> &'static str {
3815        match self {
3816            Self::Unspecified => "APPROXIMATE_COMPARISON_OPERATION_UNSPECIFIED",
3817            Self::EqualTo => "APPROXIMATE_COMPARISON_OPERATION_EQUAL_TO",
3818            Self::NotEqualTo => "APPROXIMATE_COMPARISON_OPERATION_NOT_EQUAL_TO",
3819        }
3820    }
3821    /// Creates an enum from field names used in the ProtoBuf definition.
3822    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
3823        match value {
3824            "APPROXIMATE_COMPARISON_OPERATION_UNSPECIFIED" => Some(Self::Unspecified),
3825            "APPROXIMATE_COMPARISON_OPERATION_EQUAL_TO" => Some(Self::EqualTo),
3826            "APPROXIMATE_COMPARISON_OPERATION_NOT_EQUAL_TO" => Some(Self::NotEqualTo),
3827            _ => None,
3828        }
3829    }
3830}
3831#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
3832#[repr(i32)]
3833pub enum DuplicateMergeOperation {
3834    Unspecified = 0,
3835    Min = 1,
3836    Max = 2,
3837    Mean = 3,
3838    Sum = 4,
3839    Count = 5,
3840    StandardDeviation = 6,
3841    RootMeanSquare = 7,
3842    Reject = 8,
3843}
3844impl DuplicateMergeOperation {
3845    /// String value of the enum field names used in the ProtoBuf definition.
3846    ///
3847    /// The values are not transformed in any way and thus are considered stable
3848    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
3849    pub fn as_str_name(&self) -> &'static str {
3850        match self {
3851            Self::Unspecified => "DUPLICATE_MERGE_OPERATION_UNSPECIFIED",
3852            Self::Min => "DUPLICATE_MERGE_OPERATION_MIN",
3853            Self::Max => "DUPLICATE_MERGE_OPERATION_MAX",
3854            Self::Mean => "DUPLICATE_MERGE_OPERATION_MEAN",
3855            Self::Sum => "DUPLICATE_MERGE_OPERATION_SUM",
3856            Self::Count => "DUPLICATE_MERGE_OPERATION_COUNT",
3857            Self::StandardDeviation => "DUPLICATE_MERGE_OPERATION_STANDARD_DEVIATION",
3858            Self::RootMeanSquare => "DUPLICATE_MERGE_OPERATION_ROOT_MEAN_SQUARE",
3859            Self::Reject => "DUPLICATE_MERGE_OPERATION_REJECT",
3860        }
3861    }
3862    /// Creates an enum from field names used in the ProtoBuf definition.
3863    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
3864        match value {
3865            "DUPLICATE_MERGE_OPERATION_UNSPECIFIED" => Some(Self::Unspecified),
3866            "DUPLICATE_MERGE_OPERATION_MIN" => Some(Self::Min),
3867            "DUPLICATE_MERGE_OPERATION_MAX" => Some(Self::Max),
3868            "DUPLICATE_MERGE_OPERATION_MEAN" => Some(Self::Mean),
3869            "DUPLICATE_MERGE_OPERATION_SUM" => Some(Self::Sum),
3870            "DUPLICATE_MERGE_OPERATION_COUNT" => Some(Self::Count),
3871            "DUPLICATE_MERGE_OPERATION_STANDARD_DEVIATION" => {
3872                Some(Self::StandardDeviation)
3873            }
3874            "DUPLICATE_MERGE_OPERATION_ROOT_MEAN_SQUARE" => Some(Self::RootMeanSquare),
3875            "DUPLICATE_MERGE_OPERATION_REJECT" => Some(Self::Reject),
3876            _ => None,
3877        }
3878    }
3879}
3880#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
3881#[repr(i32)]
3882pub enum LiteralBitwiseOperation {
3883    Unspecified = 0,
3884    And = 1,
3885    Or = 2,
3886    Xor = 3,
3887}
3888impl LiteralBitwiseOperation {
3889    /// String value of the enum field names used in the ProtoBuf definition.
3890    ///
3891    /// The values are not transformed in any way and thus are considered stable
3892    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
3893    pub fn as_str_name(&self) -> &'static str {
3894        match self {
3895            Self::Unspecified => "LITERAL_BITWISE_OPERATION_UNSPECIFIED",
3896            Self::And => "LITERAL_BITWISE_OPERATION_AND",
3897            Self::Or => "LITERAL_BITWISE_OPERATION_OR",
3898            Self::Xor => "LITERAL_BITWISE_OPERATION_XOR",
3899        }
3900    }
3901    /// Creates an enum from field names used in the ProtoBuf definition.
3902    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
3903        match value {
3904            "LITERAL_BITWISE_OPERATION_UNSPECIFIED" => Some(Self::Unspecified),
3905            "LITERAL_BITWISE_OPERATION_AND" => Some(Self::And),
3906            "LITERAL_BITWISE_OPERATION_OR" => Some(Self::Or),
3907            "LITERAL_BITWISE_OPERATION_XOR" => Some(Self::Xor),
3908            _ => None,
3909        }
3910    }
3911}
3912#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
3913#[repr(i32)]
3914pub enum ShiftDirection {
3915    Unspecified = 0,
3916    Left = 1,
3917    Right = 2,
3918}
3919impl ShiftDirection {
3920    /// String value of the enum field names used in the ProtoBuf definition.
3921    ///
3922    /// The values are not transformed in any way and thus are considered stable
3923    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
3924    pub fn as_str_name(&self) -> &'static str {
3925        match self {
3926            Self::Unspecified => "SHIFT_DIRECTION_UNSPECIFIED",
3927            Self::Left => "SHIFT_DIRECTION_LEFT",
3928            Self::Right => "SHIFT_DIRECTION_RIGHT",
3929        }
3930    }
3931    /// Creates an enum from field names used in the ProtoBuf definition.
3932    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
3933        match value {
3934            "SHIFT_DIRECTION_UNSPECIFIED" => Some(Self::Unspecified),
3935            "SHIFT_DIRECTION_LEFT" => Some(Self::Left),
3936            "SHIFT_DIRECTION_RIGHT" => Some(Self::Right),
3937            _ => None,
3938        }
3939    }
3940}
3941#[derive(Clone, PartialEq, ::prost::Message)]
3942pub struct DatasetScope {
3943    #[prost(message, optional, tag = "1")]
3944    pub dataset: ::core::option::Option<DatasetExpression>,
3945    #[prost(message, optional, tag = "2")]
3946    pub context: ::core::option::Option<ComputeContext>,
3947}
3948#[derive(Clone, PartialEq, ::prost::Message)]
3949pub struct ScalarValue {
3950    #[prost(oneof = "scalar_value::Kind", tags = "1, 2, 3")]
3951    pub kind: ::core::option::Option<scalar_value::Kind>,
3952}
3953/// Nested message and enum types in `ScalarValue`.
3954pub mod scalar_value {
3955    #[derive(Clone, PartialEq, ::prost::Oneof)]
3956    pub enum Kind {
3957        #[prost(string, tag = "1")]
3958        StringValue(::prost::alloc::string::String),
3959        #[prost(double, tag = "2")]
3960        Float64Value(f64),
3961        #[prost(int64, tag = "3")]
3962        Int64Value(i64),
3963    }
3964}
3965#[derive(Clone, PartialEq, ::prost::Message)]
3966pub struct ComputeValue {
3967    #[prost(oneof = "compute_value::Kind", tags = "1, 2, 3")]
3968    pub kind: ::core::option::Option<compute_value::Kind>,
3969}
3970/// Nested message and enum types in `ComputeValue`.
3971pub mod compute_value {
3972    #[derive(Clone, PartialEq, ::prost::Oneof)]
3973    pub enum Kind {
3974        #[prost(message, tag = "1")]
3975        Scalar(super::ScalarValue),
3976        #[prost(message, tag = "2")]
3977        Array(super::ComputeValueArray),
3978        #[prost(message, tag = "3")]
3979        Object(super::StructuredObject),
3980    }
3981}
3982#[derive(Clone, PartialEq, ::prost::Message)]
3983pub struct ComputeValueArray {
3984    #[prost(message, repeated, tag = "1")]
3985    pub values: ::prost::alloc::vec::Vec<NullableComputeValue>,
3986}
3987#[derive(Clone, PartialEq, ::prost::Message)]
3988pub struct NullableComputeValue {
3989    #[prost(oneof = "nullable_compute_value::Kind", tags = "1, 2")]
3990    pub kind: ::core::option::Option<nullable_compute_value::Kind>,
3991}
3992/// Nested message and enum types in `NullableComputeValue`.
3993pub mod nullable_compute_value {
3994    #[derive(Clone, PartialEq, ::prost::Oneof)]
3995    pub enum Kind {
3996        #[prost(message, tag = "1")]
3997        Value(super::ComputeValue),
3998        #[prost(
3999            enumeration = "super::super::super::super::google::protobuf::NullValue",
4000            tag = "2"
4001        )]
4002        NullValue(i32),
4003    }
4004}
4005#[derive(Clone, PartialEq, ::prost::Message)]
4006pub struct StructuredObject {
4007    #[prost(map = "string, message", tag = "1")]
4008    pub fields: ::std::collections::HashMap<
4009        ::prost::alloc::string::String,
4010        StructuredFieldValue,
4011    >,
4012}
4013#[derive(Clone, PartialEq, ::prost::Message)]
4014pub struct StructuredFieldValue {
4015    #[prost(oneof = "structured_field_value::Kind", tags = "1, 2, 3, 4, 5, 6, 7")]
4016    pub kind: ::core::option::Option<structured_field_value::Kind>,
4017}
4018/// Nested message and enum types in `StructuredFieldValue`.
4019pub mod structured_field_value {
4020    #[derive(Clone, PartialEq, ::prost::Oneof)]
4021    pub enum Kind {
4022        #[prost(message, tag = "1")]
4023        Scalar(super::ScalarValue),
4024        #[prost(
4025            enumeration = "super::super::super::super::google::protobuf::NullValue",
4026            tag = "2"
4027        )]
4028        NullValue(i32),
4029        #[prost(bool, tag = "3")]
4030        BooleanValue(bool),
4031        #[prost(uint64, tag = "4")]
4032        Uint64Value(u64),
4033        #[prost(message, tag = "5")]
4034        ArbitraryInteger(super::ArbitraryInteger),
4035        #[prost(message, tag = "6")]
4036        Object(super::StructuredObject),
4037        #[prost(message, tag = "7")]
4038        Array(super::StructuredArray),
4039    }
4040}
4041#[derive(Clone, PartialEq, ::prost::Message)]
4042pub struct StructuredArray {
4043    #[prost(message, repeated, tag = "1")]
4044    pub values: ::prost::alloc::vec::Vec<StructuredFieldValue>,
4045}
4046#[derive(Clone, PartialEq, ::prost::Message)]
4047pub struct ArbitraryInteger {
4048    #[prost(string, tag = "1")]
4049    pub decimal: ::prost::alloc::string::String,
4050}
4051#[derive(Clone, Copy, PartialEq, ::prost::Message)]
4052pub struct ResultInterval {
4053    #[prost(message, optional, tag = "1")]
4054    pub start: ::core::option::Option<super::super::types::time::Timestamp>,
4055    #[prost(message, optional, tag = "2")]
4056    pub end: ::core::option::Option<super::super::types::time::Timestamp>,
4057    #[prost(message, optional, tag = "3")]
4058    pub value: ::core::option::Option<IntervalValue>,
4059}
4060#[derive(Clone, Copy, PartialEq, ::prost::Message)]
4061pub struct IntervalValue {
4062    #[prost(oneof = "interval_value::Kind", tags = "1, 2, 3")]
4063    pub kind: ::core::option::Option<interval_value::Kind>,
4064}
4065/// Nested message and enum types in `IntervalValue`.
4066pub mod interval_value {
4067    #[derive(Clone, Copy, PartialEq, ::prost::Oneof)]
4068    pub enum Kind {
4069        #[prost(double, tag = "1")]
4070        Aggregate(f64),
4071        #[prost(message, tag = "2")]
4072        Statistics(super::IntervalStatistics),
4073        #[prost(message, tag = "3")]
4074        NoPoints(super::NoPointsInInterval),
4075    }
4076}
4077#[derive(Clone, Copy, PartialEq, ::prost::Message)]
4078pub struct NoPointsInInterval {}
4079#[derive(Clone, Copy, PartialEq, ::prost::Message)]
4080pub struct IntervalStatistics {
4081    #[prost(double, tag = "1")]
4082    pub mean: f64,
4083    #[prost(double, tag = "2")]
4084    pub min: f64,
4085    #[prost(double, tag = "3")]
4086    pub max: f64,
4087    #[prost(double, tag = "4")]
4088    pub standard_deviation: f64,
4089    #[prost(double, tag = "5")]
4090    pub count: f64,
4091    #[prost(double, tag = "6")]
4092    pub sum: f64,
4093    #[prost(double, optional, tag = "7")]
4094    pub root_mean_square: ::core::option::Option<f64>,
4095}
4096#[derive(Clone, Copy, PartialEq, ::prost::Message)]
4097pub struct NumericSample {
4098    #[prost(message, optional, tag = "1")]
4099    pub timestamp: ::core::option::Option<super::super::types::time::Timestamp>,
4100    #[prost(double, tag = "2")]
4101    pub value: f64,
4102}
4103#[derive(Clone, PartialEq, ::prost::Message)]
4104pub struct CategoricalSample {
4105    #[prost(message, optional, tag = "1")]
4106    pub timestamp: ::core::option::Option<super::super::types::time::Timestamp>,
4107    #[prost(string, tag = "2")]
4108    pub value: ::prost::alloc::string::String,
4109}
4110#[derive(Clone, PartialEq, ::prost::Message)]
4111pub struct ValueSample {
4112    #[prost(message, optional, tag = "1")]
4113    pub timestamp: ::core::option::Option<super::super::types::time::Timestamp>,
4114    #[prost(message, optional, tag = "2")]
4115    pub value: ::core::option::Option<ComputeValue>,
4116    #[prost(bool, tag = "3")]
4117    pub precision_loss: bool,
4118}
4119#[derive(Clone, PartialEq, ::prost::Message)]
4120pub struct LogSample {
4121    #[prost(message, optional, tag = "1")]
4122    pub timestamp: ::core::option::Option<super::super::types::time::Timestamp>,
4123    #[prost(string, tag = "2")]
4124    pub message: ::prost::alloc::string::String,
4125    #[prost(map = "string, string", tag = "3")]
4126    pub attributes: ::std::collections::HashMap<
4127        ::prost::alloc::string::String,
4128        ::prost::alloc::string::String,
4129    >,
4130    #[prost(string, tag = "4")]
4131    pub id: ::prost::alloc::string::String,
4132}
4133#[derive(Clone, PartialEq, ::prost::Message)]
4134pub struct ResultGrouping {
4135    #[prost(map = "string, string", tag = "1")]
4136    pub tags: ::std::collections::HashMap<
4137        ::prost::alloc::string::String,
4138        ::prost::alloc::string::String,
4139    >,
4140}
4141#[derive(Clone, PartialEq, ::prost::Message)]
4142pub struct ResultGroupingKeys {
4143    #[prost(string, repeated, tag = "1")]
4144    pub keys: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
4145}
4146#[derive(Clone, PartialEq, ::prost::Message)]
4147pub struct ArrowResult {
4148    #[prost(bytes = "vec", tag = "1")]
4149    pub ipc_stream: ::prost::alloc::vec::Vec<u8>,
4150    #[prost(enumeration = "ArrowResultShape", tag = "2")]
4151    pub shape: i32,
4152    #[prost(message, optional, tag = "3")]
4153    pub grouping_keys: ::core::option::Option<ResultGroupingKeys>,
4154    #[prost(string, tag = "4")]
4155    pub next_page_token: ::prost::alloc::string::String,
4156}
4157#[derive(Clone, PartialEq, ::prost::Message)]
4158pub struct ComputationFailure {
4159    #[prost(string, tag = "1")]
4160    pub error_type: ::prost::alloc::string::String,
4161    #[prost(int32, tag = "2")]
4162    pub http_status_code: i32,
4163}
4164#[derive(Clone, PartialEq, ::prost::Message)]
4165pub struct ChannelUnitReference {
4166    #[prost(string, tag = "1")]
4167    pub data_source_rid: ::prost::alloc::string::String,
4168    #[prost(string, tag = "2")]
4169    pub channel: ::prost::alloc::string::String,
4170}
4171#[derive(Clone, PartialEq, ::prost::Message)]
4172pub struct MissingInputUnits {
4173    #[deprecated]
4174    #[prost(string, repeated, tag = "1")]
4175    pub logical_series_rids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
4176    #[prost(message, repeated, tag = "2")]
4177    pub channels: ::prost::alloc::vec::Vec<ChannelUnitReference>,
4178}
4179#[derive(Clone, PartialEq, ::prost::Message)]
4180pub struct IncompatibleUnitCalculation {
4181    #[prost(enumeration = "UnitCalculationOperation", tag = "1")]
4182    pub operation: i32,
4183    #[prost(string, repeated, tag = "2")]
4184    pub units: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
4185}
4186#[derive(Clone, PartialEq, ::prost::Message)]
4187pub struct UnitCalculationIssue {
4188    #[prost(oneof = "unit_calculation_issue::Kind", tags = "1, 2, 3")]
4189    pub kind: ::core::option::Option<unit_calculation_issue::Kind>,
4190}
4191/// Nested message and enum types in `UnitCalculationIssue`.
4192pub mod unit_calculation_issue {
4193    #[derive(Clone, PartialEq, ::prost::Oneof)]
4194    pub enum Kind {
4195        #[prost(message, tag = "1")]
4196        Incompatible(super::IncompatibleUnitCalculation),
4197        #[prost(message, tag = "2")]
4198        Missing(super::MissingInputUnits),
4199        #[prost(message, tag = "3")]
4200        Error(super::super::super::types::SerializableError),
4201    }
4202}
4203#[derive(Clone, PartialEq, ::prost::Message)]
4204pub struct UnavailableUnit {
4205    #[prost(message, repeated, tag = "1")]
4206    pub issues: ::prost::alloc::vec::Vec<UnitCalculationIssue>,
4207}
4208#[derive(Clone, PartialEq, ::prost::Message)]
4209pub struct ComputedUnit {
4210    #[prost(oneof = "computed_unit::Kind", tags = "1, 2")]
4211    pub kind: ::core::option::Option<computed_unit::Kind>,
4212}
4213/// Nested message and enum types in `ComputedUnit`.
4214pub mod computed_unit {
4215    #[derive(Clone, PartialEq, ::prost::Oneof)]
4216    pub enum Kind {
4217        #[prost(string, tag = "1")]
4218        Symbol(::prost::alloc::string::String),
4219        #[prost(message, tag = "2")]
4220        Unavailable(super::UnavailableUnit),
4221    }
4222}
4223#[derive(Clone, PartialEq, ::prost::Message)]
4224pub struct CartesianComputedUnits {
4225    #[prost(message, optional, tag = "1")]
4226    pub x: ::core::option::Option<ComputedUnit>,
4227    #[prost(message, optional, tag = "2")]
4228    pub y: ::core::option::Option<ComputedUnit>,
4229}
4230#[derive(Clone, PartialEq, ::prost::Message)]
4231pub struct Cartesian3dComputedUnits {
4232    #[prost(message, optional, tag = "1")]
4233    pub x: ::core::option::Option<ComputedUnit>,
4234    #[prost(message, optional, tag = "2")]
4235    pub y: ::core::option::Option<ComputedUnit>,
4236    #[prost(message, optional, tag = "3")]
4237    pub z: ::core::option::Option<ComputedUnit>,
4238}
4239#[derive(Clone, PartialEq, ::prost::Message)]
4240pub struct MultivariateComputedUnits {
4241    #[prost(message, repeated, tag = "1")]
4242    pub units: ::prost::alloc::vec::Vec<ComputedUnit>,
4243}
4244#[derive(Clone, PartialEq, ::prost::Message)]
4245pub struct ComputationUnits {
4246    #[prost(oneof = "computation_units::Kind", tags = "1, 2, 3, 4")]
4247    pub kind: ::core::option::Option<computation_units::Kind>,
4248}
4249/// Nested message and enum types in `ComputationUnits`.
4250pub mod computation_units {
4251    #[derive(Clone, PartialEq, ::prost::Oneof)]
4252    pub enum Kind {
4253        #[prost(message, tag = "1")]
4254        Single(super::ComputedUnit),
4255        #[prost(message, tag = "2")]
4256        Cartesian(super::CartesianComputedUnits),
4257        #[prost(message, tag = "3")]
4258        Cartesian3d(super::Cartesian3dComputedUnits),
4259        #[prost(message, tag = "4")]
4260        Multivariate(super::MultivariateComputedUnits),
4261    }
4262}
4263#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
4264#[repr(i32)]
4265pub enum ArrowResultShape {
4266    Unspecified = 0,
4267    Numeric = 1,
4268    NumericBuckets = 2,
4269    Categorical = 3,
4270    CategoricalBuckets = 4,
4271    Log = 5,
4272    Struct = 6,
4273    StructBuckets = 7,
4274    FullResolution = 8,
4275    MultivariateBuckets = 9,
4276    NumericArrayBuckets = 10,
4277    CategoricalArrayBuckets = 11,
4278}
4279impl ArrowResultShape {
4280    /// String value of the enum field names used in the ProtoBuf definition.
4281    ///
4282    /// The values are not transformed in any way and thus are considered stable
4283    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
4284    pub fn as_str_name(&self) -> &'static str {
4285        match self {
4286            Self::Unspecified => "ARROW_RESULT_SHAPE_UNSPECIFIED",
4287            Self::Numeric => "ARROW_RESULT_SHAPE_NUMERIC",
4288            Self::NumericBuckets => "ARROW_RESULT_SHAPE_NUMERIC_BUCKETS",
4289            Self::Categorical => "ARROW_RESULT_SHAPE_CATEGORICAL",
4290            Self::CategoricalBuckets => "ARROW_RESULT_SHAPE_CATEGORICAL_BUCKETS",
4291            Self::Log => "ARROW_RESULT_SHAPE_LOG",
4292            Self::Struct => "ARROW_RESULT_SHAPE_STRUCT",
4293            Self::StructBuckets => "ARROW_RESULT_SHAPE_STRUCT_BUCKETS",
4294            Self::FullResolution => "ARROW_RESULT_SHAPE_FULL_RESOLUTION",
4295            Self::MultivariateBuckets => "ARROW_RESULT_SHAPE_MULTIVARIATE_BUCKETS",
4296            Self::NumericArrayBuckets => "ARROW_RESULT_SHAPE_NUMERIC_ARRAY_BUCKETS",
4297            Self::CategoricalArrayBuckets => {
4298                "ARROW_RESULT_SHAPE_CATEGORICAL_ARRAY_BUCKETS"
4299            }
4300        }
4301    }
4302    /// Creates an enum from field names used in the ProtoBuf definition.
4303    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
4304        match value {
4305            "ARROW_RESULT_SHAPE_UNSPECIFIED" => Some(Self::Unspecified),
4306            "ARROW_RESULT_SHAPE_NUMERIC" => Some(Self::Numeric),
4307            "ARROW_RESULT_SHAPE_NUMERIC_BUCKETS" => Some(Self::NumericBuckets),
4308            "ARROW_RESULT_SHAPE_CATEGORICAL" => Some(Self::Categorical),
4309            "ARROW_RESULT_SHAPE_CATEGORICAL_BUCKETS" => Some(Self::CategoricalBuckets),
4310            "ARROW_RESULT_SHAPE_LOG" => Some(Self::Log),
4311            "ARROW_RESULT_SHAPE_STRUCT" => Some(Self::Struct),
4312            "ARROW_RESULT_SHAPE_STRUCT_BUCKETS" => Some(Self::StructBuckets),
4313            "ARROW_RESULT_SHAPE_FULL_RESOLUTION" => Some(Self::FullResolution),
4314            "ARROW_RESULT_SHAPE_MULTIVARIATE_BUCKETS" => Some(Self::MultivariateBuckets),
4315            "ARROW_RESULT_SHAPE_NUMERIC_ARRAY_BUCKETS" => Some(Self::NumericArrayBuckets),
4316            "ARROW_RESULT_SHAPE_CATEGORICAL_ARRAY_BUCKETS" => {
4317                Some(Self::CategoricalArrayBuckets)
4318            }
4319            _ => None,
4320        }
4321    }
4322}
4323#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
4324#[repr(i32)]
4325pub enum UnitCalculationOperation {
4326    Unspecified = 0,
4327    UnitAsExponent = 1,
4328    NonIntegerAsExponent = 2,
4329    FloorDivision = 3,
4330    Modulo = 4,
4331    CrossoverComparison = 5,
4332    Max = 6,
4333    Min = 7,
4334    Mean = 8,
4335    Union = 9,
4336    Addition = 10,
4337    Subtraction = 11,
4338    UnitConversion = 12,
4339    Comparison = 13,
4340    TernaryOperator = 14,
4341}
4342impl UnitCalculationOperation {
4343    /// String value of the enum field names used in the ProtoBuf definition.
4344    ///
4345    /// The values are not transformed in any way and thus are considered stable
4346    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
4347    pub fn as_str_name(&self) -> &'static str {
4348        match self {
4349            Self::Unspecified => "UNIT_CALCULATION_OPERATION_UNSPECIFIED",
4350            Self::UnitAsExponent => "UNIT_CALCULATION_OPERATION_UNIT_AS_EXPONENT",
4351            Self::NonIntegerAsExponent => {
4352                "UNIT_CALCULATION_OPERATION_NON_INTEGER_AS_EXPONENT"
4353            }
4354            Self::FloorDivision => "UNIT_CALCULATION_OPERATION_FLOOR_DIVISION",
4355            Self::Modulo => "UNIT_CALCULATION_OPERATION_MODULO",
4356            Self::CrossoverComparison => {
4357                "UNIT_CALCULATION_OPERATION_CROSSOVER_COMPARISON"
4358            }
4359            Self::Max => "UNIT_CALCULATION_OPERATION_MAX",
4360            Self::Min => "UNIT_CALCULATION_OPERATION_MIN",
4361            Self::Mean => "UNIT_CALCULATION_OPERATION_MEAN",
4362            Self::Union => "UNIT_CALCULATION_OPERATION_UNION",
4363            Self::Addition => "UNIT_CALCULATION_OPERATION_ADDITION",
4364            Self::Subtraction => "UNIT_CALCULATION_OPERATION_SUBTRACTION",
4365            Self::UnitConversion => "UNIT_CALCULATION_OPERATION_UNIT_CONVERSION",
4366            Self::Comparison => "UNIT_CALCULATION_OPERATION_COMPARISON",
4367            Self::TernaryOperator => "UNIT_CALCULATION_OPERATION_TERNARY_OPERATOR",
4368        }
4369    }
4370    /// Creates an enum from field names used in the ProtoBuf definition.
4371    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
4372        match value {
4373            "UNIT_CALCULATION_OPERATION_UNSPECIFIED" => Some(Self::Unspecified),
4374            "UNIT_CALCULATION_OPERATION_UNIT_AS_EXPONENT" => Some(Self::UnitAsExponent),
4375            "UNIT_CALCULATION_OPERATION_NON_INTEGER_AS_EXPONENT" => {
4376                Some(Self::NonIntegerAsExponent)
4377            }
4378            "UNIT_CALCULATION_OPERATION_FLOOR_DIVISION" => Some(Self::FloorDivision),
4379            "UNIT_CALCULATION_OPERATION_MODULO" => Some(Self::Modulo),
4380            "UNIT_CALCULATION_OPERATION_CROSSOVER_COMPARISON" => {
4381                Some(Self::CrossoverComparison)
4382            }
4383            "UNIT_CALCULATION_OPERATION_MAX" => Some(Self::Max),
4384            "UNIT_CALCULATION_OPERATION_MIN" => Some(Self::Min),
4385            "UNIT_CALCULATION_OPERATION_MEAN" => Some(Self::Mean),
4386            "UNIT_CALCULATION_OPERATION_UNION" => Some(Self::Union),
4387            "UNIT_CALCULATION_OPERATION_ADDITION" => Some(Self::Addition),
4388            "UNIT_CALCULATION_OPERATION_SUBTRACTION" => Some(Self::Subtraction),
4389            "UNIT_CALCULATION_OPERATION_UNIT_CONVERSION" => Some(Self::UnitConversion),
4390            "UNIT_CALCULATION_OPERATION_COMPARISON" => Some(Self::Comparison),
4391            "UNIT_CALCULATION_OPERATION_TERNARY_OPERATOR" => Some(Self::TernaryOperator),
4392            _ => None,
4393        }
4394    }
4395}
4396#[derive(Clone, PartialEq, ::prost::Message)]
4397pub struct NumericSamples {
4398    #[prost(message, repeated, tag = "1")]
4399    pub samples: ::prost::alloc::vec::Vec<NumericSample>,
4400    #[prost(string, tag = "2")]
4401    pub next_page_token: ::prost::alloc::string::String,
4402}
4403#[derive(Clone, PartialEq, ::prost::Message)]
4404pub struct NumericBucketStatistics {
4405    #[prost(double, optional, tag = "1")]
4406    pub min: ::core::option::Option<f64>,
4407    #[prost(double, optional, tag = "2")]
4408    pub max: ::core::option::Option<f64>,
4409    #[prost(double, optional, tag = "3")]
4410    pub mean: ::core::option::Option<f64>,
4411    #[prost(int64, optional, tag = "4")]
4412    pub count: ::core::option::Option<i64>,
4413    #[prost(double, optional, tag = "5")]
4414    pub variance: ::core::option::Option<f64>,
4415    #[prost(message, optional, tag = "6")]
4416    pub first: ::core::option::Option<NumericSample>,
4417    #[prost(message, optional, tag = "7")]
4418    pub last: ::core::option::Option<NumericSample>,
4419    #[prost(map = "string, double", tag = "8")]
4420    pub aggregations: ::std::collections::HashMap<::prost::alloc::string::String, f64>,
4421}
4422#[derive(Clone, PartialEq, ::prost::Message)]
4423pub struct NumericResultBucket {
4424    #[prost(message, optional, tag = "1")]
4425    pub end: ::core::option::Option<super::super::types::time::Timestamp>,
4426    #[prost(message, optional, tag = "2")]
4427    pub statistics: ::core::option::Option<NumericBucketStatistics>,
4428}
4429#[derive(Clone, PartialEq, ::prost::Message)]
4430pub struct NumericBuckets {
4431    #[prost(message, repeated, tag = "1")]
4432    pub buckets: ::prost::alloc::vec::Vec<NumericResultBucket>,
4433}
4434#[derive(Clone, Copy, PartialEq, ::prost::Message)]
4435pub struct HistogramInputCount {
4436    #[prost(int64, tag = "1")]
4437    pub count: i64,
4438}
4439#[derive(Clone, PartialEq, ::prost::Message)]
4440pub struct NumericHistogramBin {
4441    #[prost(double, tag = "1")]
4442    pub lower_bound: f64,
4443    #[prost(double, tag = "2")]
4444    pub upper_bound: f64,
4445    #[prost(map = "string, message", tag = "3")]
4446    pub counts_by_input: ::std::collections::HashMap<
4447        ::prost::alloc::string::String,
4448        HistogramInputCount,
4449    >,
4450}
4451#[derive(Clone, PartialEq, ::prost::Message)]
4452pub struct NumericHistogram {
4453    #[prost(message, repeated, tag = "1")]
4454    pub bins: ::prost::alloc::vec::Vec<NumericHistogramBin>,
4455}
4456#[derive(Clone, Copy, PartialEq, ::prost::Message)]
4457pub struct CategoricalCodeSample {
4458    #[prost(message, optional, tag = "1")]
4459    pub timestamp: ::core::option::Option<super::super::types::time::Timestamp>,
4460    #[prost(int32, tag = "2")]
4461    pub category_index: i32,
4462}
4463#[derive(Clone, PartialEq, ::prost::Message)]
4464pub struct CategoricalSamples {
4465    #[prost(string, repeated, tag = "1")]
4466    pub categories: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
4467    #[prost(message, repeated, tag = "2")]
4468    pub samples: ::prost::alloc::vec::Vec<CategoricalCodeSample>,
4469    #[prost(string, tag = "3")]
4470    pub next_page_token: ::prost::alloc::string::String,
4471}
4472#[derive(Clone, PartialEq, ::prost::Message)]
4473pub struct CategoricalBucketStatistics {
4474    #[prost(map = "int32, int64", tag = "1")]
4475    pub count_by_category_index: ::std::collections::HashMap<i32, i64>,
4476    #[prost(message, optional, tag = "2")]
4477    pub first: ::core::option::Option<CategoricalCodeSample>,
4478    #[prost(message, optional, tag = "3")]
4479    pub last: ::core::option::Option<CategoricalCodeSample>,
4480}
4481#[derive(Clone, PartialEq, ::prost::Message)]
4482pub struct CategoricalResultBucket {
4483    #[prost(message, optional, tag = "1")]
4484    pub end: ::core::option::Option<super::super::types::time::Timestamp>,
4485    #[prost(message, optional, tag = "2")]
4486    pub statistics: ::core::option::Option<CategoricalBucketStatistics>,
4487}
4488#[derive(Clone, PartialEq, ::prost::Message)]
4489pub struct CategoricalBuckets {
4490    #[prost(string, repeated, tag = "1")]
4491    pub categories: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
4492    #[prost(message, repeated, tag = "2")]
4493    pub buckets: ::prost::alloc::vec::Vec<CategoricalResultBucket>,
4494}
4495#[derive(Clone, PartialEq, ::prost::Message)]
4496pub struct CategoricalHistogramBin {
4497    #[prost(string, tag = "1")]
4498    pub value: ::prost::alloc::string::String,
4499    #[prost(map = "string, message", tag = "2")]
4500    pub counts_by_input: ::std::collections::HashMap<
4501        ::prost::alloc::string::String,
4502        HistogramInputCount,
4503    >,
4504}
4505#[derive(Clone, PartialEq, ::prost::Message)]
4506pub struct CategoricalHistogram {
4507    #[prost(message, repeated, tag = "1")]
4508    pub bins: ::prost::alloc::vec::Vec<CategoricalHistogramBin>,
4509}
4510#[derive(Clone, PartialEq, ::prost::Message)]
4511pub struct LogSamples {
4512    #[prost(message, repeated, tag = "1")]
4513    pub samples: ::prost::alloc::vec::Vec<LogSample>,
4514    #[prost(string, tag = "2")]
4515    pub next_page_token: ::prost::alloc::string::String,
4516}
4517#[derive(Clone, PartialEq, ::prost::Message)]
4518pub struct SeriesSummarization {
4519    #[prost(oneof = "series_summarization::Kind", tags = "1, 2, 3, 4, 5")]
4520    pub kind: ::core::option::Option<series_summarization::Kind>,
4521}
4522/// Nested message and enum types in `SeriesSummarization`.
4523pub mod series_summarization {
4524    #[derive(Clone, PartialEq, ::prost::Oneof)]
4525    pub enum Kind {
4526        #[prost(message, tag = "1")]
4527        FixedResolution(super::FixedResolutionSummary),
4528        #[prost(message, tag = "2")]
4529        BucketCount(super::BucketCountSummary),
4530        #[prost(message, tag = "3")]
4531        LargestTriangleThreeBuckets(super::LargestTriangleThreeBucketsSummary),
4532        #[prost(message, tag = "4")]
4533        PointPage(super::PointPageSummary),
4534        #[prost(message, tag = "5")]
4535        Truncated(super::TruncatedSummary),
4536    }
4537}
4538#[derive(Clone, Copy, PartialEq, ::prost::Message)]
4539pub struct FixedResolutionSummary {
4540    #[prost(int64, tag = "1")]
4541    pub resolution_nanos: i64,
4542}
4543#[derive(Clone, Copy, PartialEq, ::prost::Message)]
4544pub struct BucketCountSummary {
4545    #[prost(int32, tag = "1")]
4546    pub bucket_count: i32,
4547}
4548#[derive(Clone, Copy, PartialEq, ::prost::Message)]
4549pub struct LargestTriangleThreeBucketsSummary {
4550    #[prost(int32, tag = "1")]
4551    pub max_points_per_group: i32,
4552}
4553#[derive(Clone, PartialEq, ::prost::Message)]
4554pub struct PointPageSummary {
4555    #[prost(uint32, tag = "1")]
4556    pub page_size: u32,
4557    #[prost(enumeration = "ComputeTimeDirection", tag = "2")]
4558    pub direction: i32,
4559    #[prost(string, tag = "3")]
4560    pub page_token: ::prost::alloc::string::String,
4561}
4562#[derive(Clone, Copy, PartialEq, ::prost::Message)]
4563pub struct TruncatedSummary {
4564    #[prost(int32, tag = "1")]
4565    pub max_points: i32,
4566}
4567#[derive(Clone, PartialEq, ::prost::Message)]
4568pub struct NumericOutputSelection {
4569    #[prost(message, optional, tag = "1")]
4570    pub columns: ::core::option::Option<NumericOutputColumns>,
4571    #[prost(map = "string, message", tag = "2")]
4572    pub named_reductions: ::std::collections::HashMap<
4573        ::prost::alloc::string::String,
4574        NumericReduction,
4575    >,
4576}
4577#[derive(Clone, PartialEq, ::prost::Message)]
4578pub struct NumericOutputColumns {
4579    #[prost(message, repeated, tag = "1")]
4580    pub columns: ::prost::alloc::vec::Vec<NumericOutputColumn>,
4581}
4582#[derive(Clone, PartialEq, ::prost::Message)]
4583pub struct NumericOutputColumn {
4584    #[prost(oneof = "numeric_output_column::Kind", tags = "1, 2")]
4585    pub kind: ::core::option::Option<numeric_output_column::Kind>,
4586}
4587/// Nested message and enum types in `NumericOutputColumn`.
4588pub mod numeric_output_column {
4589    #[derive(Clone, PartialEq, ::prost::Oneof)]
4590    pub enum Kind {
4591        #[prost(enumeration = "super::NumericOutputStatistic", tag = "1")]
4592        Statistic(i32),
4593        #[prost(message, tag = "2")]
4594        Percentile(super::PercentileOutputColumn),
4595    }
4596}
4597#[derive(Clone, PartialEq, ::prost::Message)]
4598pub struct PercentileOutputColumn {
4599    #[prost(message, optional, tag = "1")]
4600    pub percentile: ::core::option::Option<DoubleConstant>,
4601    #[prost(string, optional, tag = "2")]
4602    pub output_name: ::core::option::Option<::prost::alloc::string::String>,
4603}
4604#[derive(Clone, Copy, PartialEq, ::prost::Message)]
4605pub struct StftConfiguration {
4606    #[prost(enumeration = "ComputeFftWindow", optional, tag = "1")]
4607    pub window: ::core::option::Option<i32>,
4608    #[prost(enumeration = "ComputeWindowSymmetry", optional, tag = "2")]
4609    pub window_symmetry: ::core::option::Option<i32>,
4610    #[prost(double, optional, tag = "3")]
4611    pub sampling_frequency: ::core::option::Option<f64>,
4612    #[prost(int32, optional, tag = "4")]
4613    pub segment_length: ::core::option::Option<i32>,
4614    #[prost(int32, optional, tag = "5")]
4615    pub overlap_length: ::core::option::Option<i32>,
4616    #[prost(int32, optional, tag = "6")]
4617    pub fft_length: ::core::option::Option<i32>,
4618    #[prost(enumeration = "ComputeDetrend", optional, tag = "7")]
4619    pub detrend: ::core::option::Option<i32>,
4620}
4621#[derive(Clone, Copy, PartialEq, ::prost::Message)]
4622pub struct FrequencyBucketing {
4623    #[prost(int32, tag = "1")]
4624    pub bucket_count: i32,
4625    #[prost(double, optional, tag = "2")]
4626    pub min_frequency: ::core::option::Option<f64>,
4627    #[prost(double, optional, tag = "3")]
4628    pub max_frequency: ::core::option::Option<f64>,
4629}
4630#[derive(Clone, Copy, PartialEq, ::prost::Message)]
4631pub struct SpectrogramBucketing {
4632    #[prost(int32, optional, tag = "1")]
4633    pub max_time_buckets: ::core::option::Option<i32>,
4634    #[prost(int32, optional, tag = "2")]
4635    pub max_frequency_buckets: ::core::option::Option<i32>,
4636    #[prost(double, optional, tag = "3")]
4637    pub min_frequency: ::core::option::Option<f64>,
4638    #[prost(double, optional, tag = "4")]
4639    pub max_frequency: ::core::option::Option<f64>,
4640    #[prost(enumeration = "SpectrogramReduction", optional, tag = "5")]
4641    pub time_reduction: ::core::option::Option<i32>,
4642    #[prost(enumeration = "SpectrogramReduction", optional, tag = "6")]
4643    pub frequency_reduction: ::core::option::Option<i32>,
4644}
4645#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
4646#[repr(i32)]
4647pub enum ComputeOutputFormat {
4648    Unspecified = 0,
4649    Typed = 1,
4650    Arrow = 2,
4651}
4652impl ComputeOutputFormat {
4653    /// String value of the enum field names used in the ProtoBuf definition.
4654    ///
4655    /// The values are not transformed in any way and thus are considered stable
4656    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
4657    pub fn as_str_name(&self) -> &'static str {
4658        match self {
4659            Self::Unspecified => "COMPUTE_OUTPUT_FORMAT_UNSPECIFIED",
4660            Self::Typed => "COMPUTE_OUTPUT_FORMAT_TYPED",
4661            Self::Arrow => "COMPUTE_OUTPUT_FORMAT_ARROW",
4662        }
4663    }
4664    /// Creates an enum from field names used in the ProtoBuf definition.
4665    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
4666        match value {
4667            "COMPUTE_OUTPUT_FORMAT_UNSPECIFIED" => Some(Self::Unspecified),
4668            "COMPUTE_OUTPUT_FORMAT_TYPED" => Some(Self::Typed),
4669            "COMPUTE_OUTPUT_FORMAT_ARROW" => Some(Self::Arrow),
4670            _ => None,
4671        }
4672    }
4673}
4674#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
4675#[repr(i32)]
4676pub enum ComputeTimeDirection {
4677    Unspecified = 0,
4678    Ascending = 1,
4679    Descending = 2,
4680}
4681impl ComputeTimeDirection {
4682    /// String value of the enum field names used in the ProtoBuf definition.
4683    ///
4684    /// The values are not transformed in any way and thus are considered stable
4685    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
4686    pub fn as_str_name(&self) -> &'static str {
4687        match self {
4688            Self::Unspecified => "COMPUTE_TIME_DIRECTION_UNSPECIFIED",
4689            Self::Ascending => "COMPUTE_TIME_DIRECTION_ASCENDING",
4690            Self::Descending => "COMPUTE_TIME_DIRECTION_DESCENDING",
4691        }
4692    }
4693    /// Creates an enum from field names used in the ProtoBuf definition.
4694    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
4695        match value {
4696            "COMPUTE_TIME_DIRECTION_UNSPECIFIED" => Some(Self::Unspecified),
4697            "COMPUTE_TIME_DIRECTION_ASCENDING" => Some(Self::Ascending),
4698            "COMPUTE_TIME_DIRECTION_DESCENDING" => Some(Self::Descending),
4699            _ => None,
4700        }
4701    }
4702}
4703#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
4704#[repr(i32)]
4705pub enum NumericOutputStatistic {
4706    Unspecified = 0,
4707    Min = 1,
4708    Max = 2,
4709    Mean = 3,
4710    Count = 4,
4711    Variance = 5,
4712    FirstPoint = 6,
4713    LastPoint = 7,
4714    Sum = 8,
4715    StandardDeviation = 9,
4716    RootMeanSquare = 10,
4717}
4718impl NumericOutputStatistic {
4719    /// String value of the enum field names used in the ProtoBuf definition.
4720    ///
4721    /// The values are not transformed in any way and thus are considered stable
4722    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
4723    pub fn as_str_name(&self) -> &'static str {
4724        match self {
4725            Self::Unspecified => "NUMERIC_OUTPUT_STATISTIC_UNSPECIFIED",
4726            Self::Min => "NUMERIC_OUTPUT_STATISTIC_MIN",
4727            Self::Max => "NUMERIC_OUTPUT_STATISTIC_MAX",
4728            Self::Mean => "NUMERIC_OUTPUT_STATISTIC_MEAN",
4729            Self::Count => "NUMERIC_OUTPUT_STATISTIC_COUNT",
4730            Self::Variance => "NUMERIC_OUTPUT_STATISTIC_VARIANCE",
4731            Self::FirstPoint => "NUMERIC_OUTPUT_STATISTIC_FIRST_POINT",
4732            Self::LastPoint => "NUMERIC_OUTPUT_STATISTIC_LAST_POINT",
4733            Self::Sum => "NUMERIC_OUTPUT_STATISTIC_SUM",
4734            Self::StandardDeviation => "NUMERIC_OUTPUT_STATISTIC_STANDARD_DEVIATION",
4735            Self::RootMeanSquare => "NUMERIC_OUTPUT_STATISTIC_ROOT_MEAN_SQUARE",
4736        }
4737    }
4738    /// Creates an enum from field names used in the ProtoBuf definition.
4739    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
4740        match value {
4741            "NUMERIC_OUTPUT_STATISTIC_UNSPECIFIED" => Some(Self::Unspecified),
4742            "NUMERIC_OUTPUT_STATISTIC_MIN" => Some(Self::Min),
4743            "NUMERIC_OUTPUT_STATISTIC_MAX" => Some(Self::Max),
4744            "NUMERIC_OUTPUT_STATISTIC_MEAN" => Some(Self::Mean),
4745            "NUMERIC_OUTPUT_STATISTIC_COUNT" => Some(Self::Count),
4746            "NUMERIC_OUTPUT_STATISTIC_VARIANCE" => Some(Self::Variance),
4747            "NUMERIC_OUTPUT_STATISTIC_FIRST_POINT" => Some(Self::FirstPoint),
4748            "NUMERIC_OUTPUT_STATISTIC_LAST_POINT" => Some(Self::LastPoint),
4749            "NUMERIC_OUTPUT_STATISTIC_SUM" => Some(Self::Sum),
4750            "NUMERIC_OUTPUT_STATISTIC_STANDARD_DEVIATION" => {
4751                Some(Self::StandardDeviation)
4752            }
4753            "NUMERIC_OUTPUT_STATISTIC_ROOT_MEAN_SQUARE" => Some(Self::RootMeanSquare),
4754            _ => None,
4755        }
4756    }
4757}
4758#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
4759#[repr(i32)]
4760pub enum ComputeFftWindow {
4761    Unspecified = 0,
4762    Blackman = 1,
4763    Hann = 2,
4764    Hamming = 3,
4765    Rectangular = 4,
4766}
4767impl ComputeFftWindow {
4768    /// String value of the enum field names used in the ProtoBuf definition.
4769    ///
4770    /// The values are not transformed in any way and thus are considered stable
4771    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
4772    pub fn as_str_name(&self) -> &'static str {
4773        match self {
4774            Self::Unspecified => "COMPUTE_FFT_WINDOW_UNSPECIFIED",
4775            Self::Blackman => "COMPUTE_FFT_WINDOW_BLACKMAN",
4776            Self::Hann => "COMPUTE_FFT_WINDOW_HANN",
4777            Self::Hamming => "COMPUTE_FFT_WINDOW_HAMMING",
4778            Self::Rectangular => "COMPUTE_FFT_WINDOW_RECTANGULAR",
4779        }
4780    }
4781    /// Creates an enum from field names used in the ProtoBuf definition.
4782    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
4783        match value {
4784            "COMPUTE_FFT_WINDOW_UNSPECIFIED" => Some(Self::Unspecified),
4785            "COMPUTE_FFT_WINDOW_BLACKMAN" => Some(Self::Blackman),
4786            "COMPUTE_FFT_WINDOW_HANN" => Some(Self::Hann),
4787            "COMPUTE_FFT_WINDOW_HAMMING" => Some(Self::Hamming),
4788            "COMPUTE_FFT_WINDOW_RECTANGULAR" => Some(Self::Rectangular),
4789            _ => None,
4790        }
4791    }
4792}
4793#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
4794#[repr(i32)]
4795pub enum ComputeWindowSymmetry {
4796    Unspecified = 0,
4797    DftEven = 1,
4798    Symmetric = 2,
4799}
4800impl ComputeWindowSymmetry {
4801    /// String value of the enum field names used in the ProtoBuf definition.
4802    ///
4803    /// The values are not transformed in any way and thus are considered stable
4804    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
4805    pub fn as_str_name(&self) -> &'static str {
4806        match self {
4807            Self::Unspecified => "COMPUTE_WINDOW_SYMMETRY_UNSPECIFIED",
4808            Self::DftEven => "COMPUTE_WINDOW_SYMMETRY_DFT_EVEN",
4809            Self::Symmetric => "COMPUTE_WINDOW_SYMMETRY_SYMMETRIC",
4810        }
4811    }
4812    /// Creates an enum from field names used in the ProtoBuf definition.
4813    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
4814        match value {
4815            "COMPUTE_WINDOW_SYMMETRY_UNSPECIFIED" => Some(Self::Unspecified),
4816            "COMPUTE_WINDOW_SYMMETRY_DFT_EVEN" => Some(Self::DftEven),
4817            "COMPUTE_WINDOW_SYMMETRY_SYMMETRIC" => Some(Self::Symmetric),
4818            _ => None,
4819        }
4820    }
4821}
4822#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
4823#[repr(i32)]
4824pub enum ComputeDetrend {
4825    Unspecified = 0,
4826    Constant = 1,
4827    Linear = 2,
4828    None = 3,
4829}
4830impl ComputeDetrend {
4831    /// String value of the enum field names used in the ProtoBuf definition.
4832    ///
4833    /// The values are not transformed in any way and thus are considered stable
4834    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
4835    pub fn as_str_name(&self) -> &'static str {
4836        match self {
4837            Self::Unspecified => "COMPUTE_DETREND_UNSPECIFIED",
4838            Self::Constant => "COMPUTE_DETREND_CONSTANT",
4839            Self::Linear => "COMPUTE_DETREND_LINEAR",
4840            Self::None => "COMPUTE_DETREND_NONE",
4841        }
4842    }
4843    /// Creates an enum from field names used in the ProtoBuf definition.
4844    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
4845        match value {
4846            "COMPUTE_DETREND_UNSPECIFIED" => Some(Self::Unspecified),
4847            "COMPUTE_DETREND_CONSTANT" => Some(Self::Constant),
4848            "COMPUTE_DETREND_LINEAR" => Some(Self::Linear),
4849            "COMPUTE_DETREND_NONE" => Some(Self::None),
4850            _ => None,
4851        }
4852    }
4853}
4854#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
4855#[repr(i32)]
4856pub enum ComputeMagnitudeScaling {
4857    Unspecified = 0,
4858    Linear = 1,
4859    Decibel10 = 2,
4860    Decibel20 = 3,
4861}
4862impl ComputeMagnitudeScaling {
4863    /// String value of the enum field names used in the ProtoBuf definition.
4864    ///
4865    /// The values are not transformed in any way and thus are considered stable
4866    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
4867    pub fn as_str_name(&self) -> &'static str {
4868        match self {
4869            Self::Unspecified => "COMPUTE_MAGNITUDE_SCALING_UNSPECIFIED",
4870            Self::Linear => "COMPUTE_MAGNITUDE_SCALING_LINEAR",
4871            Self::Decibel10 => "COMPUTE_MAGNITUDE_SCALING_DECIBEL_10",
4872            Self::Decibel20 => "COMPUTE_MAGNITUDE_SCALING_DECIBEL_20",
4873        }
4874    }
4875    /// Creates an enum from field names used in the ProtoBuf definition.
4876    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
4877        match value {
4878            "COMPUTE_MAGNITUDE_SCALING_UNSPECIFIED" => Some(Self::Unspecified),
4879            "COMPUTE_MAGNITUDE_SCALING_LINEAR" => Some(Self::Linear),
4880            "COMPUTE_MAGNITUDE_SCALING_DECIBEL_10" => Some(Self::Decibel10),
4881            "COMPUTE_MAGNITUDE_SCALING_DECIBEL_20" => Some(Self::Decibel20),
4882            _ => None,
4883        }
4884    }
4885}
4886#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
4887#[repr(i32)]
4888pub enum ComputeFrequencyUnit {
4889    Unspecified = 0,
4890    Hertz = 1,
4891    RadiansPerSecond = 2,
4892    CyclesPerSample = 3,
4893    RadiansPerSample = 4,
4894}
4895impl ComputeFrequencyUnit {
4896    /// String value of the enum field names used in the ProtoBuf definition.
4897    ///
4898    /// The values are not transformed in any way and thus are considered stable
4899    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
4900    pub fn as_str_name(&self) -> &'static str {
4901        match self {
4902            Self::Unspecified => "COMPUTE_FREQUENCY_UNIT_UNSPECIFIED",
4903            Self::Hertz => "COMPUTE_FREQUENCY_UNIT_HERTZ",
4904            Self::RadiansPerSecond => "COMPUTE_FREQUENCY_UNIT_RADIANS_PER_SECOND",
4905            Self::CyclesPerSample => "COMPUTE_FREQUENCY_UNIT_CYCLES_PER_SAMPLE",
4906            Self::RadiansPerSample => "COMPUTE_FREQUENCY_UNIT_RADIANS_PER_SAMPLE",
4907        }
4908    }
4909    /// Creates an enum from field names used in the ProtoBuf definition.
4910    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
4911        match value {
4912            "COMPUTE_FREQUENCY_UNIT_UNSPECIFIED" => Some(Self::Unspecified),
4913            "COMPUTE_FREQUENCY_UNIT_HERTZ" => Some(Self::Hertz),
4914            "COMPUTE_FREQUENCY_UNIT_RADIANS_PER_SECOND" => Some(Self::RadiansPerSecond),
4915            "COMPUTE_FREQUENCY_UNIT_CYCLES_PER_SAMPLE" => Some(Self::CyclesPerSample),
4916            "COMPUTE_FREQUENCY_UNIT_RADIANS_PER_SAMPLE" => Some(Self::RadiansPerSample),
4917            _ => None,
4918        }
4919    }
4920}
4921#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
4922#[repr(i32)]
4923pub enum ComputePhaseUnit {
4924    Unspecified = 0,
4925    Radians = 1,
4926    Degrees = 2,
4927}
4928impl ComputePhaseUnit {
4929    /// String value of the enum field names used in the ProtoBuf definition.
4930    ///
4931    /// The values are not transformed in any way and thus are considered stable
4932    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
4933    pub fn as_str_name(&self) -> &'static str {
4934        match self {
4935            Self::Unspecified => "COMPUTE_PHASE_UNIT_UNSPECIFIED",
4936            Self::Radians => "COMPUTE_PHASE_UNIT_RADIANS",
4937            Self::Degrees => "COMPUTE_PHASE_UNIT_DEGREES",
4938        }
4939    }
4940    /// Creates an enum from field names used in the ProtoBuf definition.
4941    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
4942        match value {
4943            "COMPUTE_PHASE_UNIT_UNSPECIFIED" => Some(Self::Unspecified),
4944            "COMPUTE_PHASE_UNIT_RADIANS" => Some(Self::Radians),
4945            "COMPUTE_PHASE_UNIT_DEGREES" => Some(Self::Degrees),
4946            _ => None,
4947        }
4948    }
4949}
4950#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
4951#[repr(i32)]
4952pub enum SpectrogramQuantity {
4953    Unspecified = 0,
4954    PowerSpectralDensity = 1,
4955    Amplitude = 2,
4956}
4957impl SpectrogramQuantity {
4958    /// String value of the enum field names used in the ProtoBuf definition.
4959    ///
4960    /// The values are not transformed in any way and thus are considered stable
4961    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
4962    pub fn as_str_name(&self) -> &'static str {
4963        match self {
4964            Self::Unspecified => "SPECTROGRAM_QUANTITY_UNSPECIFIED",
4965            Self::PowerSpectralDensity => "SPECTROGRAM_QUANTITY_POWER_SPECTRAL_DENSITY",
4966            Self::Amplitude => "SPECTROGRAM_QUANTITY_AMPLITUDE",
4967        }
4968    }
4969    /// Creates an enum from field names used in the ProtoBuf definition.
4970    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
4971        match value {
4972            "SPECTROGRAM_QUANTITY_UNSPECIFIED" => Some(Self::Unspecified),
4973            "SPECTROGRAM_QUANTITY_POWER_SPECTRAL_DENSITY" => {
4974                Some(Self::PowerSpectralDensity)
4975            }
4976            "SPECTROGRAM_QUANTITY_AMPLITUDE" => Some(Self::Amplitude),
4977            _ => None,
4978        }
4979    }
4980}
4981#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
4982#[repr(i32)]
4983pub enum SpectrogramReduction {
4984    Unspecified = 0,
4985    Mean = 1,
4986    Max = 2,
4987    GeometricMean = 3,
4988}
4989impl SpectrogramReduction {
4990    /// String value of the enum field names used in the ProtoBuf definition.
4991    ///
4992    /// The values are not transformed in any way and thus are considered stable
4993    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
4994    pub fn as_str_name(&self) -> &'static str {
4995        match self {
4996            Self::Unspecified => "SPECTROGRAM_REDUCTION_UNSPECIFIED",
4997            Self::Mean => "SPECTROGRAM_REDUCTION_MEAN",
4998            Self::Max => "SPECTROGRAM_REDUCTION_MAX",
4999            Self::GeometricMean => "SPECTROGRAM_REDUCTION_GEOMETRIC_MEAN",
5000        }
5001    }
5002    /// Creates an enum from field names used in the ProtoBuf definition.
5003    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
5004        match value {
5005            "SPECTROGRAM_REDUCTION_UNSPECIFIED" => Some(Self::Unspecified),
5006            "SPECTROGRAM_REDUCTION_MEAN" => Some(Self::Mean),
5007            "SPECTROGRAM_REDUCTION_MAX" => Some(Self::Max),
5008            "SPECTROGRAM_REDUCTION_GEOMETRIC_MEAN" => Some(Self::GeometricMean),
5009            _ => None,
5010        }
5011    }
5012}
5013#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
5014#[repr(i32)]
5015pub enum ScatterTemporalReduction {
5016    Unspecified = 0,
5017    Mean = 1,
5018    Min = 2,
5019    Max = 3,
5020    First = 4,
5021    Last = 5,
5022}
5023impl ScatterTemporalReduction {
5024    /// String value of the enum field names used in the ProtoBuf definition.
5025    ///
5026    /// The values are not transformed in any way and thus are considered stable
5027    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
5028    pub fn as_str_name(&self) -> &'static str {
5029        match self {
5030            Self::Unspecified => "SCATTER_TEMPORAL_REDUCTION_UNSPECIFIED",
5031            Self::Mean => "SCATTER_TEMPORAL_REDUCTION_MEAN",
5032            Self::Min => "SCATTER_TEMPORAL_REDUCTION_MIN",
5033            Self::Max => "SCATTER_TEMPORAL_REDUCTION_MAX",
5034            Self::First => "SCATTER_TEMPORAL_REDUCTION_FIRST",
5035            Self::Last => "SCATTER_TEMPORAL_REDUCTION_LAST",
5036        }
5037    }
5038    /// Creates an enum from field names used in the ProtoBuf definition.
5039    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
5040        match value {
5041            "SCATTER_TEMPORAL_REDUCTION_UNSPECIFIED" => Some(Self::Unspecified),
5042            "SCATTER_TEMPORAL_REDUCTION_MEAN" => Some(Self::Mean),
5043            "SCATTER_TEMPORAL_REDUCTION_MIN" => Some(Self::Min),
5044            "SCATTER_TEMPORAL_REDUCTION_MAX" => Some(Self::Max),
5045            "SCATTER_TEMPORAL_REDUCTION_FIRST" => Some(Self::First),
5046            "SCATTER_TEMPORAL_REDUCTION_LAST" => Some(Self::Last),
5047            _ => None,
5048        }
5049    }
5050}
5051#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
5052#[repr(i32)]
5053pub enum ScatterDriverAxis {
5054    Unspecified = 0,
5055    X = 1,
5056    Y = 2,
5057    Z = 3,
5058}
5059impl ScatterDriverAxis {
5060    /// String value of the enum field names used in the ProtoBuf definition.
5061    ///
5062    /// The values are not transformed in any way and thus are considered stable
5063    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
5064    pub fn as_str_name(&self) -> &'static str {
5065        match self {
5066            Self::Unspecified => "SCATTER_DRIVER_AXIS_UNSPECIFIED",
5067            Self::X => "SCATTER_DRIVER_AXIS_X",
5068            Self::Y => "SCATTER_DRIVER_AXIS_Y",
5069            Self::Z => "SCATTER_DRIVER_AXIS_Z",
5070        }
5071    }
5072    /// Creates an enum from field names used in the ProtoBuf definition.
5073    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
5074        match value {
5075            "SCATTER_DRIVER_AXIS_UNSPECIFIED" => Some(Self::Unspecified),
5076            "SCATTER_DRIVER_AXIS_X" => Some(Self::X),
5077            "SCATTER_DRIVER_AXIS_Y" => Some(Self::Y),
5078            "SCATTER_DRIVER_AXIS_Z" => Some(Self::Z),
5079            _ => None,
5080        }
5081    }
5082}
5083#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
5084#[repr(i32)]
5085pub enum MultivariateNumericReduction {
5086    Unspecified = 0,
5087    Mean = 1,
5088    Min = 2,
5089    Max = 3,
5090    First = 4,
5091    Last = 5,
5092}
5093impl MultivariateNumericReduction {
5094    /// String value of the enum field names used in the ProtoBuf definition.
5095    ///
5096    /// The values are not transformed in any way and thus are considered stable
5097    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
5098    pub fn as_str_name(&self) -> &'static str {
5099        match self {
5100            Self::Unspecified => "MULTIVARIATE_NUMERIC_REDUCTION_UNSPECIFIED",
5101            Self::Mean => "MULTIVARIATE_NUMERIC_REDUCTION_MEAN",
5102            Self::Min => "MULTIVARIATE_NUMERIC_REDUCTION_MIN",
5103            Self::Max => "MULTIVARIATE_NUMERIC_REDUCTION_MAX",
5104            Self::First => "MULTIVARIATE_NUMERIC_REDUCTION_FIRST",
5105            Self::Last => "MULTIVARIATE_NUMERIC_REDUCTION_LAST",
5106        }
5107    }
5108    /// Creates an enum from field names used in the ProtoBuf definition.
5109    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
5110        match value {
5111            "MULTIVARIATE_NUMERIC_REDUCTION_UNSPECIFIED" => Some(Self::Unspecified),
5112            "MULTIVARIATE_NUMERIC_REDUCTION_MEAN" => Some(Self::Mean),
5113            "MULTIVARIATE_NUMERIC_REDUCTION_MIN" => Some(Self::Min),
5114            "MULTIVARIATE_NUMERIC_REDUCTION_MAX" => Some(Self::Max),
5115            "MULTIVARIATE_NUMERIC_REDUCTION_FIRST" => Some(Self::First),
5116            "MULTIVARIATE_NUMERIC_REDUCTION_LAST" => Some(Self::Last),
5117            _ => None,
5118        }
5119    }
5120}
5121#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
5122#[repr(i32)]
5123pub enum MultivariateCategoricalReduction {
5124    Unspecified = 0,
5125    Mode = 1,
5126}
5127impl MultivariateCategoricalReduction {
5128    /// String value of the enum field names used in the ProtoBuf definition.
5129    ///
5130    /// The values are not transformed in any way and thus are considered stable
5131    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
5132    pub fn as_str_name(&self) -> &'static str {
5133        match self {
5134            Self::Unspecified => "MULTIVARIATE_CATEGORICAL_REDUCTION_UNSPECIFIED",
5135            Self::Mode => "MULTIVARIATE_CATEGORICAL_REDUCTION_MODE",
5136        }
5137    }
5138    /// Creates an enum from field names used in the ProtoBuf definition.
5139    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
5140        match value {
5141            "MULTIVARIATE_CATEGORICAL_REDUCTION_UNSPECIFIED" => Some(Self::Unspecified),
5142            "MULTIVARIATE_CATEGORICAL_REDUCTION_MODE" => Some(Self::Mode),
5143            _ => None,
5144        }
5145    }
5146}
5147#[derive(Clone, PartialEq, ::prost::Message)]
5148pub struct ComputationSpec {
5149    #[prost(oneof = "computation_spec::Kind", tags = "1, 2, 3, 4, 5, 6, 7, 8, 9, 10")]
5150    pub kind: ::core::option::Option<computation_spec::Kind>,
5151}
5152/// Nested message and enum types in `ComputationSpec`.
5153pub mod computation_spec {
5154    #[derive(Clone, PartialEq, ::prost::Oneof)]
5155    pub enum Kind {
5156        #[prost(message, tag = "1")]
5157        IntervalSummary(super::IntervalSummarySpec),
5158        #[prost(message, tag = "2")]
5159        SeriesSummary(super::SeriesSummarySpec),
5160        #[prost(message, tag = "3")]
5161        Selection(super::ValueSelectionSpec),
5162        #[prost(message, tag = "4")]
5163        Cartesian(super::CartesianSummarySpec),
5164        #[prost(message, tag = "5")]
5165        Cartesian3d(super::Cartesian3dSummarySpec),
5166        #[prost(message, tag = "6")]
5167        Frequency(super::FrequencyAnalysisSpec),
5168        #[prost(message, tag = "7")]
5169        Spectrogram(super::SpectrogramSpec),
5170        #[prost(message, tag = "8")]
5171        Histogram(super::HistogramSpec),
5172        #[prost(message, tag = "9")]
5173        Curve(super::CurveFitExpression),
5174        #[prost(message, tag = "10")]
5175        Multivariate(super::MultivariateSummarySpec),
5176    }
5177}
5178#[derive(Clone, PartialEq, ::prost::Message)]
5179pub struct IntervalSummarySpec {
5180    #[prost(message, optional, tag = "1")]
5181    pub input: ::core::option::Option<RangeExpression>,
5182    #[prost(int32, optional, tag = "2")]
5183    pub max_intervals: ::core::option::Option<i32>,
5184}
5185#[derive(Clone, PartialEq, ::prost::Message)]
5186pub struct SeriesSummarySpec {
5187    #[prost(message, optional, tag = "1")]
5188    pub input: ::core::option::Option<SeriesExpression>,
5189    #[prost(enumeration = "ComputeOutputFormat", optional, tag = "2")]
5190    pub output_format: ::core::option::Option<i32>,
5191    #[prost(message, optional, tag = "3")]
5192    pub numeric_output: ::core::option::Option<NumericOutputSelection>,
5193    #[prost(message, optional, tag = "4")]
5194    pub summarization: ::core::option::Option<SeriesSummarization>,
5195}
5196#[derive(Clone, PartialEq, ::prost::Message)]
5197pub struct ValueSelectionSpec {
5198    #[prost(oneof = "value_selection_spec::Kind", tags = "1, 2")]
5199    pub kind: ::core::option::Option<value_selection_spec::Kind>,
5200}
5201/// Nested message and enum types in `ValueSelectionSpec`.
5202pub mod value_selection_spec {
5203    #[derive(Clone, PartialEq, ::prost::Oneof)]
5204    pub enum Kind {
5205        #[prost(message, tag = "1")]
5206        Point(super::SeriesPointSelection),
5207        #[prost(message, tag = "2")]
5208        Interval(super::IntervalSelection),
5209    }
5210}
5211#[derive(Clone, PartialEq, ::prost::Message)]
5212pub struct SeriesPointSelection {
5213    #[prost(message, optional, tag = "1")]
5214    pub input: ::core::option::Option<SeriesExpression>,
5215    #[prost(enumeration = "ComputePointRepresentation", tag = "2")]
5216    pub representation: i32,
5217    #[prost(oneof = "series_point_selection::Position", tags = "3, 4")]
5218    pub position: ::core::option::Option<series_point_selection::Position>,
5219}
5220/// Nested message and enum types in `SeriesPointSelection`.
5221pub mod series_point_selection {
5222    #[derive(Clone, Copy, PartialEq, ::prost::Oneof)]
5223    pub enum Position {
5224        #[prost(message, tag = "3")]
5225        First(super::FirstSelection),
5226        #[prost(message, tag = "4")]
5227        Last(super::LastSelection),
5228    }
5229}
5230#[derive(Clone, Copy, PartialEq, ::prost::Message)]
5231pub struct FirstSelection {}
5232#[derive(Clone, Copy, PartialEq, ::prost::Message)]
5233pub struct LastSelection {}
5234#[derive(Clone, PartialEq, ::prost::Message)]
5235pub struct IntervalSelection {
5236    #[prost(message, optional, tag = "1")]
5237    pub input: ::core::option::Option<RangeExpression>,
5238    #[prost(oneof = "interval_selection::Kind", tags = "2, 3, 4")]
5239    pub kind: ::core::option::Option<interval_selection::Kind>,
5240}
5241/// Nested message and enum types in `IntervalSelection`.
5242pub mod interval_selection {
5243    #[derive(Clone, PartialEq, ::prost::Oneof)]
5244    pub enum Kind {
5245        #[prost(message, tag = "2")]
5246        First(super::FirstSelection),
5247        #[prost(message, tag = "3")]
5248        Last(super::LastSelection),
5249        #[prost(message, tag = "4")]
5250        Indexed(super::IndexedIntervalSelection),
5251    }
5252}
5253#[derive(Clone, PartialEq, ::prost::Message)]
5254pub struct IndexedIntervalSelection {
5255    #[prost(message, optional, tag = "1")]
5256    pub index: ::core::option::Option<IntegerConstant>,
5257    #[prost(enumeration = "ComputeTimeDirection", tag = "2")]
5258    pub direction: i32,
5259}
5260#[derive(Clone, PartialEq, ::prost::Message)]
5261pub struct CartesianSummarySpec {
5262    #[prost(message, optional, tag = "1")]
5263    pub x: ::core::option::Option<NumericExpression>,
5264    #[prost(message, optional, tag = "2")]
5265    pub y: ::core::option::Option<NumericExpression>,
5266    #[prost(message, optional, tag = "3")]
5267    pub bounds: ::core::option::Option<CartesianSummaryBounds>,
5268    #[prost(message, optional, tag = "4")]
5269    pub summarization: ::core::option::Option<ScatterSummarization>,
5270    #[prost(int32, optional, tag = "5")]
5271    pub max_points: ::core::option::Option<i32>,
5272}
5273#[derive(Clone, PartialEq, ::prost::Message)]
5274pub struct CartesianSummaryBounds {
5275    #[prost(message, optional, tag = "1")]
5276    pub min_x: ::core::option::Option<DoubleConstant>,
5277    #[prost(message, optional, tag = "2")]
5278    pub max_x: ::core::option::Option<DoubleConstant>,
5279    #[prost(message, optional, tag = "3")]
5280    pub min_y: ::core::option::Option<DoubleConstant>,
5281    #[prost(message, optional, tag = "4")]
5282    pub max_y: ::core::option::Option<DoubleConstant>,
5283}
5284#[derive(Clone, PartialEq, ::prost::Message)]
5285pub struct Cartesian3dSummarySpec {
5286    #[prost(message, optional, tag = "1")]
5287    pub x: ::core::option::Option<NumericExpression>,
5288    #[prost(message, optional, tag = "2")]
5289    pub y: ::core::option::Option<NumericExpression>,
5290    #[prost(message, optional, tag = "3")]
5291    pub z: ::core::option::Option<NumericExpression>,
5292    #[prost(enumeration = "ScatterDriverAxis", optional, tag = "4")]
5293    pub driver_axis: ::core::option::Option<i32>,
5294    #[prost(message, optional, tag = "5")]
5295    pub bounds: ::core::option::Option<Cartesian3dSummaryBounds>,
5296    #[prost(message, optional, tag = "6")]
5297    pub summarization: ::core::option::Option<ScatterSummarization>,
5298    #[prost(int32, optional, tag = "7")]
5299    pub max_points: ::core::option::Option<i32>,
5300}
5301#[derive(Clone, PartialEq, ::prost::Message)]
5302pub struct Cartesian3dSummaryBounds {
5303    #[prost(message, optional, tag = "1")]
5304    pub min_x: ::core::option::Option<DoubleConstant>,
5305    #[prost(message, optional, tag = "2")]
5306    pub max_x: ::core::option::Option<DoubleConstant>,
5307    #[prost(message, optional, tag = "3")]
5308    pub min_y: ::core::option::Option<DoubleConstant>,
5309    #[prost(message, optional, tag = "4")]
5310    pub max_y: ::core::option::Option<DoubleConstant>,
5311    #[prost(message, optional, tag = "5")]
5312    pub min_z: ::core::option::Option<DoubleConstant>,
5313    #[prost(message, optional, tag = "6")]
5314    pub max_z: ::core::option::Option<DoubleConstant>,
5315}
5316#[derive(Clone, Copy, PartialEq, ::prost::Message)]
5317pub struct ScatterSummarization {
5318    #[prost(oneof = "scatter_summarization::Kind", tags = "1, 2")]
5319    pub kind: ::core::option::Option<scatter_summarization::Kind>,
5320}
5321/// Nested message and enum types in `ScatterSummarization`.
5322pub mod scatter_summarization {
5323    #[derive(Clone, Copy, PartialEq, ::prost::Oneof)]
5324    pub enum Kind {
5325        #[prost(message, tag = "1")]
5326        Spatial(super::SpatialScatterSummary),
5327        #[prost(message, tag = "2")]
5328        Temporal(super::TemporalScatterSummary),
5329    }
5330}
5331#[derive(Clone, Copy, PartialEq, ::prost::Message)]
5332pub struct SpatialScatterSummary {}
5333#[derive(Clone, Copy, PartialEq, ::prost::Message)]
5334pub struct TemporalScatterSummary {
5335    #[prost(enumeration = "ScatterTemporalReduction", tag = "1")]
5336    pub x_reduction: i32,
5337    #[prost(enumeration = "ScatterTemporalReduction", tag = "2")]
5338    pub y_reduction: i32,
5339}
5340#[derive(Clone, PartialEq, ::prost::Message)]
5341pub struct FrequencyAnalysisSpec {
5342    #[prost(oneof = "frequency_analysis_spec::Kind", tags = "1, 2, 3, 4, 5")]
5343    pub kind: ::core::option::Option<frequency_analysis_spec::Kind>,
5344}
5345/// Nested message and enum types in `FrequencyAnalysisSpec`.
5346pub mod frequency_analysis_spec {
5347    #[derive(Clone, PartialEq, ::prost::Oneof)]
5348    pub enum Kind {
5349        #[prost(message, tag = "1")]
5350        Fft(super::FftSpec),
5351        #[prost(message, tag = "2")]
5352        PowerSpectralDensity(super::PowerSpectralDensitySpec),
5353        #[prost(message, tag = "3")]
5354        CrossSpectralDensity(super::CrossSpectralDensitySpec),
5355        #[prost(message, tag = "4")]
5356        FrequencyResponse(super::FrequencyResponseSpec),
5357        #[prost(message, tag = "5")]
5358        Bode(super::BodeSpec),
5359    }
5360}
5361#[derive(Clone, PartialEq, ::prost::Message)]
5362pub struct FftSpec {
5363    #[prost(message, optional, tag = "1")]
5364    pub input: ::core::option::Option<NumericExpression>,
5365    #[prost(enumeration = "ComputeFftWindow", optional, tag = "2")]
5366    pub window: ::core::option::Option<i32>,
5367    #[prost(message, optional, tag = "3")]
5368    pub bucketing: ::core::option::Option<FrequencyBucketing>,
5369    #[prost(int32, optional, tag = "4")]
5370    pub fft_length: ::core::option::Option<i32>,
5371}
5372#[derive(Clone, PartialEq, ::prost::Message)]
5373pub struct PowerSpectralDensitySpec {
5374    #[prost(message, optional, tag = "1")]
5375    pub input: ::core::option::Option<NumericExpression>,
5376    #[prost(message, optional, tag = "2")]
5377    pub stft: ::core::option::Option<StftConfiguration>,
5378    #[prost(enumeration = "ComputeMagnitudeScaling", optional, tag = "3")]
5379    pub magnitude_scaling: ::core::option::Option<i32>,
5380    #[prost(enumeration = "ComputeFrequencyUnit", optional, tag = "4")]
5381    pub frequency_unit: ::core::option::Option<i32>,
5382    #[prost(message, optional, tag = "5")]
5383    pub bucketing: ::core::option::Option<FrequencyBucketing>,
5384}
5385#[derive(Clone, PartialEq, ::prost::Message)]
5386pub struct CrossSpectralDensitySpec {
5387    #[prost(message, optional, tag = "1")]
5388    pub x: ::core::option::Option<NumericExpression>,
5389    #[prost(message, optional, tag = "2")]
5390    pub y: ::core::option::Option<NumericExpression>,
5391    #[prost(message, optional, tag = "3")]
5392    pub stft: ::core::option::Option<StftConfiguration>,
5393    #[prost(enumeration = "ComputeMagnitudeScaling", optional, tag = "4")]
5394    pub magnitude_scaling: ::core::option::Option<i32>,
5395    #[prost(enumeration = "ComputeFrequencyUnit", optional, tag = "5")]
5396    pub frequency_unit: ::core::option::Option<i32>,
5397    #[prost(bool, optional, tag = "6")]
5398    pub unwrap_phase: ::core::option::Option<bool>,
5399    #[prost(enumeration = "ComputePhaseUnit", optional, tag = "7")]
5400    pub phase_unit: ::core::option::Option<i32>,
5401}
5402#[derive(Clone, PartialEq, ::prost::Message)]
5403pub struct FrequencyResponseSpec {
5404    #[prost(message, optional, tag = "1")]
5405    pub input: ::core::option::Option<NumericExpression>,
5406    #[prost(message, optional, tag = "2")]
5407    pub output: ::core::option::Option<NumericExpression>,
5408    #[prost(message, optional, tag = "3")]
5409    pub stft: ::core::option::Option<StftConfiguration>,
5410}
5411#[derive(Clone, PartialEq, ::prost::Message)]
5412pub struct BodeSpec {
5413    #[prost(message, optional, tag = "1")]
5414    pub input: ::core::option::Option<NumericExpression>,
5415    #[prost(message, optional, tag = "2")]
5416    pub output: ::core::option::Option<NumericExpression>,
5417    #[prost(message, optional, tag = "3")]
5418    pub alignment: ::core::option::Option<SignalAlignment>,
5419    #[prost(message, optional, tag = "4")]
5420    pub stft: ::core::option::Option<StftConfiguration>,
5421    #[prost(enumeration = "ComputeMagnitudeScaling", optional, tag = "5")]
5422    pub magnitude_scaling: ::core::option::Option<i32>,
5423    #[prost(enumeration = "ComputeFrequencyUnit", optional, tag = "6")]
5424    pub frequency_unit: ::core::option::Option<i32>,
5425    #[prost(bool, optional, tag = "7")]
5426    pub unwrap_phase: ::core::option::Option<bool>,
5427}
5428#[derive(Clone, PartialEq, ::prost::Message)]
5429pub struct SignalAlignment {
5430    #[prost(message, optional, tag = "1")]
5431    pub interpolation: ::core::option::Option<InterpolationConfiguration>,
5432    #[prost(enumeration = "SignalAlignmentDriver", tag = "2")]
5433    pub driver: i32,
5434}
5435#[derive(Clone, PartialEq, ::prost::Message)]
5436pub struct SpectrogramSpec {
5437    #[prost(message, optional, tag = "1")]
5438    pub input: ::core::option::Option<NumericExpression>,
5439    #[prost(message, optional, tag = "2")]
5440    pub stft: ::core::option::Option<StftConfiguration>,
5441    #[prost(enumeration = "SpectrogramQuantity", optional, tag = "3")]
5442    pub quantity: ::core::option::Option<i32>,
5443    #[prost(enumeration = "ComputeMagnitudeScaling", optional, tag = "4")]
5444    pub magnitude_scaling: ::core::option::Option<i32>,
5445    #[prost(message, optional, tag = "5")]
5446    pub bucketing: ::core::option::Option<SpectrogramBucketing>,
5447}
5448#[derive(Clone, PartialEq, ::prost::Message)]
5449pub struct HistogramSpec {
5450    #[prost(oneof = "histogram_spec::Kind", tags = "1, 2")]
5451    pub kind: ::core::option::Option<histogram_spec::Kind>,
5452}
5453/// Nested message and enum types in `HistogramSpec`.
5454pub mod histogram_spec {
5455    #[derive(Clone, PartialEq, ::prost::Oneof)]
5456    pub enum Kind {
5457        #[prost(message, tag = "1")]
5458        Numeric(super::NumericHistogramSpec),
5459        #[prost(message, tag = "2")]
5460        Categorical(super::CategoricalHistogramSpec),
5461    }
5462}
5463#[derive(Clone, PartialEq, ::prost::Message)]
5464pub struct NumericHistogramSpec {
5465    #[prost(map = "string, message", tag = "1")]
5466    pub inputs: ::std::collections::HashMap<
5467        ::prost::alloc::string::String,
5468        NumericExpression,
5469    >,
5470    #[prost(message, optional, tag = "2")]
5471    pub bucketing: ::core::option::Option<NumericHistogramBucketing>,
5472}
5473#[derive(Clone, PartialEq, ::prost::Message)]
5474pub struct NumericHistogramBucketing {
5475    #[prost(oneof = "numeric_histogram_bucketing::Kind", tags = "1, 2")]
5476    pub kind: ::core::option::Option<numeric_histogram_bucketing::Kind>,
5477}
5478/// Nested message and enum types in `NumericHistogramBucketing`.
5479pub mod numeric_histogram_bucketing {
5480    #[derive(Clone, PartialEq, ::prost::Oneof)]
5481    pub enum Kind {
5482        #[prost(message, tag = "1")]
5483        BucketCount(super::IntegerConstant),
5484        #[prost(message, tag = "2")]
5485        WidthAndOffset(super::HistogramWidthAndOffset),
5486    }
5487}
5488#[derive(Clone, PartialEq, ::prost::Message)]
5489pub struct HistogramWidthAndOffset {
5490    #[prost(message, optional, tag = "1")]
5491    pub width: ::core::option::Option<DoubleConstant>,
5492    #[prost(message, optional, tag = "2")]
5493    pub offset: ::core::option::Option<DoubleConstant>,
5494}
5495#[derive(Clone, PartialEq, ::prost::Message)]
5496pub struct CategoricalHistogramSpec {
5497    #[prost(map = "string, message", tag = "1")]
5498    pub inputs: ::std::collections::HashMap<
5499        ::prost::alloc::string::String,
5500        CategoricalExpression,
5501    >,
5502}
5503#[derive(Clone, PartialEq, ::prost::Message)]
5504pub struct MultivariateSummarySpec {
5505    #[prost(message, repeated, tag = "1")]
5506    pub inputs: ::prost::alloc::vec::Vec<MultivariateSummaryInput>,
5507    #[prost(enumeration = "ComputeOutputFormat", optional, tag = "2")]
5508    pub output_format: ::core::option::Option<i32>,
5509    #[prost(int32, optional, tag = "3")]
5510    pub bucket_count: ::core::option::Option<i32>,
5511    #[prost(message, optional, tag = "4")]
5512    pub interpolation: ::core::option::Option<InterpolationConfiguration>,
5513}
5514#[derive(Clone, PartialEq, ::prost::Message)]
5515pub struct MultivariateSummaryInput {
5516    #[prost(oneof = "multivariate_summary_input::Kind", tags = "1, 2")]
5517    pub kind: ::core::option::Option<multivariate_summary_input::Kind>,
5518}
5519/// Nested message and enum types in `MultivariateSummaryInput`.
5520pub mod multivariate_summary_input {
5521    #[derive(Clone, PartialEq, ::prost::Oneof)]
5522    pub enum Kind {
5523        #[prost(message, tag = "1")]
5524        Numeric(super::MultivariateNumericInput),
5525        #[prost(message, tag = "2")]
5526        Categorical(super::MultivariateCategoricalInput),
5527    }
5528}
5529#[derive(Clone, PartialEq, ::prost::Message)]
5530pub struct MultivariateNumericInput {
5531    #[prost(message, optional, tag = "1")]
5532    pub input: ::core::option::Option<NumericExpression>,
5533    #[prost(
5534        enumeration = "MultivariateNumericReduction",
5535        repeated,
5536        packed = "false",
5537        tag = "2"
5538    )]
5539    pub reductions: ::prost::alloc::vec::Vec<i32>,
5540}
5541#[derive(Clone, PartialEq, ::prost::Message)]
5542pub struct MultivariateCategoricalInput {
5543    #[prost(message, optional, tag = "1")]
5544    pub input: ::core::option::Option<CategoricalExpression>,
5545    #[prost(
5546        enumeration = "MultivariateCategoricalReduction",
5547        repeated,
5548        packed = "false",
5549        tag = "2"
5550    )]
5551    pub reductions: ::prost::alloc::vec::Vec<i32>,
5552}
5553#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
5554#[repr(i32)]
5555pub enum ComputePointRepresentation {
5556    Unspecified = 0,
5557    TypedSample = 1,
5558    ValueSample = 2,
5559}
5560impl ComputePointRepresentation {
5561    /// String value of the enum field names used in the ProtoBuf definition.
5562    ///
5563    /// The values are not transformed in any way and thus are considered stable
5564    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
5565    pub fn as_str_name(&self) -> &'static str {
5566        match self {
5567            Self::Unspecified => "COMPUTE_POINT_REPRESENTATION_UNSPECIFIED",
5568            Self::TypedSample => "COMPUTE_POINT_REPRESENTATION_TYPED_SAMPLE",
5569            Self::ValueSample => "COMPUTE_POINT_REPRESENTATION_VALUE_SAMPLE",
5570        }
5571    }
5572    /// Creates an enum from field names used in the ProtoBuf definition.
5573    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
5574        match value {
5575            "COMPUTE_POINT_REPRESENTATION_UNSPECIFIED" => Some(Self::Unspecified),
5576            "COMPUTE_POINT_REPRESENTATION_TYPED_SAMPLE" => Some(Self::TypedSample),
5577            "COMPUTE_POINT_REPRESENTATION_VALUE_SAMPLE" => Some(Self::ValueSample),
5578            _ => None,
5579        }
5580    }
5581}
5582#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
5583#[repr(i32)]
5584pub enum SignalAlignmentDriver {
5585    Unspecified = 0,
5586    Input = 1,
5587    Output = 2,
5588}
5589impl SignalAlignmentDriver {
5590    /// String value of the enum field names used in the ProtoBuf definition.
5591    ///
5592    /// The values are not transformed in any way and thus are considered stable
5593    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
5594    pub fn as_str_name(&self) -> &'static str {
5595        match self {
5596            Self::Unspecified => "SIGNAL_ALIGNMENT_DRIVER_UNSPECIFIED",
5597            Self::Input => "SIGNAL_ALIGNMENT_DRIVER_INPUT",
5598            Self::Output => "SIGNAL_ALIGNMENT_DRIVER_OUTPUT",
5599        }
5600    }
5601    /// Creates an enum from field names used in the ProtoBuf definition.
5602    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
5603        match value {
5604            "SIGNAL_ALIGNMENT_DRIVER_UNSPECIFIED" => Some(Self::Unspecified),
5605            "SIGNAL_ALIGNMENT_DRIVER_INPUT" => Some(Self::Input),
5606            "SIGNAL_ALIGNMENT_DRIVER_OUTPUT" => Some(Self::Output),
5607            _ => None,
5608        }
5609    }
5610}
5611#[derive(Clone, PartialEq, ::prost::Message)]
5612pub struct ExecutionInput {
5613    #[prost(message, optional, tag = "1")]
5614    pub computation: ::core::option::Option<ComputationSpec>,
5615    #[prost(message, optional, tag = "2")]
5616    pub start: ::core::option::Option<super::super::types::time::Timestamp>,
5617    #[prost(message, optional, tag = "3")]
5618    pub end: ::core::option::Option<super::super::types::time::Timestamp>,
5619    #[prost(message, optional, tag = "4")]
5620    pub context: ::core::option::Option<ComputeContext>,
5621    #[prost(string, optional, tag = "5")]
5622    pub source_rid: ::core::option::Option<::prost::alloc::string::String>,
5623    #[prost(string, optional, tag = "6")]
5624    pub request_id: ::core::option::Option<::prost::alloc::string::String>,
5625}
5626#[derive(Clone, PartialEq, ::prost::Message)]
5627pub struct UnitResolutionInput {
5628    #[prost(message, optional, tag = "1")]
5629    pub computation: ::core::option::Option<ComputationSpec>,
5630    #[prost(message, optional, tag = "2")]
5631    pub context: ::core::option::Option<ComputeContext>,
5632}
5633#[derive(Clone, Copy, PartialEq, ::prost::Message)]
5634pub struct ExecutionWindowOverride {
5635    #[prost(message, optional, tag = "1")]
5636    pub start: ::core::option::Option<super::super::types::time::Timestamp>,
5637    #[prost(message, optional, tag = "2")]
5638    pub end: ::core::option::Option<super::super::types::time::Timestamp>,
5639}
5640#[derive(Clone, PartialEq, ::prost::Message)]
5641pub struct ParameterOverlay {
5642    #[prost(map = "string, message", tag = "1")]
5643    pub variables: ::std::collections::HashMap<
5644        ::prost::alloc::string::String,
5645        VariableValue,
5646    >,
5647    #[prost(message, optional, tag = "2")]
5648    pub window: ::core::option::Option<ExecutionWindowOverride>,
5649}
5650#[derive(Clone, PartialEq, ::prost::Message)]
5651pub struct ParameterizedExecutionInput {
5652    #[prost(message, optional, tag = "1")]
5653    pub computation: ::core::option::Option<ComputationSpec>,
5654    #[prost(message, optional, tag = "2")]
5655    pub start: ::core::option::Option<super::super::types::time::Timestamp>,
5656    #[prost(message, optional, tag = "3")]
5657    pub end: ::core::option::Option<super::super::types::time::Timestamp>,
5658    #[prost(message, optional, tag = "4")]
5659    pub context: ::core::option::Option<ComputeContext>,
5660    #[prost(string, optional, tag = "5")]
5661    pub source_rid: ::core::option::Option<::prost::alloc::string::String>,
5662    #[prost(message, repeated, tag = "6")]
5663    pub overlays: ::prost::alloc::vec::Vec<ParameterOverlay>,
5664}
5665#[derive(Clone, PartialEq, ::prost::Message)]
5666pub struct ExecutionBatch {
5667    #[prost(message, repeated, tag = "1")]
5668    pub inputs: ::prost::alloc::vec::Vec<ExecutionInput>,
5669}
5670#[derive(Clone, PartialEq, ::prost::Message)]
5671pub struct UnitResolutionBatch {
5672    #[prost(message, repeated, tag = "1")]
5673    pub inputs: ::prost::alloc::vec::Vec<UnitResolutionInput>,
5674}
5675#[derive(Clone, Copy, PartialEq, ::prost::Message)]
5676pub struct CurveFitMetrics {
5677    #[prost(double, tag = "1")]
5678    pub r_squared: f64,
5679    #[prost(double, tag = "2")]
5680    pub mean_absolute_error: f64,
5681    #[prost(double, tag = "3")]
5682    pub mean_squared_error: f64,
5683    #[prost(double, tag = "4")]
5684    pub root_mean_squared_error: f64,
5685    #[prost(double, tag = "5")]
5686    pub max_absolute_error: f64,
5687    #[prost(int32, tag = "6")]
5688    pub sample_count: i32,
5689}
5690#[derive(Clone, Copy, PartialEq, ::prost::Message)]
5691pub struct ExponentialCurveParameters {
5692    #[prost(double, tag = "1")]
5693    pub a: f64,
5694    #[prost(double, tag = "2")]
5695    pub b: f64,
5696}
5697#[derive(Clone, Copy, PartialEq, ::prost::Message)]
5698pub struct LogarithmicCurveParameters {
5699    #[prost(double, tag = "1")]
5700    pub a: f64,
5701    #[prost(double, tag = "2")]
5702    pub b: f64,
5703}
5704#[derive(Clone, PartialEq, ::prost::Message)]
5705pub struct PolynomialCurveParameters {
5706    #[prost(double, repeated, tag = "1")]
5707    pub coefficients: ::prost::alloc::vec::Vec<f64>,
5708}
5709#[derive(Clone, Copy, PartialEq, ::prost::Message)]
5710pub struct PowerCurveParameters {
5711    #[prost(double, tag = "1")]
5712    pub a: f64,
5713    #[prost(double, tag = "2")]
5714    pub b: f64,
5715}
5716#[derive(Clone, PartialEq, ::prost::Message)]
5717pub struct CustomCurveParameters {
5718    #[prost(map = "string, double", tag = "1")]
5719    pub parameters: ::std::collections::HashMap<::prost::alloc::string::String, f64>,
5720    #[prost(bool, tag = "2")]
5721    pub converged: bool,
5722    #[prost(int32, tag = "3")]
5723    pub iterations: i32,
5724}
5725#[derive(Clone, PartialEq, ::prost::Message)]
5726pub struct FittedCurve {
5727    #[prost(message, optional, tag = "1")]
5728    pub metrics: ::core::option::Option<CurveFitMetrics>,
5729    #[prost(oneof = "fitted_curve::Parameters", tags = "2, 3, 4, 5, 6")]
5730    pub parameters: ::core::option::Option<fitted_curve::Parameters>,
5731}
5732/// Nested message and enum types in `FittedCurve`.
5733pub mod fitted_curve {
5734    #[derive(Clone, PartialEq, ::prost::Oneof)]
5735    pub enum Parameters {
5736        #[prost(message, tag = "2")]
5737        Exponential(super::ExponentialCurveParameters),
5738        #[prost(message, tag = "3")]
5739        Logarithmic(super::LogarithmicCurveParameters),
5740        #[prost(message, tag = "4")]
5741        Polynomial(super::PolynomialCurveParameters),
5742        #[prost(message, tag = "5")]
5743        Power(super::PowerCurveParameters),
5744        #[prost(message, tag = "6")]
5745        Custom(super::CustomCurveParameters),
5746    }
5747}
5748#[derive(Clone, Copy, PartialEq, ::prost::Message)]
5749pub struct RealFrequencySample {
5750    #[prost(double, tag = "1")]
5751    pub frequency: f64,
5752    #[prost(double, tag = "2")]
5753    pub amplitude: f64,
5754}
5755#[derive(Clone, Copy, PartialEq, ::prost::Message)]
5756pub struct ComplexFrequencySample {
5757    #[prost(double, tag = "1")]
5758    pub frequency: f64,
5759    #[prost(double, tag = "2")]
5760    pub real: f64,
5761    #[prost(double, tag = "3")]
5762    pub imaginary: f64,
5763}
5764#[derive(Clone, Copy, PartialEq, ::prost::Message)]
5765pub struct PolarFrequencySample {
5766    #[prost(double, tag = "1")]
5767    pub frequency: f64,
5768    #[prost(double, tag = "2")]
5769    pub magnitude: f64,
5770    #[prost(double, tag = "3")]
5771    pub phase: f64,
5772}
5773#[derive(Clone, PartialEq, ::prost::Message)]
5774pub struct RealFrequencySamples {
5775    #[prost(message, repeated, tag = "1")]
5776    pub samples: ::prost::alloc::vec::Vec<RealFrequencySample>,
5777}
5778#[derive(Clone, PartialEq, ::prost::Message)]
5779pub struct ComplexFrequencySamples {
5780    #[prost(message, repeated, tag = "1")]
5781    pub samples: ::prost::alloc::vec::Vec<ComplexFrequencySample>,
5782}
5783#[derive(Clone, PartialEq, ::prost::Message)]
5784pub struct PolarFrequencySamples {
5785    #[prost(message, repeated, tag = "1")]
5786    pub samples: ::prost::alloc::vec::Vec<PolarFrequencySample>,
5787}
5788#[derive(Clone, PartialEq, ::prost::Message)]
5789pub struct FrequencySamples {
5790    #[prost(oneof = "frequency_samples::Kind", tags = "1, 2, 3")]
5791    pub kind: ::core::option::Option<frequency_samples::Kind>,
5792}
5793/// Nested message and enum types in `FrequencySamples`.
5794pub mod frequency_samples {
5795    #[derive(Clone, PartialEq, ::prost::Oneof)]
5796    pub enum Kind {
5797        #[prost(message, tag = "1")]
5798        Real(super::RealFrequencySamples),
5799        #[prost(message, tag = "2")]
5800        Complex(super::ComplexFrequencySamples),
5801        #[prost(message, tag = "3")]
5802        Polar(super::PolarFrequencySamples),
5803    }
5804}
5805#[derive(Clone, Copy, PartialEq, ::prost::Message)]
5806pub struct FrequencyResultBucket {
5807    #[prost(double, tag = "1")]
5808    pub start_frequency: f64,
5809    #[prost(double, tag = "2")]
5810    pub end_frequency: f64,
5811    #[prost(double, tag = "3")]
5812    pub center_frequency: f64,
5813    #[prost(double, tag = "4")]
5814    pub min_amplitude: f64,
5815    #[prost(double, tag = "5")]
5816    pub max_amplitude: f64,
5817    #[prost(double, tag = "6")]
5818    pub mean_amplitude: f64,
5819    #[prost(int64, tag = "7")]
5820    pub count: i64,
5821    #[prost(message, optional, tag = "8")]
5822    pub first: ::core::option::Option<RealFrequencySample>,
5823    #[prost(message, optional, tag = "9")]
5824    pub last: ::core::option::Option<RealFrequencySample>,
5825}
5826#[derive(Clone, PartialEq, ::prost::Message)]
5827pub struct FrequencyBuckets {
5828    #[prost(message, repeated, tag = "1")]
5829    pub buckets: ::prost::alloc::vec::Vec<FrequencyResultBucket>,
5830}
5831#[derive(Clone, PartialEq, ::prost::Message)]
5832pub struct SpectrogramResultRow {
5833    #[prost(message, optional, tag = "1")]
5834    pub start: ::core::option::Option<super::super::types::time::Timestamp>,
5835    #[prost(message, optional, tag = "2")]
5836    pub end: ::core::option::Option<super::super::types::time::Timestamp>,
5837    #[prost(double, repeated, tag = "3")]
5838    pub values: ::prost::alloc::vec::Vec<f64>,
5839}
5840#[derive(Clone, PartialEq, ::prost::Message)]
5841pub struct SpectrogramGrid {
5842    #[prost(double, repeated, tag = "1")]
5843    pub frequency_centers: ::prost::alloc::vec::Vec<f64>,
5844    #[prost(double, repeated, tag = "2")]
5845    pub frequency_edges: ::prost::alloc::vec::Vec<f64>,
5846    #[prost(message, repeated, tag = "3")]
5847    pub rows: ::prost::alloc::vec::Vec<SpectrogramResultRow>,
5848}
5849#[derive(Clone, Copy, PartialEq, ::prost::Message)]
5850pub struct CartesianSample {
5851    #[prost(message, optional, tag = "1")]
5852    pub timestamp: ::core::option::Option<super::super::types::time::Timestamp>,
5853    #[prost(double, tag = "2")]
5854    pub x: f64,
5855    #[prost(double, tag = "3")]
5856    pub y: f64,
5857}
5858#[derive(Clone, PartialEq, ::prost::Message)]
5859pub struct CartesianSamples {
5860    #[prost(message, repeated, tag = "1")]
5861    pub samples: ::prost::alloc::vec::Vec<CartesianSample>,
5862}
5863#[derive(Clone, Copy, PartialEq, ::prost::Message)]
5864pub struct CartesianResultBucket {
5865    #[prost(double, tag = "1")]
5866    pub min_x: f64,
5867    #[prost(double, tag = "2")]
5868    pub max_x: f64,
5869    #[prost(double, tag = "3")]
5870    pub min_y: f64,
5871    #[prost(double, tag = "4")]
5872    pub max_y: f64,
5873    #[prost(message, optional, tag = "5")]
5874    pub min_timestamp: ::core::option::Option<super::super::types::time::Timestamp>,
5875    #[prost(message, optional, tag = "6")]
5876    pub max_timestamp: ::core::option::Option<super::super::types::time::Timestamp>,
5877    #[prost(int64, tag = "7")]
5878    pub count: i64,
5879}
5880#[derive(Clone, PartialEq, ::prost::Message)]
5881pub struct CartesianBuckets {
5882    #[prost(message, repeated, tag = "1")]
5883    pub buckets: ::prost::alloc::vec::Vec<CartesianResultBucket>,
5884}
5885#[derive(Clone, Copy, PartialEq, ::prost::Message)]
5886pub struct Cartesian3dSample {
5887    #[prost(double, tag = "1")]
5888    pub x: f64,
5889    #[prost(double, tag = "2")]
5890    pub y: f64,
5891    #[prost(double, tag = "3")]
5892    pub z: f64,
5893    #[prost(message, optional, tag = "4")]
5894    pub timestamp: ::core::option::Option<super::super::types::time::Timestamp>,
5895}
5896#[derive(Clone, Copy, PartialEq, ::prost::Message)]
5897pub struct Cartesian3dCentroid {
5898    #[prost(double, tag = "1")]
5899    pub x: f64,
5900    #[prost(double, tag = "2")]
5901    pub y: f64,
5902    #[prost(double, tag = "3")]
5903    pub z: f64,
5904}
5905#[derive(Clone, Copy, PartialEq, ::prost::Message)]
5906pub struct Cartesian3dResultBucket {
5907    #[prost(message, optional, tag = "1")]
5908    pub centroid: ::core::option::Option<Cartesian3dCentroid>,
5909    #[prost(message, optional, tag = "2")]
5910    pub min_x_point: ::core::option::Option<Cartesian3dSample>,
5911    #[prost(message, optional, tag = "3")]
5912    pub max_x_point: ::core::option::Option<Cartesian3dSample>,
5913    #[prost(message, optional, tag = "4")]
5914    pub min_y_point: ::core::option::Option<Cartesian3dSample>,
5915    #[prost(message, optional, tag = "5")]
5916    pub max_y_point: ::core::option::Option<Cartesian3dSample>,
5917    #[prost(message, optional, tag = "6")]
5918    pub min_z_point: ::core::option::Option<Cartesian3dSample>,
5919    #[prost(message, optional, tag = "7")]
5920    pub max_z_point: ::core::option::Option<Cartesian3dSample>,
5921    #[prost(message, optional, tag = "8")]
5922    pub min_timestamp: ::core::option::Option<super::super::types::time::Timestamp>,
5923    #[prost(message, optional, tag = "9")]
5924    pub max_timestamp: ::core::option::Option<super::super::types::time::Timestamp>,
5925    #[prost(int64, tag = "10")]
5926    pub count: i64,
5927}
5928#[derive(Clone, PartialEq, ::prost::Message)]
5929pub struct Cartesian3dBuckets {
5930    #[prost(message, repeated, tag = "1")]
5931    pub buckets: ::prost::alloc::vec::Vec<Cartesian3dResultBucket>,
5932}
5933#[derive(Clone, PartialEq, ::prost::Message)]
5934pub struct MultivariateResultBucket {
5935    #[prost(message, optional, tag = "1")]
5936    pub timestamp: ::core::option::Option<super::super::types::time::Timestamp>,
5937    #[prost(message, repeated, tag = "2")]
5938    pub values: ::prost::alloc::vec::Vec<ComputeValue>,
5939}
5940#[derive(Clone, PartialEq, ::prost::Message)]
5941pub struct MultivariateBuckets {
5942    #[prost(message, repeated, tag = "1")]
5943    pub buckets: ::prost::alloc::vec::Vec<MultivariateResultBucket>,
5944    #[prost(message, optional, tag = "2")]
5945    pub grouping_keys: ::core::option::Option<ResultGroupingKeys>,
5946}
5947#[derive(Clone, PartialEq, ::prost::Message)]
5948pub struct IntervalCollection {
5949    #[prost(message, repeated, tag = "1")]
5950    pub intervals: ::prost::alloc::vec::Vec<ResultInterval>,
5951}
5952#[derive(Clone, Copy, PartialEq, ::prost::Message)]
5953pub struct IntervalSummary {
5954    #[prost(message, optional, tag = "1")]
5955    pub interval: ::core::option::Option<ResultInterval>,
5956    #[prost(int32, tag = "2")]
5957    pub interval_count: i32,
5958}
5959#[derive(Clone, PartialEq, ::prost::Message)]
5960pub struct IntervalSummaries {
5961    #[prost(message, repeated, tag = "1")]
5962    pub summaries: ::prost::alloc::vec::Vec<IntervalSummary>,
5963}
5964#[derive(Clone, Copy, PartialEq, ::prost::Message)]
5965pub struct OptionalIntervalResult {
5966    #[prost(message, optional, tag = "1")]
5967    pub interval: ::core::option::Option<ResultInterval>,
5968}
5969#[derive(Clone, Copy, PartialEq, ::prost::Message)]
5970pub struct OptionalNumericSampleResult {
5971    #[prost(message, optional, tag = "1")]
5972    pub sample: ::core::option::Option<NumericSample>,
5973}
5974#[derive(Clone, PartialEq, ::prost::Message)]
5975pub struct OptionalCategoricalSampleResult {
5976    #[prost(message, optional, tag = "1")]
5977    pub sample: ::core::option::Option<CategoricalSample>,
5978}
5979#[derive(Clone, PartialEq, ::prost::Message)]
5980pub struct OptionalValueSampleResult {
5981    #[prost(message, optional, tag = "1")]
5982    pub sample: ::core::option::Option<ValueSample>,
5983}
5984#[derive(Clone, PartialEq, ::prost::Message)]
5985pub struct OptionalLogSampleResult {
5986    #[prost(message, optional, tag = "1")]
5987    pub sample: ::core::option::Option<LogSample>,
5988}
5989#[derive(Clone, PartialEq, ::prost::Message)]
5990pub struct GroupedComputationResult {
5991    #[prost(message, optional, tag = "1")]
5992    pub grouping: ::core::option::Option<ResultGrouping>,
5993    #[prost(message, optional, tag = "2")]
5994    pub result: ::core::option::Option<ComputationResult>,
5995}
5996#[derive(Clone, PartialEq, ::prost::Message)]
5997pub struct GroupedComputationResults {
5998    #[prost(message, repeated, tag = "1")]
5999    pub groups: ::prost::alloc::vec::Vec<GroupedComputationResult>,
6000}
6001#[derive(Clone, PartialEq, ::prost::Message)]
6002pub struct ComputationResult {
6003    #[prost(
6004        oneof = "computation_result::Kind",
6005        tags = "1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24"
6006    )]
6007    pub kind: ::core::option::Option<computation_result::Kind>,
6008}
6009/// Nested message and enum types in `ComputationResult`.
6010pub mod computation_result {
6011    #[derive(Clone, PartialEq, ::prost::Oneof)]
6012    pub enum Kind {
6013        #[prost(message, tag = "1")]
6014        Intervals(super::IntervalCollection),
6015        #[prost(message, tag = "2")]
6016        IntervalSummaries(super::IntervalSummaries),
6017        #[prost(message, tag = "3")]
6018        Interval(super::OptionalIntervalResult),
6019        #[prost(message, tag = "4")]
6020        NumericSamples(super::NumericSamples),
6021        #[prost(message, tag = "5")]
6022        NumericBuckets(super::NumericBuckets),
6023        #[prost(message, tag = "6")]
6024        NumericSample(super::OptionalNumericSampleResult),
6025        #[prost(message, tag = "7")]
6026        ValueSample(super::OptionalValueSampleResult),
6027        #[prost(message, tag = "8")]
6028        CategoricalSamples(super::CategoricalSamples),
6029        #[prost(message, tag = "9")]
6030        CategoricalBuckets(super::CategoricalBuckets),
6031        #[prost(message, tag = "10")]
6032        CategoricalSample(super::OptionalCategoricalSampleResult),
6033        #[prost(message, tag = "11")]
6034        LogSamples(super::LogSamples),
6035        #[prost(message, tag = "12")]
6036        LogSample(super::OptionalLogSampleResult),
6037        #[prost(message, tag = "13")]
6038        CartesianSamples(super::CartesianSamples),
6039        #[prost(message, tag = "14")]
6040        CartesianBuckets(super::CartesianBuckets),
6041        #[prost(message, tag = "15")]
6042        Cartesian3dBuckets(super::Cartesian3dBuckets),
6043        #[prost(message, tag = "16")]
6044        FrequencySamples(super::FrequencySamples),
6045        #[prost(message, tag = "17")]
6046        FrequencyBuckets(super::FrequencyBuckets),
6047        #[prost(message, tag = "18")]
6048        Spectrogram(super::SpectrogramGrid),
6049        #[prost(message, tag = "19")]
6050        NumericHistogram(super::NumericHistogram),
6051        #[prost(message, tag = "20")]
6052        CategoricalHistogram(super::CategoricalHistogram),
6053        #[prost(message, tag = "21")]
6054        FittedCurve(super::FittedCurve),
6055        #[prost(message, tag = "22")]
6056        Grouped(super::GroupedComputationResults),
6057        #[prost(message, tag = "23")]
6058        Arrow(super::ArrowResult),
6059        #[prost(message, tag = "24")]
6060        MultivariateBuckets(super::MultivariateBuckets),
6061    }
6062}
6063#[derive(Clone, PartialEq, ::prost::Message)]
6064pub struct ComputationOutcome {
6065    #[prost(oneof = "computation_outcome::Kind", tags = "1, 2")]
6066    pub kind: ::core::option::Option<computation_outcome::Kind>,
6067}
6068/// Nested message and enum types in `ComputationOutcome`.
6069pub mod computation_outcome {
6070    #[derive(Clone, PartialEq, ::prost::Oneof)]
6071    pub enum Kind {
6072        #[prost(message, tag = "1")]
6073        Success(super::ComputationResult),
6074        #[prost(message, tag = "2")]
6075        Failure(super::ComputationFailure),
6076    }
6077}
6078#[derive(Clone, PartialEq, ::prost::Message)]
6079pub struct ComputationWithUnits {
6080    #[prost(message, optional, tag = "1")]
6081    pub result: ::core::option::Option<ComputationResult>,
6082    #[prost(message, optional, tag = "2")]
6083    pub units: ::core::option::Option<ComputationUnits>,
6084}
6085#[derive(Clone, PartialEq, ::prost::Message)]
6086pub struct ComputationOutcomeWithUnits {
6087    #[prost(message, optional, tag = "1")]
6088    pub outcome: ::core::option::Option<ComputationOutcome>,
6089    #[prost(message, optional, tag = "2")]
6090    pub units: ::core::option::Option<ComputationUnits>,
6091}
6092#[derive(Clone, PartialEq, ::prost::Message)]
6093pub struct BatchCancelRequestsRequest {
6094    #[prost(string, repeated, tag = "1")]
6095    pub request_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
6096}
6097#[derive(Clone, Copy, PartialEq, ::prost::Message)]
6098pub struct BatchCancelRequestsResponse {}
6099#[derive(Clone, PartialEq, ::prost::Message)]
6100pub struct BatchGetRequestProgressRequest {
6101    #[prost(string, repeated, tag = "1")]
6102    pub request_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
6103}
6104#[derive(Clone, Copy, PartialEq, ::prost::Message)]
6105pub struct RequestInProgress {
6106    #[prost(int64, tag = "1")]
6107    pub read_rows: i64,
6108    #[prost(int64, tag = "2")]
6109    pub total_rows_approx: i64,
6110}
6111#[derive(Clone, Copy, PartialEq, ::prost::Message)]
6112pub struct RequestInactive {}
6113#[derive(Clone, PartialEq, ::prost::Message)]
6114pub struct RequestProgress {
6115    #[prost(string, tag = "1")]
6116    pub request_id: ::prost::alloc::string::String,
6117    #[prost(oneof = "request_progress::State", tags = "2, 3")]
6118    pub state: ::core::option::Option<request_progress::State>,
6119}
6120/// Nested message and enum types in `RequestProgress`.
6121pub mod request_progress {
6122    #[derive(Clone, Copy, PartialEq, ::prost::Oneof)]
6123    pub enum State {
6124        #[prost(message, tag = "2")]
6125        InProgress(super::RequestInProgress),
6126        #[prost(message, tag = "3")]
6127        Inactive(super::RequestInactive),
6128    }
6129}
6130#[derive(Clone, PartialEq, ::prost::Message)]
6131pub struct BatchGetRequestProgressResponse {
6132    #[prost(message, repeated, tag = "1")]
6133    pub progress: ::prost::alloc::vec::Vec<RequestProgress>,
6134}
6135#[derive(Clone, Copy, PartialEq, ::prost::Message)]
6136pub struct QuotaWindow {
6137    #[prost(message, optional, tag = "1")]
6138    pub start_time: ::core::option::Option<
6139        super::super::super::google::protobuf::Timestamp,
6140    >,
6141    #[prost(message, optional, tag = "2")]
6142    pub end_time: ::core::option::Option<
6143        super::super::super::google::protobuf::Timestamp,
6144    >,
6145}
6146#[derive(Clone, Copy, PartialEq, ::prost::Message)]
6147pub struct QuotaResourceUsage {
6148    #[prost(enumeration = "QuotaResourceType", tag = "1")]
6149    pub resource: i32,
6150    #[prost(double, tag = "2")]
6151    pub used: f64,
6152    #[prost(double, tag = "3")]
6153    pub limit: f64,
6154}
6155#[derive(Clone, PartialEq, ::prost::Message)]
6156pub struct QuotaIntervalUsage {
6157    #[prost(int64, tag = "1")]
6158    pub duration_seconds: i64,
6159    #[prost(message, optional, tag = "2")]
6160    pub current_window: ::core::option::Option<QuotaWindow>,
6161    #[prost(message, repeated, tag = "3")]
6162    pub resources: ::prost::alloc::vec::Vec<QuotaResourceUsage>,
6163}
6164#[derive(Clone, PartialEq, ::prost::Message)]
6165pub struct QuotaUsage {
6166    #[prost(message, repeated, tag = "1")]
6167    pub intervals: ::prost::alloc::vec::Vec<QuotaIntervalUsage>,
6168}
6169#[derive(Clone, PartialEq, ::prost::Message)]
6170pub struct ListQuotaUsageIntervalsRequest {
6171    #[prost(int32, optional, tag = "1")]
6172    pub page_size: ::core::option::Option<i32>,
6173    #[prost(string, tag = "2")]
6174    pub page_token: ::prost::alloc::string::String,
6175}
6176#[derive(Clone, PartialEq, ::prost::Message)]
6177pub struct ListQuotaUsageIntervalsResponse {
6178    #[prost(message, repeated, tag = "1")]
6179    pub intervals: ::prost::alloc::vec::Vec<QuotaIntervalUsage>,
6180    #[prost(string, tag = "2")]
6181    pub next_page_token: ::prost::alloc::string::String,
6182}
6183#[derive(Clone, PartialEq, ::prost::Message)]
6184pub struct ComputeRequest {
6185    #[prost(message, optional, tag = "1")]
6186    pub input: ::core::option::Option<ExecutionInput>,
6187}
6188#[derive(Clone, PartialEq, ::prost::Message)]
6189pub struct ComputeResponse {
6190    #[prost(message, optional, tag = "1")]
6191    pub result: ::core::option::Option<ComputationResult>,
6192}
6193#[derive(Clone, PartialEq, ::prost::Message)]
6194pub struct BatchComputeWithUnitsRequest {
6195    #[prost(message, repeated, tag = "1")]
6196    pub inputs: ::prost::alloc::vec::Vec<ExecutionInput>,
6197}
6198#[derive(Clone, PartialEq, ::prost::Message)]
6199pub struct BatchComputeWithUnitsResponse {
6200    #[prost(message, repeated, tag = "1")]
6201    pub results: ::prost::alloc::vec::Vec<ComputationOutcomeWithUnits>,
6202}
6203#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
6204#[repr(i32)]
6205pub enum ComputeRequestControlError {
6206    Unspecified = 0,
6207    InvalidRequestId = 1,
6208    InvalidPageToken = 2,
6209    InvalidPageSize = 3,
6210}
6211impl ComputeRequestControlError {
6212    /// String value of the enum field names used in the ProtoBuf definition.
6213    ///
6214    /// The values are not transformed in any way and thus are considered stable
6215    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
6216    pub fn as_str_name(&self) -> &'static str {
6217        match self {
6218            Self::Unspecified => "COMPUTE_REQUEST_CONTROL_ERROR_UNSPECIFIED",
6219            Self::InvalidRequestId => "COMPUTE_REQUEST_CONTROL_ERROR_INVALID_REQUEST_ID",
6220            Self::InvalidPageToken => "COMPUTE_REQUEST_CONTROL_ERROR_INVALID_PAGE_TOKEN",
6221            Self::InvalidPageSize => "COMPUTE_REQUEST_CONTROL_ERROR_INVALID_PAGE_SIZE",
6222        }
6223    }
6224    /// Creates an enum from field names used in the ProtoBuf definition.
6225    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
6226        match value {
6227            "COMPUTE_REQUEST_CONTROL_ERROR_UNSPECIFIED" => Some(Self::Unspecified),
6228            "COMPUTE_REQUEST_CONTROL_ERROR_INVALID_REQUEST_ID" => {
6229                Some(Self::InvalidRequestId)
6230            }
6231            "COMPUTE_REQUEST_CONTROL_ERROR_INVALID_PAGE_TOKEN" => {
6232                Some(Self::InvalidPageToken)
6233            }
6234            "COMPUTE_REQUEST_CONTROL_ERROR_INVALID_PAGE_SIZE" => {
6235                Some(Self::InvalidPageSize)
6236            }
6237            _ => None,
6238        }
6239    }
6240}
6241#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
6242#[repr(i32)]
6243pub enum ComputeRequestAdmissionError {
6244    Unspecified = 0,
6245    TooDeep = 1,
6246    TooManyMessages = 2,
6247    TooLarge = 3,
6248}
6249impl ComputeRequestAdmissionError {
6250    /// String value of the enum field names used in the ProtoBuf definition.
6251    ///
6252    /// The values are not transformed in any way and thus are considered stable
6253    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
6254    pub fn as_str_name(&self) -> &'static str {
6255        match self {
6256            Self::Unspecified => "COMPUTE_REQUEST_ADMISSION_ERROR_UNSPECIFIED",
6257            Self::TooDeep => "COMPUTE_REQUEST_ADMISSION_ERROR_TOO_DEEP",
6258            Self::TooManyMessages => "COMPUTE_REQUEST_ADMISSION_ERROR_TOO_MANY_MESSAGES",
6259            Self::TooLarge => "COMPUTE_REQUEST_ADMISSION_ERROR_TOO_LARGE",
6260        }
6261    }
6262    /// Creates an enum from field names used in the ProtoBuf definition.
6263    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
6264        match value {
6265            "COMPUTE_REQUEST_ADMISSION_ERROR_UNSPECIFIED" => Some(Self::Unspecified),
6266            "COMPUTE_REQUEST_ADMISSION_ERROR_TOO_DEEP" => Some(Self::TooDeep),
6267            "COMPUTE_REQUEST_ADMISSION_ERROR_TOO_MANY_MESSAGES" => {
6268                Some(Self::TooManyMessages)
6269            }
6270            "COMPUTE_REQUEST_ADMISSION_ERROR_TOO_LARGE" => Some(Self::TooLarge),
6271            _ => None,
6272        }
6273    }
6274}
6275#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
6276#[repr(i32)]
6277pub enum QuotaResourceType {
6278    Unspecified = 0,
6279    ReadRows = 1,
6280    ReadBytes = 2,
6281    Queries = 3,
6282    Errors = 4,
6283    ExecutionTime = 5,
6284}
6285impl QuotaResourceType {
6286    /// String value of the enum field names used in the ProtoBuf definition.
6287    ///
6288    /// The values are not transformed in any way and thus are considered stable
6289    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
6290    pub fn as_str_name(&self) -> &'static str {
6291        match self {
6292            Self::Unspecified => "QUOTA_RESOURCE_TYPE_UNSPECIFIED",
6293            Self::ReadRows => "QUOTA_RESOURCE_TYPE_READ_ROWS",
6294            Self::ReadBytes => "QUOTA_RESOURCE_TYPE_READ_BYTES",
6295            Self::Queries => "QUOTA_RESOURCE_TYPE_QUERIES",
6296            Self::Errors => "QUOTA_RESOURCE_TYPE_ERRORS",
6297            Self::ExecutionTime => "QUOTA_RESOURCE_TYPE_EXECUTION_TIME",
6298        }
6299    }
6300    /// Creates an enum from field names used in the ProtoBuf definition.
6301    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
6302        match value {
6303            "QUOTA_RESOURCE_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
6304            "QUOTA_RESOURCE_TYPE_READ_ROWS" => Some(Self::ReadRows),
6305            "QUOTA_RESOURCE_TYPE_READ_BYTES" => Some(Self::ReadBytes),
6306            "QUOTA_RESOURCE_TYPE_QUERIES" => Some(Self::Queries),
6307            "QUOTA_RESOURCE_TYPE_ERRORS" => Some(Self::Errors),
6308            "QUOTA_RESOURCE_TYPE_EXECUTION_TIME" => Some(Self::ExecutionTime),
6309            _ => None,
6310        }
6311    }
6312}
6313/// Generated client implementations.
6314pub mod compute_service_client {
6315    #![allow(
6316        unused_variables,
6317        dead_code,
6318        missing_docs,
6319        clippy::wildcard_imports,
6320        clippy::let_unit_value,
6321    )]
6322    use tonic::codegen::*;
6323    use tonic::codegen::http::Uri;
6324    #[derive(Debug, Clone)]
6325    pub struct ComputeServiceClient<T> {
6326        inner: tonic::client::Grpc<T>,
6327    }
6328    impl ComputeServiceClient<tonic::transport::Channel> {
6329        /// Attempt to create a new client by connecting to a given endpoint.
6330        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
6331        where
6332            D: TryInto<tonic::transport::Endpoint>,
6333            D::Error: Into<StdError>,
6334        {
6335            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
6336            Ok(Self::new(conn))
6337        }
6338    }
6339    impl<T> ComputeServiceClient<T>
6340    where
6341        T: tonic::client::GrpcService<tonic::body::Body>,
6342        T::Error: Into<StdError>,
6343        T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static,
6344        <T::ResponseBody as Body>::Error: Into<StdError> + std::marker::Send,
6345    {
6346        pub fn new(inner: T) -> Self {
6347            let inner = tonic::client::Grpc::new(inner);
6348            Self { inner }
6349        }
6350        pub fn with_origin(inner: T, origin: Uri) -> Self {
6351            let inner = tonic::client::Grpc::with_origin(inner, origin);
6352            Self { inner }
6353        }
6354        pub fn with_interceptor<F>(
6355            inner: T,
6356            interceptor: F,
6357        ) -> ComputeServiceClient<InterceptedService<T, F>>
6358        where
6359            F: tonic::service::Interceptor,
6360            T::ResponseBody: Default,
6361            T: tonic::codegen::Service<
6362                http::Request<tonic::body::Body>,
6363                Response = http::Response<
6364                    <T as tonic::client::GrpcService<tonic::body::Body>>::ResponseBody,
6365                >,
6366            >,
6367            <T as tonic::codegen::Service<
6368                http::Request<tonic::body::Body>,
6369            >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
6370        {
6371            ComputeServiceClient::new(InterceptedService::new(inner, interceptor))
6372        }
6373        /// Compress requests with the given encoding.
6374        ///
6375        /// This requires the server to support it otherwise it might respond with an
6376        /// error.
6377        #[must_use]
6378        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
6379            self.inner = self.inner.send_compressed(encoding);
6380            self
6381        }
6382        /// Enable decompressing responses.
6383        #[must_use]
6384        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
6385            self.inner = self.inner.accept_compressed(encoding);
6386            self
6387        }
6388        /// Limits the maximum size of a decoded message.
6389        ///
6390        /// Default: `4MB`
6391        #[must_use]
6392        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
6393            self.inner = self.inner.max_decoding_message_size(limit);
6394            self
6395        }
6396        /// Limits the maximum size of an encoded message.
6397        ///
6398        /// Default: `usize::MAX`
6399        #[must_use]
6400        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
6401            self.inner = self.inner.max_encoding_message_size(limit);
6402            self
6403        }
6404        pub async fn compute(
6405            &mut self,
6406            request: impl tonic::IntoRequest<super::ComputeRequest>,
6407        ) -> std::result::Result<
6408            tonic::Response<super::ComputeResponse>,
6409            tonic::Status,
6410        > {
6411            self.inner
6412                .ready()
6413                .await
6414                .map_err(|e| {
6415                    tonic::Status::unknown(
6416                        format!("Service was not ready: {}", e.into()),
6417                    )
6418                })?;
6419            let codec = tonic::codec::ProstCodec::default();
6420            let path = http::uri::PathAndQuery::from_static(
6421                "/nominal.compute.v1.ComputeService/Compute",
6422            );
6423            let mut req = request.into_request();
6424            req.extensions_mut()
6425                .insert(GrpcMethod::new("nominal.compute.v1.ComputeService", "Compute"));
6426            self.inner.unary(req, path, codec).await
6427        }
6428        pub async fn batch_compute_with_units(
6429            &mut self,
6430            request: impl tonic::IntoRequest<super::BatchComputeWithUnitsRequest>,
6431        ) -> std::result::Result<
6432            tonic::Response<super::BatchComputeWithUnitsResponse>,
6433            tonic::Status,
6434        > {
6435            self.inner
6436                .ready()
6437                .await
6438                .map_err(|e| {
6439                    tonic::Status::unknown(
6440                        format!("Service was not ready: {}", e.into()),
6441                    )
6442                })?;
6443            let codec = tonic::codec::ProstCodec::default();
6444            let path = http::uri::PathAndQuery::from_static(
6445                "/nominal.compute.v1.ComputeService/BatchComputeWithUnits",
6446            );
6447            let mut req = request.into_request();
6448            req.extensions_mut()
6449                .insert(
6450                    GrpcMethod::new(
6451                        "nominal.compute.v1.ComputeService",
6452                        "BatchComputeWithUnits",
6453                    ),
6454                );
6455            self.inner.unary(req, path, codec).await
6456        }
6457        pub async fn batch_cancel_requests(
6458            &mut self,
6459            request: impl tonic::IntoRequest<super::BatchCancelRequestsRequest>,
6460        ) -> std::result::Result<
6461            tonic::Response<super::BatchCancelRequestsResponse>,
6462            tonic::Status,
6463        > {
6464            self.inner
6465                .ready()
6466                .await
6467                .map_err(|e| {
6468                    tonic::Status::unknown(
6469                        format!("Service was not ready: {}", e.into()),
6470                    )
6471                })?;
6472            let codec = tonic::codec::ProstCodec::default();
6473            let path = http::uri::PathAndQuery::from_static(
6474                "/nominal.compute.v1.ComputeService/BatchCancelRequests",
6475            );
6476            let mut req = request.into_request();
6477            req.extensions_mut()
6478                .insert(
6479                    GrpcMethod::new(
6480                        "nominal.compute.v1.ComputeService",
6481                        "BatchCancelRequests",
6482                    ),
6483                );
6484            self.inner.unary(req, path, codec).await
6485        }
6486        pub async fn batch_get_request_progress(
6487            &mut self,
6488            request: impl tonic::IntoRequest<super::BatchGetRequestProgressRequest>,
6489        ) -> std::result::Result<
6490            tonic::Response<super::BatchGetRequestProgressResponse>,
6491            tonic::Status,
6492        > {
6493            self.inner
6494                .ready()
6495                .await
6496                .map_err(|e| {
6497                    tonic::Status::unknown(
6498                        format!("Service was not ready: {}", e.into()),
6499                    )
6500                })?;
6501            let codec = tonic::codec::ProstCodec::default();
6502            let path = http::uri::PathAndQuery::from_static(
6503                "/nominal.compute.v1.ComputeService/BatchGetRequestProgress",
6504            );
6505            let mut req = request.into_request();
6506            req.extensions_mut()
6507                .insert(
6508                    GrpcMethod::new(
6509                        "nominal.compute.v1.ComputeService",
6510                        "BatchGetRequestProgress",
6511                    ),
6512                );
6513            self.inner.unary(req, path, codec).await
6514        }
6515        pub async fn list_quota_usage_intervals(
6516            &mut self,
6517            request: impl tonic::IntoRequest<super::ListQuotaUsageIntervalsRequest>,
6518        ) -> std::result::Result<
6519            tonic::Response<super::ListQuotaUsageIntervalsResponse>,
6520            tonic::Status,
6521        > {
6522            self.inner
6523                .ready()
6524                .await
6525                .map_err(|e| {
6526                    tonic::Status::unknown(
6527                        format!("Service was not ready: {}", e.into()),
6528                    )
6529                })?;
6530            let codec = tonic::codec::ProstCodec::default();
6531            let path = http::uri::PathAndQuery::from_static(
6532                "/nominal.compute.v1.ComputeService/ListQuotaUsageIntervals",
6533            );
6534            let mut req = request.into_request();
6535            req.extensions_mut()
6536                .insert(
6537                    GrpcMethod::new(
6538                        "nominal.compute.v1.ComputeService",
6539                        "ListQuotaUsageIntervals",
6540                    ),
6541                );
6542            self.inner.unary(req, path, codec).await
6543        }
6544    }
6545}
6546#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
6547#[repr(i32)]
6548pub enum ComputeModelConversionError {
6549    Unspecified = 0,
6550    UnsupportedExpression = 1,
6551    TimeComponentOutOfRange = 2,
6552    IntegerOperandOutOfRange = 3,
6553    ResultIntegerOutOfRange = 4,
6554    InvalidPageToken = 5,
6555}
6556impl ComputeModelConversionError {
6557    /// String value of the enum field names used in the ProtoBuf definition.
6558    ///
6559    /// The values are not transformed in any way and thus are considered stable
6560    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
6561    pub fn as_str_name(&self) -> &'static str {
6562        match self {
6563            Self::Unspecified => "COMPUTE_MODEL_CONVERSION_ERROR_UNSPECIFIED",
6564            Self::UnsupportedExpression => {
6565                "COMPUTE_MODEL_CONVERSION_ERROR_UNSUPPORTED_EXPRESSION"
6566            }
6567            Self::TimeComponentOutOfRange => {
6568                "COMPUTE_MODEL_CONVERSION_ERROR_TIME_COMPONENT_OUT_OF_RANGE"
6569            }
6570            Self::IntegerOperandOutOfRange => {
6571                "COMPUTE_MODEL_CONVERSION_ERROR_INTEGER_OPERAND_OUT_OF_RANGE"
6572            }
6573            Self::ResultIntegerOutOfRange => {
6574                "COMPUTE_MODEL_CONVERSION_ERROR_RESULT_INTEGER_OUT_OF_RANGE"
6575            }
6576            Self::InvalidPageToken => "COMPUTE_MODEL_CONVERSION_ERROR_INVALID_PAGE_TOKEN",
6577        }
6578    }
6579    /// Creates an enum from field names used in the ProtoBuf definition.
6580    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
6581        match value {
6582            "COMPUTE_MODEL_CONVERSION_ERROR_UNSPECIFIED" => Some(Self::Unspecified),
6583            "COMPUTE_MODEL_CONVERSION_ERROR_UNSUPPORTED_EXPRESSION" => {
6584                Some(Self::UnsupportedExpression)
6585            }
6586            "COMPUTE_MODEL_CONVERSION_ERROR_TIME_COMPONENT_OUT_OF_RANGE" => {
6587                Some(Self::TimeComponentOutOfRange)
6588            }
6589            "COMPUTE_MODEL_CONVERSION_ERROR_INTEGER_OPERAND_OUT_OF_RANGE" => {
6590                Some(Self::IntegerOperandOutOfRange)
6591            }
6592            "COMPUTE_MODEL_CONVERSION_ERROR_RESULT_INTEGER_OUT_OF_RANGE" => {
6593                Some(Self::ResultIntegerOutOfRange)
6594            }
6595            "COMPUTE_MODEL_CONVERSION_ERROR_INVALID_PAGE_TOKEN" => {
6596                Some(Self::InvalidPageToken)
6597            }
6598            _ => None,
6599        }
6600    }
6601}
nominal_api_proto/proto/nominal.compute.v1.rs

nominal_api_proto/proto/
nominal.compute.v1.rs
