megacommerce_proto/
shared.v1.rs

1// This file is @generated by prost-build.
2#[derive(serde::Serialize, serde::Deserialize)]
3#[derive(Clone, Copy, PartialEq, ::prost::Message)]
4pub struct PingRequest {}
5#[derive(serde::Serialize, serde::Deserialize)]
6#[derive(Clone, Copy, PartialEq, ::prost::Message)]
7pub struct PingResponse {}
8#[derive(serde::Serialize, serde::Deserialize)]
9#[derive(Clone, PartialEq, ::prost::Message)]
10pub struct SuccessResponseData {
11    #[prost(string, optional, tag = "1")]
12    pub message: ::core::option::Option<::prost::alloc::string::String>,
13    #[prost(map = "string, string", tag = "2")]
14    pub metadata: ::std::collections::HashMap<
15        ::prost::alloc::string::String,
16        ::prost::alloc::string::String,
17    >,
18}
19#[derive(serde::Serialize, serde::Deserialize)]
20#[derive(Clone, PartialEq, ::prost::Message)]
21pub struct StringMap {
22    #[prost(map = "string, string", tag = "1")]
23    pub values: ::std::collections::HashMap<
24        ::prost::alloc::string::String,
25        ::prost::alloc::string::String,
26    >,
27}
28#[derive(serde::Serialize, serde::Deserialize)]
29#[derive(Clone, PartialEq, ::prost::Message)]
30pub struct NestedStringMap {
31    #[prost(map = "string, message", tag = "1")]
32    pub data: ::std::collections::HashMap<::prost::alloc::string::String, StringMap>,
33}
34#[derive(serde::Serialize, serde::Deserialize)]
35#[derive(Clone, PartialEq, ::prost::Message)]
36pub struct StringArray {
37    #[prost(string, repeated, tag = "1")]
38    pub values: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
39}
40#[derive(serde::Serialize, serde::Deserialize)]
41#[derive(Clone, Copy, PartialEq, ::prost::Message)]
42pub struct OrderDirection {
43    #[prost(oneof = "order_direction::Order", tags = "1, 2")]
44    pub order: ::core::option::Option<order_direction::Order>,
45}
46/// Nested message and enum types in `OrderDirection`.
47pub mod order_direction {
48    #[derive(serde::Serialize, serde::Deserialize)]
49    #[derive(Clone, Copy, PartialEq, ::prost::Oneof)]
50    pub enum Order {
51        #[prost(bool, tag = "1")]
52        Asc(bool),
53        #[prost(bool, tag = "2")]
54        Desc(bool),
55    }
56}
57#[derive(serde::Serialize, serde::Deserialize)]
58#[derive(Clone, PartialEq, ::prost::Message)]
59pub struct IdName {
60    #[prost(string, tag = "1")]
61    pub id: ::prost::alloc::string::String,
62    #[prost(string, tag = "2")]
63    pub name: ::prost::alloc::string::String,
64}
65/// Custom Any message to avoid google.protobuf.Any issues
66#[derive(serde::Serialize, serde::Deserialize)]
67#[derive(Clone, PartialEq, ::prost::Message)]
68pub struct Any {
69    /// Identifies the type of the serialized message
70    #[prost(string, tag = "1")]
71    pub type_url: ::prost::alloc::string::String,
72    /// Serialized proto data
73    #[prost(bytes = "vec", tag = "2")]
74    pub value: ::prost::alloc::vec::Vec<u8>,
75}
76#[derive(serde::Serialize, serde::Deserialize)]
77#[derive(Clone, Copy, PartialEq, ::prost::Message)]
78pub struct Empty {}
79#[derive(serde::Serialize, serde::Deserialize)]
80#[derive(Clone, PartialEq, ::prost::Message)]
81pub struct AppError {
82    #[prost(string, tag = "1")]
83    pub id: ::prost::alloc::string::String,
84    /// displayed to the end user without debugging info
85    #[prost(string, tag = "2")]
86    pub message: ::prost::alloc::string::String,
87    /// Internal debug info
88    #[prost(string, tag = "3")]
89    pub detailed_error: ::prost::alloc::string::String,
90    /// For correlation
91    #[prost(string, tag = "4")]
92    pub request_id: ::prost::alloc::string::String,
93    /// grpc status code
94    #[prost(int32, tag = "5")]
95    pub status_code: i32,
96    /// Code path or func name
97    #[prost(string, tag = "6")]
98    pub r#where: ::prost::alloc::string::String,
99    /// If false, i18n may not apply
100    #[prost(bool, tag = "7")]
101    pub skip_translation: bool,
102    #[prost(message, optional, tag = "8")]
103    pub errors: ::core::option::Option<StringMap>,
104    #[prost(message, optional, tag = "9")]
105    pub errors_nested: ::core::option::Option<NestedStringMap>,
106}
107/// `Struct` represents a structured data value, consisting of fields
108/// which map to dynamically typed values. In some languages, `Struct`
109/// might be supported by a native representation. For example, in
110/// scripting languages like JS a struct is represented as an
111/// object. The details of that representation are described together
112/// with the proto support for the language.
113///
114/// The JSON representation for `Struct` is JSON object.
115#[derive(serde::Serialize, serde::Deserialize)]
116#[derive(Clone, PartialEq, ::prost::Message)]
117pub struct Struct {
118    /// Unordered map of dynamically typed values.
119    #[prost(map = "string, message", tag = "1")]
120    pub fields: ::std::collections::HashMap<::prost::alloc::string::String, Value>,
121}
122/// `Value` represents a dynamically typed value which can be either
123/// null, a number, a string, a boolean, a recursive struct value, or a
124/// list of values. A producer of value is expected to set one of these
125/// variants. Absence of any variant indicates an error.
126///
127/// The JSON representation for `Value` is JSON value.
128#[derive(serde::Serialize, serde::Deserialize)]
129#[derive(Clone, PartialEq, ::prost::Message)]
130pub struct Value {
131    /// The kind of value.
132    #[prost(oneof = "value::Kind", tags = "1, 2, 3, 4, 5, 6")]
133    pub kind: ::core::option::Option<value::Kind>,
134}
135/// Nested message and enum types in `Value`.
136pub mod value {
137    /// The kind of value.
138    #[derive(serde::Serialize, serde::Deserialize)]
139    #[derive(Clone, PartialEq, ::prost::Oneof)]
140    pub enum Kind {
141        /// Represents a null value.
142        #[prost(enumeration = "super::NullValue", tag = "1")]
143        NullValue(i32),
144        /// Represents a double value.
145        #[prost(double, tag = "2")]
146        NumberValue(f64),
147        /// Represents a string value.
148        #[prost(string, tag = "3")]
149        StringValue(::prost::alloc::string::String),
150        /// Represents a boolean value.
151        #[prost(bool, tag = "4")]
152        BoolValue(bool),
153        /// Represents a structured value.
154        #[prost(message, tag = "5")]
155        StructValue(super::Struct),
156        /// Represents a repeated `Value`.
157        #[prost(message, tag = "6")]
158        ListValue(super::ListValue),
159    }
160}
161/// `ListValue` is a wrapper around a repeated field of values.
162///
163/// The JSON representation for `ListValue` is JSON array.
164#[derive(serde::Serialize, serde::Deserialize)]
165#[derive(Clone, PartialEq, ::prost::Message)]
166pub struct ListValue {
167    /// Repeated field of dynamically typed values.
168    #[prost(message, repeated, tag = "1")]
169    pub values: ::prost::alloc::vec::Vec<Value>,
170}
171/// `NullValue` is a singleton enumeration to represent the null value for the
172/// `Value` type union.
173///
174/// The JSON representation for `NullValue` is JSON `null`.
175#[derive(serde::Serialize, serde::Deserialize)]
176#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
177#[repr(i32)]
178pub enum NullValue {
179    /// Null value.
180    NullValue = 0,
181}
182impl NullValue {
183    /// String value of the enum field names used in the ProtoBuf definition.
184    ///
185    /// The values are not transformed in any way and thus are considered stable
186    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
187    pub fn as_str_name(&self) -> &'static str {
188        match self {
189            Self::NullValue => "NULL_VALUE",
190        }
191    }
192    /// Creates an enum from field names used in the ProtoBuf definition.
193    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
194        match value {
195            "NULL_VALUE" => Some(Self::NullValue),
196            _ => None,
197        }
198    }
199}
200#[derive(serde::Serialize, serde::Deserialize)]
201#[derive(Clone, PartialEq, ::prost::Message)]
202pub struct Attachment {
203    #[prost(string, tag = "1")]
204    pub id: ::prost::alloc::string::String,
205    #[prost(string, tag = "2")]
206    pub filename: ::prost::alloc::string::String,
207    #[prost(string, tag = "3")]
208    pub file_type: ::prost::alloc::string::String,
209    #[prost(int64, tag = "4")]
210    pub file_size: i64,
211    #[prost(string, tag = "5")]
212    pub file_extension: ::prost::alloc::string::String,
213    #[prost(string, tag = "6")]
214    pub base64: ::prost::alloc::string::String,
215    #[prost(int32, tag = "7")]
216    pub exif_orientation: i32,
217    #[prost(message, optional, tag = "8")]
218    pub crop: ::core::option::Option<Crop>,
219    /// arbitrary JSON-like object
220    #[prost(message, optional, tag = "9")]
221    pub metadata: ::core::option::Option<Struct>,
222    /// usually set by the backend
223    #[prost(bytes = "vec", tag = "10")]
224    pub data: ::prost::alloc::vec::Vec<u8>,
225    /// usually set by the backend
226    #[prost(string, tag = "11")]
227    pub mime: ::prost::alloc::string::String,
228    #[prost(string, optional, tag = "12")]
229    pub checksum: ::core::option::Option<::prost::alloc::string::String>,
230    #[prost(string, optional, tag = "13")]
231    pub url: ::core::option::Option<::prost::alloc::string::String>,
232    #[prost(uint64, optional, tag = "14")]
233    pub duration_seconds: ::core::option::Option<u64>,
234    #[prost(string, optional, tag = "15")]
235    pub error: ::core::option::Option<::prost::alloc::string::String>,
236}
237#[derive(serde::Serialize, serde::Deserialize)]
238#[derive(Clone, PartialEq, ::prost::Message)]
239pub struct Attachments {
240    #[prost(message, repeated, tag = "1")]
241    pub attachments: ::prost::alloc::vec::Vec<Attachment>,
242}
243#[derive(serde::Serialize, serde::Deserialize)]
244#[derive(Clone, Copy, PartialEq, ::prost::Message)]
245pub struct Crop {
246    #[prost(float, tag = "1")]
247    pub x: f32,
248    #[prost(float, tag = "2")]
249    pub y: f32,
250    #[prost(float, tag = "3")]
251    pub width: f32,
252    #[prost(float, tag = "4")]
253    pub height: f32,
254    #[prost(float, tag = "5")]
255    pub aspect_ratio: f32,
256}
257/// A Timestamp represents a point in time independent of any time zone or local
258/// calendar, encoded as a count of seconds and fractions of seconds at
259/// nanosecond resolution. The count is relative to an epoch at UTC midnight on
260/// January 1, 1970, in the proleptic Gregorian calendar which extends the
261/// Gregorian calendar backwards to year one.
262///
263/// All minutes are 60 seconds long. Leap seconds are "smeared" so that no leap
264/// second table is needed for interpretation, using a
265/// [24-hour linear smear](<https://developers.google.com/time/smear>).
266///
267/// The range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By
268/// restricting to that range, we ensure that we can convert to and from
269/// [RFC 3339](<https://www.ietf.org/rfc/rfc3339.txt>) date strings.
270///
271/// # Examples
272///
273/// Example 1: Compute Timestamp from POSIX `time()`.
274///
275///      Timestamp timestamp;
276///      timestamp.set_seconds(time(NULL));
277///      timestamp.set_nanos(0);
278///
279/// Example 2: Compute Timestamp from POSIX `gettimeofday()`.
280///
281///      struct timeval tv;
282///      gettimeofday(&tv, NULL);
283///
284///      Timestamp timestamp;
285///      timestamp.set_seconds(tv.tv_sec);
286///      timestamp.set_nanos(tv.tv_usec * 1000);
287///
288/// Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`.
289///
290///      FILETIME ft;
291///      GetSystemTimeAsFileTime(&ft);
292///      UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime;
293///
294///      // A Windows tick is 100 nanoseconds. Windows epoch 1601-01-01T00:00:00Z
295///      // is 11644473600 seconds before Unix epoch 1970-01-01T00:00:00Z.
296///      Timestamp timestamp;
297///      timestamp.set_seconds((INT64) ((ticks / 10000000) - 11644473600LL));
298///      timestamp.set_nanos((INT32) ((ticks % 10000000) * 100));
299///
300/// Example 4: Compute Timestamp from Java `System.currentTimeMillis()`.
301///
302///      long millis = System.currentTimeMillis();
303///
304///      Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000)
305///          .setNanos((int) ((millis % 1000) * 1000000)).build();
306///
307/// Example 5: Compute Timestamp from Java `Instant.now()`.
308///
309///      Instant now = Instant.now();
310///
311///      Timestamp timestamp =
312///          Timestamp.newBuilder().setSeconds(now.getEpochSecond())
313///              .setNanos(now.getNano()).build();
314///
315/// Example 6: Compute Timestamp from current time in Python.
316///
317///      timestamp = Timestamp()
318///      timestamp.GetCurrentTime()
319///
320/// # JSON Mapping
321///
322/// In JSON format, the Timestamp type is encoded as a string in the
323/// [RFC 3339](<https://www.ietf.org/rfc/rfc3339.txt>) format. That is, the
324/// format is "{year}-{month}-{day}T{hour}:{min}:{sec}\[.{frac_sec}\]Z"
325/// where {year} is always expressed using four digits while {month}, {day},
326/// {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional
327/// seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution),
328/// are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone
329/// is required. A proto3 JSON serializer should always use UTC (as indicated by "Z")
330/// when printing the Timestamp type and a proto3 JSON parser should be
331/// able to accept both UTC and other timezones (as indicated by an offset).
332///
333/// For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past
334/// 01:30 UTC on January 15, 2017.
335///
336/// In JavaScript, one can convert a Date object to this format using the standard
337/// [toISOString()](<https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString>)
338/// method. In Python, a standard `datetime.datetime` object can be converted
339/// to this format using
340/// [`strftime`](<https://docs.python.org/2/library/time.html#time.strftime>) with
341/// the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use
342/// the Joda Time's [`ISODateTimeFormat.dateTime()`](
343/// <http://joda-time.sourceforge.net/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime(>)
344/// ) to obtain a formatter capable of generating timestamps in this format.
345///
346#[derive(serde::Serialize, serde::Deserialize)]
347#[derive(Clone, Copy, PartialEq, ::prost::Message)]
348pub struct Timestamp {
349    /// Represents seconds of UTC time since Unix epoch
350    /// 1970-01-01T00:00:00Z. Must be from 0001-01-01T00:00:00Z to
351    /// 9999-12-31T23:59:59Z inclusive.
352    #[prost(int64, tag = "1")]
353    pub seconds: i64,
354    /// Non-negative fractions of a second at nanosecond resolution. Negative
355    /// second values with fractions must still have non-negative nanos values
356    /// that count forward in time. Must be from 0 to 999,999,999 inclusive.
357    #[prost(int32, tag = "2")]
358    pub nanos: i32,
359}
360/// Validation message with a oneof for typed rules
361#[derive(serde::Serialize, serde::Deserialize)]
362#[derive(Clone, PartialEq, ::prost::Message)]
363pub struct ValidationField {
364    #[prost(oneof = "validation_field::Rule", tags = "1, 2, 3")]
365    pub rule: ::core::option::Option<validation_field::Rule>,
366}
367/// Nested message and enum types in `ValidationField`.
368pub mod validation_field {
369    #[derive(serde::Serialize, serde::Deserialize)]
370    #[derive(Clone, PartialEq, ::prost::Oneof)]
371    pub enum Rule {
372        #[prost(message, tag = "1")]
373        Numeric(super::ValidationFieldNumeric),
374        #[prost(message, tag = "2")]
375        Str(super::ValidationFieldString),
376        #[prost(message, tag = "3")]
377        Regex(super::ValidationFieldRegex),
378    }
379}
380/// Numeric rule (min/max, etc.)
381#[derive(serde::Serialize, serde::Deserialize)]
382#[derive(Clone, PartialEq, ::prost::Message)]
383pub struct ValidationFieldNumeric {
384    #[prost(message, repeated, tag = "1")]
385    pub rules: ::prost::alloc::vec::Vec<NumericRule>,
386}
387#[derive(serde::Serialize, serde::Deserialize)]
388#[derive(Clone, Copy, PartialEq, ::prost::Message)]
389pub struct NumericRule {
390    #[prost(enumeration = "NumericRuleType", tag = "1")]
391    pub r#type: i32,
392    /// numeric parameter (double to accept int/float)
393    #[prost(double, tag = "2")]
394    pub value: f64,
395}
396/// String rule (min/max length)
397#[derive(serde::Serialize, serde::Deserialize)]
398#[derive(Clone, PartialEq, ::prost::Message)]
399pub struct ValidationFieldString {
400    #[prost(message, repeated, tag = "1")]
401    pub rules: ::prost::alloc::vec::Vec<StringRule>,
402}
403#[derive(serde::Serialize, serde::Deserialize)]
404#[derive(Clone, Copy, PartialEq, ::prost::Message)]
405pub struct StringRule {
406    #[prost(enumeration = "StringRuleType", tag = "1")]
407    pub r#type: i32,
408    /// numeric parameter (double to accept int/float)
409    #[prost(double, tag = "2")]
410    pub value: f64,
411}
412/// Regex rule (pattern)
413#[derive(serde::Serialize, serde::Deserialize)]
414#[derive(Clone, PartialEq, ::prost::Message)]
415pub struct ValidationFieldRegex {
416    #[prost(string, tag = "1")]
417    pub pattern: ::prost::alloc::string::String,
418    #[prost(bool, tag = "2")]
419    pub case_sensitive: bool,
420}
421#[derive(serde::Serialize, serde::Deserialize)]
422#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
423#[repr(i32)]
424pub enum NumericRuleType {
425    Min = 0,
426    Max = 1,
427    /// greater than
428    Gt = 2,
429    /// less than
430    Lt = 3,
431}
432impl NumericRuleType {
433    /// String value of the enum field names used in the ProtoBuf definition.
434    ///
435    /// The values are not transformed in any way and thus are considered stable
436    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
437    pub fn as_str_name(&self) -> &'static str {
438        match self {
439            Self::Min => "NUMERIC_RULE_TYPE_MIN",
440            Self::Max => "NUMERIC_RULE_TYPE_MAX",
441            Self::Gt => "NUMERIC_RULE_TYPE_GT",
442            Self::Lt => "NUMERIC_RULE_TYPE_LT",
443        }
444    }
445    /// Creates an enum from field names used in the ProtoBuf definition.
446    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
447        match value {
448            "NUMERIC_RULE_TYPE_MIN" => Some(Self::Min),
449            "NUMERIC_RULE_TYPE_MAX" => Some(Self::Max),
450            "NUMERIC_RULE_TYPE_GT" => Some(Self::Gt),
451            "NUMERIC_RULE_TYPE_LT" => Some(Self::Lt),
452            _ => None,
453        }
454    }
455}
456#[derive(serde::Serialize, serde::Deserialize)]
457#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
458#[repr(i32)]
459pub enum StringRuleType {
460    Min = 0,
461    Max = 1,
462}
463impl StringRuleType {
464    /// String value of the enum field names used in the ProtoBuf definition.
465    ///
466    /// The values are not transformed in any way and thus are considered stable
467    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
468    pub fn as_str_name(&self) -> &'static str {
469        match self {
470            Self::Min => "STRING_RULE_TYPE_MIN",
471            Self::Max => "STRING_RULE_TYPE_MAX",
472        }
473    }
474    /// Creates an enum from field names used in the ProtoBuf definition.
475    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
476        match value {
477            "STRING_RULE_TYPE_MIN" => Some(Self::Min),
478            "STRING_RULE_TYPE_MAX" => Some(Self::Max),
479            _ => None,
480        }
481    }
482}
483/// Wrapper message for `double`.
484///
485/// The JSON representation for `DoubleValue` is JSON number.
486///
487/// Not recommended for use in new APIs, but still useful for legacy APIs and
488/// has no plan to be removed.
489#[derive(serde::Serialize, serde::Deserialize)]
490#[derive(Clone, Copy, PartialEq, ::prost::Message)]
491pub struct DoubleValue {
492    /// The double value.
493    #[prost(double, tag = "1")]
494    pub value: f64,
495}
496/// Wrapper message for `float`.
497///
498/// The JSON representation for `FloatValue` is JSON number.
499///
500/// Not recommended for use in new APIs, but still useful for legacy APIs and
501/// has no plan to be removed.
502#[derive(serde::Serialize, serde::Deserialize)]
503#[derive(Clone, Copy, PartialEq, ::prost::Message)]
504pub struct FloatValue {
505    /// The float value.
506    #[prost(float, tag = "1")]
507    pub value: f32,
508}
509/// Wrapper message for `int64`.
510///
511/// The JSON representation for `Int64Value` is JSON string.
512///
513/// Not recommended for use in new APIs, but still useful for legacy APIs and
514/// has no plan to be removed.
515#[derive(serde::Serialize, serde::Deserialize)]
516#[derive(Clone, Copy, PartialEq, ::prost::Message)]
517pub struct Int64Value {
518    /// The int64 value.
519    #[prost(int64, tag = "1")]
520    pub value: i64,
521}
522/// Wrapper message for `uint64`.
523///
524/// The JSON representation for `UInt64Value` is JSON string.
525///
526/// Not recommended for use in new APIs, but still useful for legacy APIs and
527/// has no plan to be removed.
528#[derive(serde::Serialize, serde::Deserialize)]
529#[derive(Clone, Copy, PartialEq, ::prost::Message)]
530pub struct UInt64Value {
531    /// The uint64 value.
532    #[prost(uint64, tag = "1")]
533    pub value: u64,
534}
535/// Wrapper message for `int32`.
536///
537/// The JSON representation for `Int32Value` is JSON number.
538///
539/// Not recommended for use in new APIs, but still useful for legacy APIs and
540/// has no plan to be removed.
541#[derive(serde::Serialize, serde::Deserialize)]
542#[derive(Clone, Copy, PartialEq, ::prost::Message)]
543pub struct Int32Value {
544    /// The int32 value.
545    #[prost(int32, tag = "1")]
546    pub value: i32,
547}
548/// Wrapper message for `uint32`.
549///
550/// The JSON representation for `UInt32Value` is JSON number.
551///
552/// Not recommended for use in new APIs, but still useful for legacy APIs and
553/// has no plan to be removed.
554#[derive(serde::Serialize, serde::Deserialize)]
555#[derive(Clone, Copy, PartialEq, ::prost::Message)]
556pub struct UInt32Value {
557    /// The uint32 value.
558    #[prost(uint32, tag = "1")]
559    pub value: u32,
560}
561/// Wrapper message for `bool`.
562///
563/// The JSON representation for `BoolValue` is JSON `true` and `false`.
564///
565/// Not recommended for use in new APIs, but still useful for legacy APIs and
566/// has no plan to be removed.
567#[derive(serde::Serialize, serde::Deserialize)]
568#[derive(Clone, Copy, PartialEq, ::prost::Message)]
569pub struct BoolValue {
570    /// The bool value.
571    #[prost(bool, tag = "1")]
572    pub value: bool,
573}
574/// Wrapper message for `string`.
575///
576/// The JSON representation for `StringValue` is JSON string.
577///
578/// Not recommended for use in new APIs, but still useful for legacy APIs and
579/// has no plan to be removed.
580#[derive(serde::Serialize, serde::Deserialize)]
581#[derive(Clone, PartialEq, ::prost::Message)]
582pub struct StringValue {
583    /// The string value.
584    #[prost(string, tag = "1")]
585    pub value: ::prost::alloc::string::String,
586}
587/// Wrapper message for `bytes`.
588///
589/// The JSON representation for `BytesValue` is JSON string.
590///
591/// Not recommended for use in new APIs, but still useful for legacy APIs and
592/// has no plan to be removed.
593#[derive(serde::Serialize, serde::Deserialize)]
594#[derive(Clone, PartialEq, ::prost::Message)]
595pub struct BytesValue {
596    /// The bytes value.
597    #[prost(bytes = "vec", tag = "1")]
598    pub value: ::prost::alloc::vec::Vec<u8>,
599}
megacommerce_proto/shared.v1.rs

megacommerce_proto/
shared.v1.rs
