cx_api/generated/
com.coralogixapis.dashboards.v1.common.rs

1// This file is @generated by prost-build.
2#[derive(serde::Serialize, serde::Deserialize)]
3#[serde(rename_all = "snake_case")]
4#[derive(Clone, PartialEq, ::prost::Message)]
5pub struct DashboardFolder {
6    /// Folder unique identifier
7    #[prost(message, optional, tag = "1")]
8    pub id: ::core::option::Option<::prost::alloc::string::String>,
9    /// Folder name
10    #[prost(message, optional, tag = "2")]
11    pub name: ::core::option::Option<::prost::alloc::string::String>,
12    #[prost(message, optional, tag = "3")]
13    pub parent_id: ::core::option::Option<::prost::alloc::string::String>,
14}
15#[derive(serde::Serialize, serde::Deserialize)]
16#[serde(rename_all = "snake_case")]
17#[derive(Clone, PartialEq, ::prost::Message)]
18pub struct ObservationField {
19    #[prost(message, repeated, tag = "1")]
20    pub keypath: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
21    #[prost(enumeration = "DatasetScope", tag = "2")]
22    pub scope: i32,
23}
24#[derive(serde::Serialize, serde::Deserialize)]
25#[serde(rename_all = "snake_case")]
26#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
27#[repr(i32)]
28pub enum DatasetScope {
29    Unspecified = 0,
30    UserData = 1,
31    Label = 2,
32    Metadata = 3,
33}
34impl DatasetScope {
35    /// String value of the enum field names used in the ProtoBuf definition.
36    ///
37    /// The values are not transformed in any way and thus are considered stable
38    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
39    pub fn as_str_name(&self) -> &'static str {
40        match self {
41            Self::Unspecified => "DATASET_SCOPE_UNSPECIFIED",
42            Self::UserData => "DATASET_SCOPE_USER_DATA",
43            Self::Label => "DATASET_SCOPE_LABEL",
44            Self::Metadata => "DATASET_SCOPE_METADATA",
45        }
46    }
47    /// Creates an enum from field names used in the ProtoBuf definition.
48    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
49        match value {
50            "DATASET_SCOPE_UNSPECIFIED" => Some(Self::Unspecified),
51            "DATASET_SCOPE_USER_DATA" => Some(Self::UserData),
52            "DATASET_SCOPE_LABEL" => Some(Self::Label),
53            "DATASET_SCOPE_METADATA" => Some(Self::Metadata),
54            _ => None,
55        }
56    }
57}
58#[derive(serde::Serialize, serde::Deserialize)]
59#[serde(rename_all = "snake_case")]
60#[derive(Clone, PartialEq, ::prost::Message)]
61pub struct DataprimeQuery {
62    #[prost(string, tag = "1")]
63    pub text: ::prost::alloc::string::String,
64}
65#[derive(serde::Serialize, serde::Deserialize)]
66#[serde(rename_all = "snake_case")]
67#[derive(Clone, PartialEq, ::prost::Message)]
68pub struct SerializedDataprimeQuery {
69    #[prost(bytes = "vec", tag = "1")]
70    pub data: ::prost::alloc::vec::Vec<u8>,
71}
72#[derive(serde::Serialize, serde::Deserialize)]
73#[serde(rename_all = "snake_case")]
74#[derive(Clone, PartialEq, ::prost::Message)]
75pub struct FullDataprimeQuery {
76    #[prost(message, optional, tag = "1")]
77    pub serialized: ::core::option::Option<SerializedDataprimeQuery>,
78    #[prost(message, optional, tag = "2")]
79    pub raw: ::core::option::Option<DataprimeQuery>,
80}
81#[derive(serde::Serialize, serde::Deserialize)]
82#[serde(rename_all = "snake_case")]
83#[derive(Clone, PartialEq, ::prost::Message)]
84pub struct PromQlQuery {
85    #[prost(message, optional, tag = "1")]
86    pub value: ::core::option::Option<::prost::alloc::string::String>,
87}
88#[derive(serde::Serialize, serde::Deserialize)]
89#[serde(rename_all = "snake_case")]
90#[derive(Clone, PartialEq, ::prost::Message)]
91pub struct LuceneQuery {
92    #[prost(message, optional, tag = "1")]
93    pub value: ::core::option::Option<::prost::alloc::string::String>,
94}
95#[derive(serde::Serialize, serde::Deserialize)]
96#[serde(rename_all = "snake_case")]
97#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
98#[repr(i32)]
99pub enum PromQlQueryType {
100    Unspecified = 0,
101    Range = 1,
102    Instant = 2,
103}
104impl PromQlQueryType {
105    /// String value of the enum field names used in the ProtoBuf definition.
106    ///
107    /// The values are not transformed in any way and thus are considered stable
108    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
109    pub fn as_str_name(&self) -> &'static str {
110        match self {
111            Self::Unspecified => "PROM_QL_QUERY_TYPE_UNSPECIFIED",
112            Self::Range => "PROM_QL_QUERY_TYPE_RANGE",
113            Self::Instant => "PROM_QL_QUERY_TYPE_INSTANT",
114        }
115    }
116    /// Creates an enum from field names used in the ProtoBuf definition.
117    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
118        match value {
119            "PROM_QL_QUERY_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
120            "PROM_QL_QUERY_TYPE_RANGE" => Some(Self::Range),
121            "PROM_QL_QUERY_TYPE_INSTANT" => Some(Self::Instant),
122            _ => None,
123        }
124    }
125}
126#[derive(serde::Serialize, serde::Deserialize)]
127#[serde(rename_all = "snake_case")]
128#[derive(Clone, PartialEq, ::prost::Message)]
129pub struct SpanField {
130    #[prost(oneof = "span_field::Value", tags = "1, 2, 3")]
131    pub value: ::core::option::Option<span_field::Value>,
132}
133/// Nested message and enum types in `SpanField`.
134pub mod span_field {
135    #[derive(serde::Serialize, serde::Deserialize)]
136    #[serde(rename_all = "snake_case")]
137    #[derive(
138        Clone,
139        Copy,
140        Debug,
141        PartialEq,
142        Eq,
143        Hash,
144        PartialOrd,
145        Ord,
146        ::prost::Enumeration
147    )]
148    #[repr(i32)]
149    pub enum MetadataField {
150        Unspecified = 0,
151        ApplicationName = 1,
152        SubsystemName = 2,
153        ServiceName = 3,
154        OperationName = 4,
155    }
156    impl MetadataField {
157        /// String value of the enum field names used in the ProtoBuf definition.
158        ///
159        /// The values are not transformed in any way and thus are considered stable
160        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
161        pub fn as_str_name(&self) -> &'static str {
162            match self {
163                Self::Unspecified => "METADATA_FIELD_UNSPECIFIED",
164                Self::ApplicationName => "METADATA_FIELD_APPLICATION_NAME",
165                Self::SubsystemName => "METADATA_FIELD_SUBSYSTEM_NAME",
166                Self::ServiceName => "METADATA_FIELD_SERVICE_NAME",
167                Self::OperationName => "METADATA_FIELD_OPERATION_NAME",
168            }
169        }
170        /// Creates an enum from field names used in the ProtoBuf definition.
171        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
172            match value {
173                "METADATA_FIELD_UNSPECIFIED" => Some(Self::Unspecified),
174                "METADATA_FIELD_APPLICATION_NAME" => Some(Self::ApplicationName),
175                "METADATA_FIELD_SUBSYSTEM_NAME" => Some(Self::SubsystemName),
176                "METADATA_FIELD_SERVICE_NAME" => Some(Self::ServiceName),
177                "METADATA_FIELD_OPERATION_NAME" => Some(Self::OperationName),
178                _ => None,
179            }
180        }
181    }
182    #[derive(serde::Serialize, serde::Deserialize)]
183    #[serde(rename_all = "snake_case")]
184    #[derive(Clone, PartialEq, ::prost::Oneof)]
185    pub enum Value {
186        #[prost(enumeration = "MetadataField", tag = "1")]
187        MetadataField(i32),
188        #[prost(message, tag = "2")]
189        TagField(::prost::alloc::string::String),
190        #[prost(message, tag = "3")]
191        ProcessTagField(::prost::alloc::string::String),
192    }
193}
194#[derive(serde::Serialize, serde::Deserialize)]
195#[serde(rename_all = "snake_case")]
196#[derive(Clone, PartialEq, ::prost::Message)]
197pub struct LogsAggregation {
198    #[prost(oneof = "logs_aggregation::Value", tags = "1, 2, 3, 4, 5, 6, 7")]
199    pub value: ::core::option::Option<logs_aggregation::Value>,
200}
201/// Nested message and enum types in `LogsAggregation`.
202pub mod logs_aggregation {
203    #[derive(serde::Serialize, serde::Deserialize)]
204    #[serde(rename_all = "snake_case")]
205    #[derive(Clone, Copy, PartialEq, ::prost::Message)]
206    pub struct Count {}
207    #[derive(serde::Serialize, serde::Deserialize)]
208    #[serde(rename_all = "snake_case")]
209    #[derive(Clone, PartialEq, ::prost::Message)]
210    pub struct CountDistinct {
211        #[prost(message, optional, tag = "1")]
212        pub field: ::core::option::Option<::prost::alloc::string::String>,
213        #[prost(message, optional, tag = "2")]
214        pub observation_field: ::core::option::Option<super::ObservationField>,
215    }
216    #[derive(serde::Serialize, serde::Deserialize)]
217    #[serde(rename_all = "snake_case")]
218    #[derive(Clone, PartialEq, ::prost::Message)]
219    pub struct Sum {
220        #[prost(message, optional, tag = "1")]
221        pub field: ::core::option::Option<::prost::alloc::string::String>,
222        #[prost(message, optional, tag = "2")]
223        pub observation_field: ::core::option::Option<super::ObservationField>,
224    }
225    #[derive(serde::Serialize, serde::Deserialize)]
226    #[serde(rename_all = "snake_case")]
227    #[derive(Clone, PartialEq, ::prost::Message)]
228    pub struct Average {
229        #[prost(message, optional, tag = "1")]
230        pub field: ::core::option::Option<::prost::alloc::string::String>,
231        #[prost(message, optional, tag = "2")]
232        pub observation_field: ::core::option::Option<super::ObservationField>,
233    }
234    #[derive(serde::Serialize, serde::Deserialize)]
235    #[serde(rename_all = "snake_case")]
236    #[derive(Clone, PartialEq, ::prost::Message)]
237    pub struct Min {
238        #[prost(message, optional, tag = "1")]
239        pub field: ::core::option::Option<::prost::alloc::string::String>,
240        #[prost(message, optional, tag = "2")]
241        pub observation_field: ::core::option::Option<super::ObservationField>,
242    }
243    #[derive(serde::Serialize, serde::Deserialize)]
244    #[serde(rename_all = "snake_case")]
245    #[derive(Clone, PartialEq, ::prost::Message)]
246    pub struct Max {
247        #[prost(message, optional, tag = "1")]
248        pub field: ::core::option::Option<::prost::alloc::string::String>,
249        #[prost(message, optional, tag = "2")]
250        pub observation_field: ::core::option::Option<super::ObservationField>,
251    }
252    #[derive(serde::Serialize, serde::Deserialize)]
253    #[serde(rename_all = "snake_case")]
254    #[derive(Clone, PartialEq, ::prost::Message)]
255    pub struct Percentile {
256        #[prost(message, optional, tag = "1")]
257        pub field: ::core::option::Option<::prost::alloc::string::String>,
258        /// A value in range (0, 100]
259        #[prost(message, optional, tag = "2")]
260        pub percent: ::core::option::Option<f64>,
261        #[prost(message, optional, tag = "3")]
262        pub observation_field: ::core::option::Option<super::ObservationField>,
263    }
264    #[derive(serde::Serialize, serde::Deserialize)]
265    #[serde(rename_all = "snake_case")]
266    #[derive(Clone, PartialEq, ::prost::Oneof)]
267    pub enum Value {
268        #[prost(message, tag = "1")]
269        Count(Count),
270        #[prost(message, tag = "2")]
271        CountDistinct(CountDistinct),
272        #[prost(message, tag = "3")]
273        Sum(Sum),
274        #[prost(message, tag = "4")]
275        Average(Average),
276        #[prost(message, tag = "5")]
277        Min(Min),
278        #[prost(message, tag = "6")]
279        Max(Max),
280        #[prost(message, tag = "7")]
281        Percentile(Percentile),
282    }
283}
284#[derive(serde::Serialize, serde::Deserialize)]
285#[serde(rename_all = "snake_case")]
286#[derive(Clone, Copy, PartialEq, ::prost::Message)]
287pub struct SpansAggregation {
288    #[prost(oneof = "spans_aggregation::Aggregation", tags = "1, 2")]
289    pub aggregation: ::core::option::Option<spans_aggregation::Aggregation>,
290}
291/// Nested message and enum types in `SpansAggregation`.
292pub mod spans_aggregation {
293    #[derive(serde::Serialize, serde::Deserialize)]
294    #[serde(rename_all = "snake_case")]
295    #[derive(Clone, Copy, PartialEq, ::prost::Message)]
296    pub struct MetricAggregation {
297        #[prost(enumeration = "metric_aggregation::MetricField", tag = "1")]
298        pub metric_field: i32,
299        #[prost(enumeration = "metric_aggregation::MetricAggregationType", tag = "2")]
300        pub aggregation_type: i32,
301    }
302    /// Nested message and enum types in `MetricAggregation`.
303    pub mod metric_aggregation {
304        #[derive(serde::Serialize, serde::Deserialize)]
305        #[serde(rename_all = "snake_case")]
306        #[derive(
307            Clone,
308            Copy,
309            Debug,
310            PartialEq,
311            Eq,
312            Hash,
313            PartialOrd,
314            Ord,
315            ::prost::Enumeration
316        )]
317        #[repr(i32)]
318        pub enum MetricField {
319            Unspecified = 0,
320            Duration = 1,
321        }
322        impl MetricField {
323            /// String value of the enum field names used in the ProtoBuf definition.
324            ///
325            /// The values are not transformed in any way and thus are considered stable
326            /// (if the ProtoBuf definition does not change) and safe for programmatic use.
327            pub fn as_str_name(&self) -> &'static str {
328                match self {
329                    Self::Unspecified => "METRIC_FIELD_UNSPECIFIED",
330                    Self::Duration => "METRIC_FIELD_DURATION",
331                }
332            }
333            /// Creates an enum from field names used in the ProtoBuf definition.
334            pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
335                match value {
336                    "METRIC_FIELD_UNSPECIFIED" => Some(Self::Unspecified),
337                    "METRIC_FIELD_DURATION" => Some(Self::Duration),
338                    _ => None,
339                }
340            }
341        }
342        #[derive(serde::Serialize, serde::Deserialize)]
343        #[serde(rename_all = "snake_case")]
344        #[derive(
345            Clone,
346            Copy,
347            Debug,
348            PartialEq,
349            Eq,
350            Hash,
351            PartialOrd,
352            Ord,
353            ::prost::Enumeration
354        )]
355        #[repr(i32)]
356        pub enum MetricAggregationType {
357            Unspecified = 0,
358            Min = 1,
359            Max = 2,
360            Average = 3,
361            Sum = 4,
362            Percentile99 = 5,
363            Percentile95 = 6,
364            Percentile50 = 7,
365        }
366        impl MetricAggregationType {
367            /// String value of the enum field names used in the ProtoBuf definition.
368            ///
369            /// The values are not transformed in any way and thus are considered stable
370            /// (if the ProtoBuf definition does not change) and safe for programmatic use.
371            pub fn as_str_name(&self) -> &'static str {
372                match self {
373                    Self::Unspecified => "METRIC_AGGREGATION_TYPE_UNSPECIFIED",
374                    Self::Min => "METRIC_AGGREGATION_TYPE_MIN",
375                    Self::Max => "METRIC_AGGREGATION_TYPE_MAX",
376                    Self::Average => "METRIC_AGGREGATION_TYPE_AVERAGE",
377                    Self::Sum => "METRIC_AGGREGATION_TYPE_SUM",
378                    Self::Percentile99 => "METRIC_AGGREGATION_TYPE_PERCENTILE_99",
379                    Self::Percentile95 => "METRIC_AGGREGATION_TYPE_PERCENTILE_95",
380                    Self::Percentile50 => "METRIC_AGGREGATION_TYPE_PERCENTILE_50",
381                }
382            }
383            /// Creates an enum from field names used in the ProtoBuf definition.
384            pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
385                match value {
386                    "METRIC_AGGREGATION_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
387                    "METRIC_AGGREGATION_TYPE_MIN" => Some(Self::Min),
388                    "METRIC_AGGREGATION_TYPE_MAX" => Some(Self::Max),
389                    "METRIC_AGGREGATION_TYPE_AVERAGE" => Some(Self::Average),
390                    "METRIC_AGGREGATION_TYPE_SUM" => Some(Self::Sum),
391                    "METRIC_AGGREGATION_TYPE_PERCENTILE_99" => Some(Self::Percentile99),
392                    "METRIC_AGGREGATION_TYPE_PERCENTILE_95" => Some(Self::Percentile95),
393                    "METRIC_AGGREGATION_TYPE_PERCENTILE_50" => Some(Self::Percentile50),
394                    _ => None,
395                }
396            }
397        }
398    }
399    #[derive(serde::Serialize, serde::Deserialize)]
400    #[serde(rename_all = "snake_case")]
401    #[derive(Clone, Copy, PartialEq, ::prost::Message)]
402    pub struct DimensionAggregation {
403        #[prost(enumeration = "dimension_aggregation::DimensionField", tag = "1")]
404        pub dimension_field: i32,
405        #[prost(
406            enumeration = "dimension_aggregation::DimensionAggregationType",
407            tag = "2"
408        )]
409        pub aggregation_type: i32,
410    }
411    /// Nested message and enum types in `DimensionAggregation`.
412    pub mod dimension_aggregation {
413        #[derive(serde::Serialize, serde::Deserialize)]
414        #[serde(rename_all = "snake_case")]
415        #[derive(
416            Clone,
417            Copy,
418            Debug,
419            PartialEq,
420            Eq,
421            Hash,
422            PartialOrd,
423            Ord,
424            ::prost::Enumeration
425        )]
426        #[repr(i32)]
427        pub enum DimensionField {
428            Unspecified = 0,
429            TraceId = 1,
430        }
431        impl DimensionField {
432            /// String value of the enum field names used in the ProtoBuf definition.
433            ///
434            /// The values are not transformed in any way and thus are considered stable
435            /// (if the ProtoBuf definition does not change) and safe for programmatic use.
436            pub fn as_str_name(&self) -> &'static str {
437                match self {
438                    Self::Unspecified => "DIMENSION_FIELD_UNSPECIFIED",
439                    Self::TraceId => "DIMENSION_FIELD_TRACE_ID",
440                }
441            }
442            /// Creates an enum from field names used in the ProtoBuf definition.
443            pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
444                match value {
445                    "DIMENSION_FIELD_UNSPECIFIED" => Some(Self::Unspecified),
446                    "DIMENSION_FIELD_TRACE_ID" => Some(Self::TraceId),
447                    _ => None,
448                }
449            }
450        }
451        #[derive(serde::Serialize, serde::Deserialize)]
452        #[serde(rename_all = "snake_case")]
453        #[derive(
454            Clone,
455            Copy,
456            Debug,
457            PartialEq,
458            Eq,
459            Hash,
460            PartialOrd,
461            Ord,
462            ::prost::Enumeration
463        )]
464        #[repr(i32)]
465        pub enum DimensionAggregationType {
466            Unspecified = 0,
467            UniqueCount = 1,
468            ErrorCount = 2,
469        }
470        impl DimensionAggregationType {
471            /// String value of the enum field names used in the ProtoBuf definition.
472            ///
473            /// The values are not transformed in any way and thus are considered stable
474            /// (if the ProtoBuf definition does not change) and safe for programmatic use.
475            pub fn as_str_name(&self) -> &'static str {
476                match self {
477                    Self::Unspecified => "DIMENSION_AGGREGATION_TYPE_UNSPECIFIED",
478                    Self::UniqueCount => "DIMENSION_AGGREGATION_TYPE_UNIQUE_COUNT",
479                    Self::ErrorCount => "DIMENSION_AGGREGATION_TYPE_ERROR_COUNT",
480                }
481            }
482            /// Creates an enum from field names used in the ProtoBuf definition.
483            pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
484                match value {
485                    "DIMENSION_AGGREGATION_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
486                    "DIMENSION_AGGREGATION_TYPE_UNIQUE_COUNT" => Some(Self::UniqueCount),
487                    "DIMENSION_AGGREGATION_TYPE_ERROR_COUNT" => Some(Self::ErrorCount),
488                    _ => None,
489                }
490            }
491        }
492    }
493    #[derive(serde::Serialize, serde::Deserialize)]
494    #[serde(rename_all = "snake_case")]
495    #[derive(Clone, Copy, PartialEq, ::prost::Oneof)]
496    pub enum Aggregation {
497        #[prost(message, tag = "1")]
498        MetricAggregation(MetricAggregation),
499        #[prost(message, tag = "2")]
500        DimensionAggregation(DimensionAggregation),
501    }
502}
503#[derive(serde::Serialize, serde::Deserialize)]
504#[serde(rename_all = "snake_case")]
505#[derive(Clone, Copy, PartialEq, ::prost::Message)]
506pub struct TimeFrameSelect {
507    #[prost(oneof = "time_frame_select::Value", tags = "1, 2")]
508    pub value: ::core::option::Option<time_frame_select::Value>,
509}
510/// Nested message and enum types in `TimeFrameSelect`.
511pub mod time_frame_select {
512    #[derive(serde::Serialize, serde::Deserialize)]
513    #[serde(rename_all = "snake_case")]
514    #[derive(Clone, Copy, PartialEq, ::prost::Oneof)]
515    pub enum Value {
516        #[prost(message, tag = "1")]
517        AbsoluteTimeFrame(super::TimeFrame),
518        #[prost(message, tag = "2")]
519        RelativeTimeFrame(::prost_wkt_types::Duration),
520    }
521}
522#[derive(serde::Serialize, serde::Deserialize)]
523#[serde(rename_all = "snake_case")]
524#[derive(Clone, Copy, PartialEq, ::prost::Message)]
525pub struct TimeFrame {
526    #[prost(message, optional, tag = "1")]
527    pub from: ::core::option::Option<::prost_wkt_types::Timestamp>,
528    #[prost(message, optional, tag = "2")]
529    pub to: ::core::option::Option<::prost_wkt_types::Timestamp>,
530}
531#[derive(serde::Serialize, serde::Deserialize)]
532#[serde(rename_all = "snake_case")]
533#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
534#[repr(i32)]
535pub enum OrderDirection {
536    Unspecified = 0,
537    Asc = 1,
538    Desc = 2,
539}
540impl OrderDirection {
541    /// String value of the enum field names used in the ProtoBuf definition.
542    ///
543    /// The values are not transformed in any way and thus are considered stable
544    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
545    pub fn as_str_name(&self) -> &'static str {
546        match self {
547            Self::Unspecified => "ORDER_DIRECTION_UNSPECIFIED",
548            Self::Asc => "ORDER_DIRECTION_ASC",
549            Self::Desc => "ORDER_DIRECTION_DESC",
550        }
551    }
552    /// Creates an enum from field names used in the ProtoBuf definition.
553    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
554        match value {
555            "ORDER_DIRECTION_UNSPECIFIED" => Some(Self::Unspecified),
556            "ORDER_DIRECTION_ASC" => Some(Self::Asc),
557            "ORDER_DIRECTION_DESC" => Some(Self::Desc),
558            _ => None,
559        }
560    }
561}
562#[derive(serde::Serialize, serde::Deserialize)]
563#[serde(rename_all = "snake_case")]
564#[derive(Clone, PartialEq, ::prost::Message)]
565pub struct OrderingField {
566    #[prost(message, optional, tag = "1")]
567    pub field: ::core::option::Option<::prost::alloc::string::String>,
568    #[prost(enumeration = "OrderDirection", tag = "2")]
569    pub order_direction: i32,
570}