Skip to main content

nominal_api_proto/proto/
nominal.types.rs

1// This file is @generated by prost-build.
2#[derive(Clone, Copy, PartialEq, ::prost::Message)]
3pub struct Empty {}
4#[derive(Clone, PartialEq, ::prost::Message)]
5pub struct ErrorResult {
6    #[prost(string, tag = "1")]
7    pub error_type: ::prost::alloc::string::String,
8    #[prost(string, tag = "2")]
9    pub message: ::prost::alloc::string::String,
10}
11#[derive(Clone, PartialEq, ::prost::Message)]
12pub struct Handle {
13    #[prost(oneof = "handle::Handle", tags = "1")]
14    pub handle: ::core::option::Option<handle::Handle>,
15}
16/// Nested message and enum types in `Handle`.
17pub mod handle {
18    #[derive(Clone, PartialEq, ::prost::Oneof)]
19    pub enum Handle {
20        #[prost(string, tag = "1")]
21        S3(::prost::alloc::string::String),
22    }
23}
24#[derive(Clone, Copy, PartialEq, ::prost::Message)]
25pub struct InProgressResult {}
26#[derive(Clone, PartialEq, ::prost::Message)]
27pub struct Property {
28    #[prost(string, tag = "1")]
29    pub name: ::prost::alloc::string::String,
30    #[prost(string, tag = "2")]
31    pub value: ::prost::alloc::string::String,
32}
33#[derive(Clone, PartialEq, ::prost::Message)]
34pub struct TypedPropertyValue {
35    #[prost(oneof = "typed_property_value::TypedPropertyValue", tags = "1, 2")]
36    pub typed_property_value: ::core::option::Option<
37        typed_property_value::TypedPropertyValue,
38    >,
39}
40/// Nested message and enum types in `TypedPropertyValue`.
41pub mod typed_property_value {
42    #[derive(Clone, PartialEq, ::prost::Oneof)]
43    pub enum TypedPropertyValue {
44        #[prost(string, tag = "1")]
45        StringValue(::prost::alloc::string::String),
46        #[prost(double, tag = "2")]
47        NumericValue(f64),
48    }
49}
50#[derive(Clone, PartialEq, ::prost::Message)]
51pub struct NumericPropertyPredicate {
52    #[prost(string, tag = "1")]
53    pub name: ::prost::alloc::string::String,
54    #[prost(double, tag = "2")]
55    pub value: f64,
56    #[prost(enumeration = "PropertyComparisonOperator", tag = "3")]
57    pub operator: i32,
58}
59#[derive(Clone, PartialEq, ::prost::Message)]
60pub struct LabelUpdateWrapper {
61    #[prost(string, repeated, tag = "1")]
62    pub labels: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
63}
64#[derive(Clone, PartialEq, ::prost::Message)]
65pub struct PropertyUpdateWrapper {
66    #[prost(map = "string, string", tag = "1")]
67    pub properties: ::std::collections::HashMap<
68        ::prost::alloc::string::String,
69        ::prost::alloc::string::String,
70    >,
71}
72#[derive(Clone, PartialEq, ::prost::Message)]
73pub struct TypedPropertyUpdateWrapper {
74    #[prost(map = "string, message", tag = "1")]
75    pub typed_properties: ::std::collections::HashMap<
76        ::prost::alloc::string::String,
77        TypedPropertyValue,
78    >,
79}
80#[derive(Clone, PartialEq, ::prost::Message)]
81pub struct RefNameAndType {
82    #[prost(string, tag = "1")]
83    pub name: ::prost::alloc::string::String,
84    #[prost(enumeration = "DataSourceType", tag = "2")]
85    pub r#type: i32,
86}
87#[derive(Clone, PartialEq, ::prost::Message)]
88pub struct SerializableError {
89    #[prost(string, tag = "1")]
90    pub name: ::prost::alloc::string::String,
91    #[prost(string, optional, tag = "2")]
92    pub message: ::core::option::Option<::prost::alloc::string::String>,
93    #[prost(string, tag = "3")]
94    pub error_instance_id: ::prost::alloc::string::String,
95    #[prost(int32, tag = "4")]
96    pub status_code: i32,
97    #[prost(map = "string, string", tag = "5")]
98    pub params: ::std::collections::HashMap<
99        ::prost::alloc::string::String,
100        ::prost::alloc::string::String,
101    >,
102}
103#[derive(Clone, Copy, PartialEq, ::prost::Message)]
104pub struct SuccessResult {}
105#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
106#[repr(i32)]
107pub enum ArchivedStatus {
108    Unspecified = 0,
109    NotArchived = 1,
110    Archived = 2,
111}
112impl ArchivedStatus {
113    /// String value of the enum field names used in the ProtoBuf definition.
114    ///
115    /// The values are not transformed in any way and thus are considered stable
116    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
117    pub fn as_str_name(&self) -> &'static str {
118        match self {
119            Self::Unspecified => "ARCHIVED_STATUS_UNSPECIFIED",
120            Self::NotArchived => "NOT_ARCHIVED",
121            Self::Archived => "ARCHIVED",
122        }
123    }
124    /// Creates an enum from field names used in the ProtoBuf definition.
125    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
126        match value {
127            "ARCHIVED_STATUS_UNSPECIFIED" => Some(Self::Unspecified),
128            "NOT_ARCHIVED" => Some(Self::NotArchived),
129            "ARCHIVED" => Some(Self::Archived),
130            _ => None,
131        }
132    }
133}
134#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
135#[repr(i32)]
136pub enum DataSourceType {
137    Unspecified = 0,
138    Dataset = 1,
139    Connection = 2,
140    Video = 3,
141    Spatial = 4,
142}
143impl DataSourceType {
144    /// String value of the enum field names used in the ProtoBuf definition.
145    ///
146    /// The values are not transformed in any way and thus are considered stable
147    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
148    pub fn as_str_name(&self) -> &'static str {
149        match self {
150            Self::Unspecified => "DATA_SOURCE_TYPE_UNSPECIFIED",
151            Self::Dataset => "DATASET",
152            Self::Connection => "CONNECTION",
153            Self::Video => "VIDEO",
154            Self::Spatial => "SPATIAL",
155        }
156    }
157    /// Creates an enum from field names used in the ProtoBuf definition.
158    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
159        match value {
160            "DATA_SOURCE_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
161            "DATASET" => Some(Self::Dataset),
162            "CONNECTION" => Some(Self::Connection),
163            "VIDEO" => Some(Self::Video),
164            "SPATIAL" => Some(Self::Spatial),
165            _ => None,
166        }
167    }
168}
169#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
170#[repr(i32)]
171pub enum Granularity {
172    Unspecified = 0,
173    Nanoseconds = 2,
174}
175impl Granularity {
176    /// String value of the enum field names used in the ProtoBuf definition.
177    ///
178    /// The values are not transformed in any way and thus are considered stable
179    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
180    pub fn as_str_name(&self) -> &'static str {
181        match self {
182            Self::Unspecified => "GRANULARITY_UNSPECIFIED",
183            Self::Nanoseconds => "NANOSECONDS",
184        }
185    }
186    /// Creates an enum from field names used in the ProtoBuf definition.
187    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
188        match value {
189            "GRANULARITY_UNSPECIFIED" => Some(Self::Unspecified),
190            "NANOSECONDS" => Some(Self::Nanoseconds),
191            _ => None,
192        }
193    }
194}
195#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
196#[repr(i32)]
197pub enum IngestStatus {
198    Unspecified = 0,
199    Succeeded = 1,
200    Failed = 2,
201    InProgress = 3,
202    DeletionInProgress = 4,
203    Deleted = 5,
204}
205impl IngestStatus {
206    /// String value of the enum field names used in the ProtoBuf definition.
207    ///
208    /// The values are not transformed in any way and thus are considered stable
209    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
210    pub fn as_str_name(&self) -> &'static str {
211        match self {
212            Self::Unspecified => "INGEST_STATUS_UNSPECIFIED",
213            Self::Succeeded => "SUCCEEDED",
214            Self::Failed => "FAILED",
215            Self::InProgress => "IN_PROGRESS",
216            Self::DeletionInProgress => "DELETION_IN_PROGRESS",
217            Self::Deleted => "DELETED",
218        }
219    }
220    /// Creates an enum from field names used in the ProtoBuf definition.
221    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
222        match value {
223            "INGEST_STATUS_UNSPECIFIED" => Some(Self::Unspecified),
224            "SUCCEEDED" => Some(Self::Succeeded),
225            "FAILED" => Some(Self::Failed),
226            "IN_PROGRESS" => Some(Self::InProgress),
227            "DELETION_IN_PROGRESS" => Some(Self::DeletionInProgress),
228            "DELETED" => Some(Self::Deleted),
229            _ => None,
230        }
231    }
232}
233#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
234#[repr(i32)]
235pub enum PropertyComparisonOperator {
236    Unspecified = 0,
237    Eq = 1,
238    Neq = 2,
239    Gt = 3,
240    Geq = 4,
241    Lt = 5,
242    Leq = 6,
243}
244impl PropertyComparisonOperator {
245    /// String value of the enum field names used in the ProtoBuf definition.
246    ///
247    /// The values are not transformed in any way and thus are considered stable
248    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
249    pub fn as_str_name(&self) -> &'static str {
250        match self {
251            Self::Unspecified => "PROPERTY_COMPARISON_OPERATOR_UNSPECIFIED",
252            Self::Eq => "EQ",
253            Self::Neq => "NEQ",
254            Self::Gt => "GT",
255            Self::Geq => "GEQ",
256            Self::Lt => "LT",
257            Self::Leq => "LEQ",
258        }
259    }
260    /// Creates an enum from field names used in the ProtoBuf definition.
261    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
262        match value {
263            "PROPERTY_COMPARISON_OPERATOR_UNSPECIFIED" => Some(Self::Unspecified),
264            "EQ" => Some(Self::Eq),
265            "NEQ" => Some(Self::Neq),
266            "GT" => Some(Self::Gt),
267            "GEQ" => Some(Self::Geq),
268            "LT" => Some(Self::Lt),
269            "LEQ" => Some(Self::Leq),
270            _ => None,
271        }
272    }
273}
274#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
275#[repr(i32)]
276pub enum NominalDataType {
277    Unspecified = 0,
278    Double = 1,
279    String = 2,
280    Log = 3,
281    Int64 = 4,
282}
283impl NominalDataType {
284    /// String value of the enum field names used in the ProtoBuf definition.
285    ///
286    /// The values are not transformed in any way and thus are considered stable
287    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
288    pub fn as_str_name(&self) -> &'static str {
289        match self {
290            Self::Unspecified => "NOMINAL_DATA_TYPE_UNSPECIFIED",
291            Self::Double => "DOUBLE",
292            Self::String => "STRING",
293            Self::Log => "LOG",
294            Self::Int64 => "INT64",
295        }
296    }
297    /// Creates an enum from field names used in the ProtoBuf definition.
298    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
299        match value {
300            "NOMINAL_DATA_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
301            "DOUBLE" => Some(Self::Double),
302            "STRING" => Some(Self::String),
303            "LOG" => Some(Self::Log),
304            "INT64" => Some(Self::Int64),
305            _ => None,
306        }
307    }
308}
309#[derive(Clone, Copy, PartialEq, ::prost::Message)]
310pub struct Duration {
311    #[prost(int64, tag = "1")]
312    pub seconds: i64,
313    #[prost(int64, tag = "2")]
314    pub nanos: i64,
315}
316#[derive(Clone, PartialEq, ::prost::Message)]
317pub struct PropertiesFilter {
318    #[prost(string, tag = "1")]
319    pub name: ::prost::alloc::string::String,
320    #[prost(string, repeated, tag = "2")]
321    pub values: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
322}
323#[derive(Clone, PartialEq, ::prost::Message)]
324pub struct LabelsFilter {
325    #[prost(enumeration = "SetOperator", tag = "1")]
326    pub operator: i32,
327    #[prost(string, repeated, tag = "2")]
328    pub labels: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
329}
330#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
331#[repr(i32)]
332pub enum Priority {
333    Unspecified = 0,
334    P0 = 1,
335    P1 = 2,
336    P2 = 3,
337    P3 = 4,
338    P4 = 5,
339}
340impl Priority {
341    /// String value of the enum field names used in the ProtoBuf definition.
342    ///
343    /// The values are not transformed in any way and thus are considered stable
344    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
345    pub fn as_str_name(&self) -> &'static str {
346        match self {
347            Self::Unspecified => "PRIORITY_UNSPECIFIED",
348            Self::P0 => "P0",
349            Self::P1 => "P1",
350            Self::P2 => "P2",
351            Self::P3 => "P3",
352            Self::P4 => "P4",
353        }
354    }
355    /// Creates an enum from field names used in the ProtoBuf definition.
356    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
357        match value {
358            "PRIORITY_UNSPECIFIED" => Some(Self::Unspecified),
359            "P0" => Some(Self::P0),
360            "P1" => Some(Self::P1),
361            "P2" => Some(Self::P2),
362            "P3" => Some(Self::P3),
363            "P4" => Some(Self::P4),
364            _ => None,
365        }
366    }
367}
368#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
369#[repr(i32)]
370pub enum SetOperator {
371    Unspecified = 0,
372    And = 1,
373    Or = 2,
374}
375impl SetOperator {
376    /// String value of the enum field names used in the ProtoBuf definition.
377    ///
378    /// The values are not transformed in any way and thus are considered stable
379    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
380    pub fn as_str_name(&self) -> &'static str {
381        match self {
382            Self::Unspecified => "SET_OPERATOR_UNSPECIFIED",
383            Self::And => "AND",
384            Self::Or => "OR",
385        }
386    }
387    /// Creates an enum from field names used in the ProtoBuf definition.
388    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
389        match value {
390            "SET_OPERATOR_UNSPECIFIED" => Some(Self::Unspecified),
391            "AND" => Some(Self::And),
392            "OR" => Some(Self::Or),
393            _ => None,
394        }
395    }
396}