rithmic_rs/
rti.rs

1pub mod messages;
2
3/// PB_OFFSET = 100000 , is the offset added for each MNM field id
4#[allow(clippy::derive_partial_eq_without_eq)]
5#[derive(Clone, PartialEq, ::prost::Message)]
6pub struct MessageType {
7    /// PB_OFFSET + MNM_TEMPLATE_ID
8    #[prost(int32, required, tag = "154467")]
9    pub template_id: i32,
10}
11#[allow(clippy::derive_partial_eq_without_eq)]
12#[derive(Clone, PartialEq, ::prost::Message)]
13pub struct RequestLogin {
14    #[prost(int32, required, tag = "154467")]
15    pub template_id: i32,
16    #[prost(string, optional, tag = "153634")]
17    pub template_version: ::core::option::Option<::prost::alloc::string::String>,
18    #[prost(string, repeated, tag = "132760")]
19    pub user_msg: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
20    #[prost(string, optional, tag = "131003")]
21    pub user: ::core::option::Option<::prost::alloc::string::String>,
22    #[prost(string, optional, tag = "130004")]
23    pub password: ::core::option::Option<::prost::alloc::string::String>,
24    #[prost(string, optional, tag = "130002")]
25    pub app_name: ::core::option::Option<::prost::alloc::string::String>,
26    #[prost(string, optional, tag = "131803")]
27    pub app_version: ::core::option::Option<::prost::alloc::string::String>,
28    #[prost(string, optional, tag = "153628")]
29    pub system_name: ::core::option::Option<::prost::alloc::string::String>,
30    #[prost(enumeration = "request_login::SysInfraType", optional, tag = "153621")]
31    pub infra_type: ::core::option::Option<i32>,
32    #[prost(string, repeated, tag = "144108")]
33    pub mac_addr: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
34    #[prost(string, optional, tag = "144021")]
35    pub os_version: ::core::option::Option<::prost::alloc::string::String>,
36    #[prost(string, optional, tag = "144020")]
37    pub os_platform: ::core::option::Option<::prost::alloc::string::String>,
38    /// applicable only for TICKER_PLANT infra_type
39    #[prost(bool, optional, tag = "153644")]
40    pub aggregated_quotes: ::core::option::Option<bool>,
41}
42/// Nested message and enum types in `RequestLogin`.
43pub mod request_login {
44    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
45    #[repr(i32)]
46    pub enum SysInfraType {
47        TickerPlant = 1,
48        OrderPlant = 2,
49        HistoryPlant = 3,
50        PnlPlant = 4,
51        RepositoryPlant = 5,
52    }
53    impl SysInfraType {
54        /// String value of the enum field names used in the ProtoBuf definition.
55        ///
56        /// The values are not transformed in any way and thus are considered stable
57        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
58        pub fn as_str_name(&self) -> &'static str {
59            match self {
60                Self::TickerPlant => "TICKER_PLANT",
61                Self::OrderPlant => "ORDER_PLANT",
62                Self::HistoryPlant => "HISTORY_PLANT",
63                Self::PnlPlant => "PNL_PLANT",
64                Self::RepositoryPlant => "REPOSITORY_PLANT",
65            }
66        }
67        /// Creates an enum from field names used in the ProtoBuf definition.
68        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
69            match value {
70                "TICKER_PLANT" => Some(Self::TickerPlant),
71                "ORDER_PLANT" => Some(Self::OrderPlant),
72                "HISTORY_PLANT" => Some(Self::HistoryPlant),
73                "PNL_PLANT" => Some(Self::PnlPlant),
74                "REPOSITORY_PLANT" => Some(Self::RepositoryPlant),
75                _ => None,
76            }
77        }
78    }
79}
80#[derive(Clone, PartialEq, ::prost::Message)]
81pub struct ResponseLogin {
82    #[prost(int32, required, tag = "154467")]
83    pub template_id: i32,
84    #[prost(string, optional, tag = "153634")]
85    pub template_version: ::core::option::Option<::prost::alloc::string::String>,
86    #[prost(string, repeated, tag = "132760")]
87    pub user_msg: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
88    #[prost(string, repeated, tag = "132766")]
89    pub rp_code: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
90    #[prost(string, optional, tag = "154013")]
91    pub fcm_id: ::core::option::Option<::prost::alloc::string::String>,
92    #[prost(string, optional, tag = "154014")]
93    pub ib_id: ::core::option::Option<::prost::alloc::string::String>,
94    #[prost(string, optional, tag = "154712")]
95    pub country_code: ::core::option::Option<::prost::alloc::string::String>,
96    #[prost(string, optional, tag = "154713")]
97    pub state_code: ::core::option::Option<::prost::alloc::string::String>,
98    #[prost(string, optional, tag = "153428")]
99    pub unique_user_id: ::core::option::Option<::prost::alloc::string::String>,
100    #[prost(double, optional, tag = "153633")]
101    pub heartbeat_interval: ::core::option::Option<f64>,
102}
103/// PB_OFFSET = 100000 , is the offset added for each MNM field id
104#[derive(Clone, PartialEq, ::prost::Message)]
105pub struct RequestLogout {
106    /// PB_OFFSET + MNM_TEMPLATE_ID
107    #[prost(int32, required, tag = "154467")]
108    pub template_id: i32,
109    /// PB_OFFSET + MNM_USER_MSG
110    #[prost(string, repeated, tag = "132760")]
111    pub user_msg: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
112}
113/// PB_OFFSET = 100000 , is the offset added for each MNM field id
114#[derive(Clone, PartialEq, ::prost::Message)]
115pub struct ResponseLogout {
116    /// PB_OFFSET + MNM_TEMPLATE_ID
117    #[prost(int32, required, tag = "154467")]
118    pub template_id: i32,
119    /// PB_OFFSET + MNM_USER_MSG
120    #[prost(string, repeated, tag = "132760")]
121    pub user_msg: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
122    /// PB_OFFSET + MNM_RESPONSE_CODE
123    #[prost(string, repeated, tag = "132766")]
124    pub rp_code: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
125}
126#[derive(Clone, PartialEq, ::prost::Message)]
127pub struct RequestReferenceData {
128    #[prost(int32, required, tag = "154467")]
129    pub template_id: i32,
130    #[prost(string, repeated, tag = "132760")]
131    pub user_msg: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
132    #[prost(string, optional, tag = "110100")]
133    pub symbol: ::core::option::Option<::prost::alloc::string::String>,
134    #[prost(string, optional, tag = "110101")]
135    pub exchange: ::core::option::Option<::prost::alloc::string::String>,
136}
137/// presence bits defined here is also referred in response_get_instrument_by_underlying.proto and response_search_symbols.proto
138/// make sure both these proto files are always same.
139#[derive(Clone, PartialEq, ::prost::Message)]
140pub struct ResponseReferenceData {
141    #[prost(int32, required, tag = "154467")]
142    pub template_id: i32,
143    #[prost(string, repeated, tag = "132760")]
144    pub user_msg: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
145    #[prost(string, repeated, tag = "132766")]
146    pub rp_code: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
147    #[prost(uint32, optional, tag = "149138")]
148    pub presence_bits: ::core::option::Option<u32>,
149    #[prost(uint32, optional, tag = "154571")]
150    pub clear_bits: ::core::option::Option<u32>,
151    #[prost(string, optional, tag = "110100")]
152    pub symbol: ::core::option::Option<::prost::alloc::string::String>,
153    #[prost(string, optional, tag = "110101")]
154    pub exchange: ::core::option::Option<::prost::alloc::string::String>,
155    #[prost(string, optional, tag = "110114")]
156    pub exchange_symbol: ::core::option::Option<::prost::alloc::string::String>,
157    #[prost(string, optional, tag = "100003")]
158    pub symbol_name: ::core::option::Option<::prost::alloc::string::String>,
159    #[prost(string, optional, tag = "157095")]
160    pub trading_symbol: ::core::option::Option<::prost::alloc::string::String>,
161    #[prost(string, optional, tag = "157096")]
162    pub trading_exchange: ::core::option::Option<::prost::alloc::string::String>,
163    #[prost(string, optional, tag = "100749")]
164    pub product_code: ::core::option::Option<::prost::alloc::string::String>,
165    #[prost(string, optional, tag = "110116")]
166    pub instrument_type: ::core::option::Option<::prost::alloc::string::String>,
167    #[prost(string, optional, tag = "101026")]
168    pub underlying_symbol: ::core::option::Option<::prost::alloc::string::String>,
169    #[prost(string, optional, tag = "100067")]
170    pub expiration_date: ::core::option::Option<::prost::alloc::string::String>,
171    #[prost(string, optional, tag = "154382")]
172    pub currency: ::core::option::Option<::prost::alloc::string::String>,
173    #[prost(string, optional, tag = "100109")]
174    pub put_call_indicator: ::core::option::Option<::prost::alloc::string::String>,
175    #[prost(string, optional, tag = "154167")]
176    pub tick_size_type: ::core::option::Option<::prost::alloc::string::String>,
177    #[prost(string, optional, tag = "154390")]
178    pub price_display_format: ::core::option::Option<::prost::alloc::string::String>,
179    #[prost(string, optional, tag = "154844")]
180    pub is_tradable: ::core::option::Option<::prost::alloc::string::String>,
181    #[prost(string, optional, tag = "154952")]
182    pub is_underlying_for_binary_contrats: ::core::option::Option<::prost::alloc::string::String>,
183    #[prost(double, optional, tag = "100066")]
184    pub strike_price: ::core::option::Option<f64>,
185    #[prost(double, optional, tag = "154384")]
186    pub ftoq_price: ::core::option::Option<f64>,
187    #[prost(double, optional, tag = "154385")]
188    pub qtof_price: ::core::option::Option<f64>,
189    #[prost(double, optional, tag = "154386")]
190    pub min_qprice_change: ::core::option::Option<f64>,
191    #[prost(double, optional, tag = "154387")]
192    pub min_fprice_change: ::core::option::Option<f64>,
193    #[prost(double, optional, tag = "154389")]
194    pub single_point_value: ::core::option::Option<f64>,
195}
196/// Nested message and enum types in `ResponseReferenceData`.
197pub mod response_reference_data {
198    /// bit constants are defined using enum
199    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
200    #[repr(i32)]
201    pub enum PresenceBits {
202        ExchangeSymbol = 1,
203        SymbolName = 2,
204        ProductCode = 4,
205        InstrumentType = 8,
206        UnderlyingSymbol = 16,
207        ExpirationDate = 32,
208        Currency = 64,
209        PutCallIndicator = 128,
210        StrikePrice = 256,
211        FpriceToQprice = 512,
212        QpriceToFprice = 1024,
213        MinQpriceChange = 2048,
214        MinFrpiceChange = 4096,
215        SinglePointValue = 8192,
216        TickSizeType = 16384,
217        PriceDisplayFormat = 32768,
218        IsTradable = 65536,
219        TradingSymbol = 131072,
220        TradingExchange = 262144,
221        IsUnderlyingForBinaryContracts = 8388608,
222    }
223    impl PresenceBits {
224        /// String value of the enum field names used in the ProtoBuf definition.
225        ///
226        /// The values are not transformed in any way and thus are considered stable
227        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
228        pub fn as_str_name(&self) -> &'static str {
229            match self {
230                Self::ExchangeSymbol => "EXCHANGE_SYMBOL",
231                Self::SymbolName => "SYMBOL_NAME",
232                Self::ProductCode => "PRODUCT_CODE",
233                Self::InstrumentType => "INSTRUMENT_TYPE",
234                Self::UnderlyingSymbol => "UNDERLYING_SYMBOL",
235                Self::ExpirationDate => "EXPIRATION_DATE",
236                Self::Currency => "CURRENCY",
237                Self::PutCallIndicator => "PUT_CALL_INDICATOR",
238                Self::StrikePrice => "STRIKE_PRICE",
239                Self::FpriceToQprice => "FPRICE_TO_QPRICE",
240                Self::QpriceToFprice => "QPRICE_TO_FPRICE",
241                Self::MinQpriceChange => "MIN_QPRICE_CHANGE",
242                Self::MinFrpiceChange => "MIN_FRPICE_CHANGE",
243                Self::SinglePointValue => "SINGLE_POINT_VALUE",
244                Self::TickSizeType => "TICK_SIZE_TYPE",
245                Self::PriceDisplayFormat => "PRICE_DISPLAY_FORMAT",
246                Self::IsTradable => "IS_TRADABLE",
247                Self::TradingSymbol => "TRADING_SYMBOL",
248                Self::TradingExchange => "TRADING_EXCHANGE",
249                Self::IsUnderlyingForBinaryContracts => "IS_UNDERLYING_FOR_BINARY_CONTRACTS",
250            }
251        }
252        /// Creates an enum from field names used in the ProtoBuf definition.
253        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
254            match value {
255                "EXCHANGE_SYMBOL" => Some(Self::ExchangeSymbol),
256                "SYMBOL_NAME" => Some(Self::SymbolName),
257                "PRODUCT_CODE" => Some(Self::ProductCode),
258                "INSTRUMENT_TYPE" => Some(Self::InstrumentType),
259                "UNDERLYING_SYMBOL" => Some(Self::UnderlyingSymbol),
260                "EXPIRATION_DATE" => Some(Self::ExpirationDate),
261                "CURRENCY" => Some(Self::Currency),
262                "PUT_CALL_INDICATOR" => Some(Self::PutCallIndicator),
263                "STRIKE_PRICE" => Some(Self::StrikePrice),
264                "FPRICE_TO_QPRICE" => Some(Self::FpriceToQprice),
265                "QPRICE_TO_FPRICE" => Some(Self::QpriceToFprice),
266                "MIN_QPRICE_CHANGE" => Some(Self::MinQpriceChange),
267                "MIN_FRPICE_CHANGE" => Some(Self::MinFrpiceChange),
268                "SINGLE_POINT_VALUE" => Some(Self::SinglePointValue),
269                "TICK_SIZE_TYPE" => Some(Self::TickSizeType),
270                "PRICE_DISPLAY_FORMAT" => Some(Self::PriceDisplayFormat),
271                "IS_TRADABLE" => Some(Self::IsTradable),
272                "TRADING_SYMBOL" => Some(Self::TradingSymbol),
273                "TRADING_EXCHANGE" => Some(Self::TradingExchange),
274                "IS_UNDERLYING_FOR_BINARY_CONTRACTS" => Some(Self::IsUnderlyingForBinaryContracts),
275                _ => None,
276            }
277        }
278    }
279}
280#[derive(Clone, PartialEq, ::prost::Message)]
281pub struct RequestRithmicSystemInfo {
282    #[prost(int32, required, tag = "154467")]
283    pub template_id: i32,
284    #[prost(string, repeated, tag = "132760")]
285    pub user_msg: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
286}
287#[derive(Clone, PartialEq, ::prost::Message)]
288pub struct ResponseRithmicSystemInfo {
289    #[prost(int32, required, tag = "154467")]
290    pub template_id: i32,
291    #[prost(string, repeated, tag = "132760")]
292    pub user_msg: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
293    #[prost(string, repeated, tag = "132766")]
294    pub rp_code: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
295    #[prost(string, repeated, tag = "153628")]
296    pub system_name: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
297    #[prost(bool, repeated, packed = "false", tag = "153649")]
298    pub has_aggregated_quotes: ::prost::alloc::vec::Vec<bool>,
299}
300#[derive(Clone, PartialEq, ::prost::Message)]
301pub struct RequestRithmicSystemGatewayInfo {
302    #[prost(int32, required, tag = "154467")]
303    pub template_id: i32,
304    #[prost(string, repeated, tag = "132760")]
305    pub user_msg: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
306    #[prost(string, optional, tag = "153628")]
307    pub system_name: ::core::option::Option<::prost::alloc::string::String>,
308}
309#[derive(Clone, PartialEq, ::prost::Message)]
310pub struct ResponseRithmicSystemGatewayInfo {
311    #[prost(int32, required, tag = "154467")]
312    pub template_id: i32,
313    #[prost(string, repeated, tag = "132760")]
314    pub user_msg: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
315    #[prost(string, repeated, tag = "132766")]
316    pub rp_code: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
317    #[prost(string, optional, tag = "153628")]
318    pub system_name: ::core::option::Option<::prost::alloc::string::String>,
319    #[prost(string, repeated, tag = "153640")]
320    pub gateway_name: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
321    #[prost(string, repeated, tag = "153641")]
322    pub gateway_uri: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
323}
324/// PB_OFFSET = 100000, is the offset added for each MNM field id
325#[derive(Clone, PartialEq, ::prost::Message)]
326pub struct RequestHeartbeat {
327    /// PB_OFFSET + MNM_TEMPLATE_ID
328    #[prost(int32, required, tag = "154467")]
329    pub template_id: i32,
330    /// PB_OFFSET + MNM_USER_MSG
331    #[prost(string, repeated, tag = "132760")]
332    pub user_msg: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
333    /// PB_OFFSET + MNM_SECONDS_SINCE_BOE
334    #[prost(int32, optional, tag = "150100")]
335    pub ssboe: ::core::option::Option<i32>,
336    /// PB_OFFSET + MNM_USECS
337    #[prost(int32, optional, tag = "150101")]
338    pub usecs: ::core::option::Option<i32>,
339}
340/// PB_OFFSET = 100000, is the offset added for each MNM field id
341#[derive(Clone, PartialEq, ::prost::Message)]
342pub struct ResponseHeartbeat {
343    /// PB_OFFSET + MNM_TEMPLATE_ID
344    #[prost(int32, required, tag = "154467")]
345    pub template_id: i32,
346    /// PB_OFFSET + MNM_USER_MSG
347    #[prost(string, repeated, tag = "132760")]
348    pub user_msg: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
349    /// PB_OFFSET + MNM_RESPONSE_CODE
350    #[prost(string, repeated, tag = "132766")]
351    pub rp_code: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
352    /// PB_OFFSET + MNM_SECONDS_SINCE_BOE
353    #[prost(int32, optional, tag = "150100")]
354    pub ssboe: ::core::option::Option<i32>,
355    /// PB_OFFSET + MNM_USECS
356    #[prost(int32, optional, tag = "150101")]
357    pub usecs: ::core::option::Option<i32>,
358}
359/// PB_OFFSET = 100000 , is the offset added for each MNM field id
360#[derive(Clone, PartialEq, ::prost::Message)]
361pub struct Reject {
362    /// PB_OFFSET + MNM_TEMPLATE_ID
363    #[prost(int32, required, tag = "154467")]
364    pub template_id: i32,
365    /// PB_OFFSET + MNM_USER_MSG
366    #[prost(string, repeated, tag = "132760")]
367    pub user_msg: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
368    /// PB_OFFSET + MNM_RESPONSE_CODE
369    #[prost(string, repeated, tag = "132766")]
370    pub rp_code: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
371}
372/// PB_OFFSET = 100000 , is the offset added for each MNM field id
373#[derive(Clone, Copy, PartialEq, ::prost::Message)]
374pub struct ForcedLogout {
375    /// PB_OFFSET + MNM_TEMPLATE_ID
376    #[prost(int32, required, tag = "154467")]
377    pub template_id: i32,
378}
379#[derive(Clone, PartialEq, ::prost::Message)]
380pub struct UserAccountUpdate {
381    #[prost(int32, required, tag = "154467")]
382    pub template_id: i32,
383    #[prost(
384        enumeration = "user_account_update::UpdateType",
385        optional,
386        tag = "154288"
387    )]
388    pub update_type: ::core::option::Option<i32>,
389    #[prost(
390        enumeration = "user_account_update::AccessType",
391        optional,
392        tag = "154000"
393    )]
394    pub access_type: ::core::option::Option<i32>,
395    #[prost(string, optional, tag = "154247")]
396    pub source_user_id: ::core::option::Option<::prost::alloc::string::String>,
397    #[prost(string, optional, tag = "131003")]
398    pub user: ::core::option::Option<::prost::alloc::string::String>,
399    #[prost(string, optional, tag = "154013")]
400    pub fcm_id: ::core::option::Option<::prost::alloc::string::String>,
401    #[prost(string, optional, tag = "154014")]
402    pub ib_id: ::core::option::Option<::prost::alloc::string::String>,
403    #[prost(string, optional, tag = "154008")]
404    pub account_id: ::core::option::Option<::prost::alloc::string::String>,
405    #[prost(string, optional, tag = "154002")]
406    pub account_name: ::core::option::Option<::prost::alloc::string::String>,
407    #[prost(int32, optional, tag = "150100")]
408    pub ssboe: ::core::option::Option<i32>,
409    #[prost(int32, optional, tag = "150101")]
410    pub usecs: ::core::option::Option<i32>,
411}
412/// Nested message and enum types in `UserAccountUpdate`.
413pub mod user_account_update {
414    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
415    #[repr(i32)]
416    pub enum UpdateType {
417        Add = 1,
418        Remove = 2,
419    }
420    impl UpdateType {
421        /// String value of the enum field names used in the ProtoBuf definition.
422        ///
423        /// The values are not transformed in any way and thus are considered stable
424        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
425        pub fn as_str_name(&self) -> &'static str {
426            match self {
427                Self::Add => "ADD",
428                Self::Remove => "REMOVE",
429            }
430        }
431        /// Creates an enum from field names used in the ProtoBuf definition.
432        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
433            match value {
434                "ADD" => Some(Self::Add),
435                "REMOVE" => Some(Self::Remove),
436                _ => None,
437            }
438        }
439    }
440    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
441    #[repr(i32)]
442    pub enum AccessType {
443        ReadOnly = 0,
444        ReadWrite = 1,
445    }
446    impl AccessType {
447        /// String value of the enum field names used in the ProtoBuf definition.
448        ///
449        /// The values are not transformed in any way and thus are considered stable
450        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
451        pub fn as_str_name(&self) -> &'static str {
452            match self {
453                Self::ReadOnly => "READ_ONLY",
454                Self::ReadWrite => "READ_WRITE",
455            }
456        }
457        /// Creates an enum from field names used in the ProtoBuf definition.
458        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
459            match value {
460                "READ_ONLY" => Some(Self::ReadOnly),
461                "READ_WRITE" => Some(Self::ReadWrite),
462                _ => None,
463            }
464        }
465    }
466}
467/// update bits and Request enum defined here is also referred in request_subscribe_by_underlying.proto
468/// make sure both these proto files are always same.
469#[derive(Clone, PartialEq, ::prost::Message)]
470pub struct RequestMarketDataUpdate {
471    #[prost(int32, required, tag = "154467")]
472    pub template_id: i32,
473    #[prost(string, repeated, tag = "132760")]
474    pub user_msg: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
475    #[prost(string, optional, tag = "110100")]
476    pub symbol: ::core::option::Option<::prost::alloc::string::String>,
477    #[prost(string, optional, tag = "110101")]
478    pub exchange: ::core::option::Option<::prost::alloc::string::String>,
479    #[prost(
480        enumeration = "request_market_data_update::Request",
481        optional,
482        tag = "100000"
483    )]
484    pub request: ::core::option::Option<i32>,
485    #[prost(uint32, optional, tag = "154211")]
486    pub update_bits: ::core::option::Option<u32>,
487}
488/// Nested message and enum types in `RequestMarketDataUpdate`.
489pub mod request_market_data_update {
490    /// bit constants are defined using enum
491    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
492    #[repr(i32)]
493    pub enum UpdateBits {
494        LastTrade = 1,
495        Bbo = 2,
496        OrderBook = 4,
497        Open = 8,
498        OpeningIndicator = 16,
499        HighLow = 32,
500        HighBidLowAsk = 64,
501        Close = 128,
502        ClosingIndicator = 256,
503        Settlement = 512,
504        MarketMode = 1024,
505        OpenInterest = 2048,
506        MarginRate = 4096,
507        HighPriceLimit = 8192,
508        LowPriceLimit = 16384,
509        ProjectedSettlement = 32768,
510        AdjustedClose = 65536,
511    }
512    impl UpdateBits {
513        /// String value of the enum field names used in the ProtoBuf definition.
514        ///
515        /// The values are not transformed in any way and thus are considered stable
516        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
517        pub fn as_str_name(&self) -> &'static str {
518            match self {
519                Self::LastTrade => "LAST_TRADE",
520                Self::Bbo => "BBO",
521                Self::OrderBook => "ORDER_BOOK",
522                Self::Open => "OPEN",
523                Self::OpeningIndicator => "OPENING_INDICATOR",
524                Self::HighLow => "HIGH_LOW",
525                Self::HighBidLowAsk => "HIGH_BID_LOW_ASK",
526                Self::Close => "CLOSE",
527                Self::ClosingIndicator => "CLOSING_INDICATOR",
528                Self::Settlement => "SETTLEMENT",
529                Self::MarketMode => "MARKET_MODE",
530                Self::OpenInterest => "OPEN_INTEREST",
531                Self::MarginRate => "MARGIN_RATE",
532                Self::HighPriceLimit => "HIGH_PRICE_LIMIT",
533                Self::LowPriceLimit => "LOW_PRICE_LIMIT",
534                Self::ProjectedSettlement => "PROJECTED_SETTLEMENT",
535                Self::AdjustedClose => "ADJUSTED_CLOSE",
536            }
537        }
538        /// Creates an enum from field names used in the ProtoBuf definition.
539        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
540            match value {
541                "LAST_TRADE" => Some(Self::LastTrade),
542                "BBO" => Some(Self::Bbo),
543                "ORDER_BOOK" => Some(Self::OrderBook),
544                "OPEN" => Some(Self::Open),
545                "OPENING_INDICATOR" => Some(Self::OpeningIndicator),
546                "HIGH_LOW" => Some(Self::HighLow),
547                "HIGH_BID_LOW_ASK" => Some(Self::HighBidLowAsk),
548                "CLOSE" => Some(Self::Close),
549                "CLOSING_INDICATOR" => Some(Self::ClosingIndicator),
550                "SETTLEMENT" => Some(Self::Settlement),
551                "MARKET_MODE" => Some(Self::MarketMode),
552                "OPEN_INTEREST" => Some(Self::OpenInterest),
553                "MARGIN_RATE" => Some(Self::MarginRate),
554                "HIGH_PRICE_LIMIT" => Some(Self::HighPriceLimit),
555                "LOW_PRICE_LIMIT" => Some(Self::LowPriceLimit),
556                "PROJECTED_SETTLEMENT" => Some(Self::ProjectedSettlement),
557                "ADJUSTED_CLOSE" => Some(Self::AdjustedClose),
558                _ => None,
559            }
560        }
561    }
562    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
563    #[repr(i32)]
564    pub enum Request {
565        Subscribe = 1,
566        Unsubscribe = 2,
567    }
568    impl Request {
569        /// String value of the enum field names used in the ProtoBuf definition.
570        ///
571        /// The values are not transformed in any way and thus are considered stable
572        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
573        pub fn as_str_name(&self) -> &'static str {
574            match self {
575                Self::Subscribe => "SUBSCRIBE",
576                Self::Unsubscribe => "UNSUBSCRIBE",
577            }
578        }
579        /// Creates an enum from field names used in the ProtoBuf definition.
580        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
581            match value {
582                "SUBSCRIBE" => Some(Self::Subscribe),
583                "UNSUBSCRIBE" => Some(Self::Unsubscribe),
584                _ => None,
585            }
586        }
587    }
588}
589#[derive(Clone, PartialEq, ::prost::Message)]
590pub struct ResponseMarketDataUpdate {
591    #[prost(int32, required, tag = "154467")]
592    pub template_id: i32,
593    #[prost(string, repeated, tag = "132760")]
594    pub user_msg: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
595    #[prost(string, repeated, tag = "132766")]
596    pub rp_code: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
597}
598/// PB_OFFSET = 100000, is the offset added for each MNM field id
599#[derive(Clone, PartialEq, ::prost::Message)]
600pub struct RequestAuxilliaryReferenceData {
601    /// PB_OFFSET + MNM_TEMPLATE_ID
602    #[prost(int32, required, tag = "154467")]
603    pub template_id: i32,
604    /// PB_OFFSET + MNM_USER_MSG
605    #[prost(string, repeated, tag = "132760")]
606    pub user_msg: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
607    /// PB_OFFSET + MNM_SYMBOL
608    #[prost(string, optional, tag = "110100")]
609    pub symbol: ::core::option::Option<::prost::alloc::string::String>,
610    /// PB_OFFSET + MNM_EXCHANGE
611    #[prost(string, optional, tag = "110101")]
612    pub exchange: ::core::option::Option<::prost::alloc::string::String>,
613}
614/// presence bits defined here is also referred in response_get_instrument_by_underlying.proto and response_search_symbols.proto
615/// make sure both these proto files are always same.
616#[derive(Clone, PartialEq, ::prost::Message)]
617pub struct ResponseAuxilliaryReferenceData {
618    /// PB_OFFSET + MNM_TEMPLATE_ID
619    #[prost(int32, required, tag = "154467")]
620    pub template_id: i32,
621    /// PB_OFFSET + MNM_USER_MSG
622    #[prost(string, repeated, tag = "132760")]
623    pub user_msg: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
624    /// PB_OFFSET + MNM_RESPONSE_CODE
625    #[prost(string, repeated, tag = "132766")]
626    pub rp_code: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
627    /// PB_OFFSET + MNM_PRICING_INDICATOR
628    #[prost(uint32, optional, tag = "149138")]
629    pub presence_bits: ::core::option::Option<u32>,
630    /// PB_OFFSET + MNM_DISPLAY_INDICATOR
631    #[prost(uint32, optional, tag = "154571")]
632    pub clear_bits: ::core::option::Option<u32>,
633    /// PB_OFFSET + MNM_SYMBOL
634    #[prost(string, optional, tag = "110100")]
635    pub symbol: ::core::option::Option<::prost::alloc::string::String>,
636    /// PB_OFFSET + MNM_EXCHANGE
637    #[prost(string, optional, tag = "110101")]
638    pub exchange: ::core::option::Option<::prost::alloc::string::String>,
639    /// PB_OFFSET + MNM_SETTLEMENT_METHOD
640    #[prost(string, optional, tag = "153294")]
641    pub settlement_method: ::core::option::Option<::prost::alloc::string::String>,
642    /// PB_OFFSET + MNM_FIRST_NOTICE_DATE
643    #[prost(string, optional, tag = "154932")]
644    pub first_notice_date: ::core::option::Option<::prost::alloc::string::String>,
645    /// PB_OFFSET + MNM_LAST_NOTICE_DATE
646    #[prost(string, optional, tag = "154933")]
647    pub last_notice_date: ::core::option::Option<::prost::alloc::string::String>,
648    /// PB_OFFSET + MNM_FIRST_TRADING_DATE
649    #[prost(string, optional, tag = "154996")]
650    pub first_trading_date: ::core::option::Option<::prost::alloc::string::String>,
651    /// PB_OFFSET + MNM_LAST_TRADING_DATE
652    #[prost(string, optional, tag = "154236")]
653    pub last_trading_date: ::core::option::Option<::prost::alloc::string::String>,
654    /// PB_OFFSET + MNM_FIRST_DELIVERY_DATE
655    #[prost(string, optional, tag = "154994")]
656    pub first_delivery_date: ::core::option::Option<::prost::alloc::string::String>,
657    /// PB_OFFSET + MNM_LAST_DELIVERY_DATE
658    #[prost(string, optional, tag = "154995")]
659    pub last_delivery_date: ::core::option::Option<::prost::alloc::string::String>,
660    /// PB_OFFSET + MNM_FIRST_POSITION_DATE
661    #[prost(string, optional, tag = "154997")]
662    pub first_position_date: ::core::option::Option<::prost::alloc::string::String>,
663    /// PB_OFFSET + MNM_LAST_POSITION_DATE
664    #[prost(string, optional, tag = "154998")]
665    pub last_position_date: ::core::option::Option<::prost::alloc::string::String>,
666    /// PB_OFFSET + MNM_UNIT_OF_MEASURE
667    #[prost(string, optional, tag = "157023")]
668    pub unit_of_measure: ::core::option::Option<::prost::alloc::string::String>,
669    /// PB_OFFSET + MNM_UNIT_OF_MEASURE_QTY
670    #[prost(double, optional, tag = "157024")]
671    pub unit_of_measure_qty: ::core::option::Option<f64>,
672}
673/// Nested message and enum types in `ResponseAuxilliaryReferenceData`.
674pub mod response_auxilliary_reference_data {
675    /// bit constants are defined using enum
676    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
677    #[repr(i32)]
678    pub enum PresenceBits {
679        SettlementMethod = 1,
680        FirstNoticeDate = 2,
681        LastNoticeDate = 4,
682        FirstTradingDate = 8,
683        LastTradingDate = 16,
684        FirstDeliveryDate = 32,
685        LastDeliveryDate = 64,
686        FirstPositionDate = 128,
687        LastPositionDate = 256,
688        UnitOfMeasure = 512,
689        UnitOfMeasureQty = 1024,
690    }
691    impl PresenceBits {
692        /// String value of the enum field names used in the ProtoBuf definition.
693        ///
694        /// The values are not transformed in any way and thus are considered stable
695        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
696        pub fn as_str_name(&self) -> &'static str {
697            match self {
698                Self::SettlementMethod => "SETTLEMENT_METHOD",
699                Self::FirstNoticeDate => "FIRST_NOTICE_DATE",
700                Self::LastNoticeDate => "LAST_NOTICE_DATE",
701                Self::FirstTradingDate => "FIRST_TRADING_DATE",
702                Self::LastTradingDate => "LAST_TRADING_DATE",
703                Self::FirstDeliveryDate => "FIRST_DELIVERY_DATE",
704                Self::LastDeliveryDate => "LAST_DELIVERY_DATE",
705                Self::FirstPositionDate => "FIRST_POSITION_DATE",
706                Self::LastPositionDate => "LAST_POSITION_DATE",
707                Self::UnitOfMeasure => "UNIT_OF_MEASURE",
708                Self::UnitOfMeasureQty => "UNIT_OF_MEASURE_QTY",
709            }
710        }
711        /// Creates an enum from field names used in the ProtoBuf definition.
712        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
713            match value {
714                "SETTLEMENT_METHOD" => Some(Self::SettlementMethod),
715                "FIRST_NOTICE_DATE" => Some(Self::FirstNoticeDate),
716                "LAST_NOTICE_DATE" => Some(Self::LastNoticeDate),
717                "FIRST_TRADING_DATE" => Some(Self::FirstTradingDate),
718                "LAST_TRADING_DATE" => Some(Self::LastTradingDate),
719                "FIRST_DELIVERY_DATE" => Some(Self::FirstDeliveryDate),
720                "LAST_DELIVERY_DATE" => Some(Self::LastDeliveryDate),
721                "FIRST_POSITION_DATE" => Some(Self::FirstPositionDate),
722                "LAST_POSITION_DATE" => Some(Self::LastPositionDate),
723                "UNIT_OF_MEASURE" => Some(Self::UnitOfMeasure),
724                "UNIT_OF_MEASURE_QTY" => Some(Self::UnitOfMeasureQty),
725                _ => None,
726            }
727        }
728    }
729}
730/// PB_OFFSET = 100000, is the offset added for each MNM field id
731#[derive(Clone, PartialEq, ::prost::Message)]
732pub struct RequestGiveTickSizeTypeTable {
733    /// PB_OFFSET + MNM_TEMPLATE_ID
734    #[prost(int32, required, tag = "154467")]
735    pub template_id: i32,
736    /// PB_OFFSET + MNM_USER_MSG
737    #[prost(string, repeated, tag = "132760")]
738    pub user_msg: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
739    /// PB_OFFSET + MNM_TICK_SIZE_TYPE
740    #[prost(string, optional, tag = "154167")]
741    pub tick_size_type: ::core::option::Option<::prost::alloc::string::String>,
742}
743/// PB_OFFSET = 100000, is the offset added for each MNM field id
744#[derive(Clone, PartialEq, ::prost::Message)]
745pub struct ResponseGiveTickSizeTypeTable {
746    /// PB_OFFSET + MNM_TEMPLATE_ID
747    #[prost(int32, required, tag = "154467")]
748    pub template_id: i32,
749    /// PB_OFFSET + MNM_USER_MSG
750    #[prost(string, repeated, tag = "132760")]
751    pub user_msg: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
752    /// PB_OFFSET + MNM_REQUEST_HANDLER_RESPONSE_CODE
753    #[prost(string, repeated, tag = "132764")]
754    pub rq_handler_rp_code: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
755    /// PB_OFFSET + MNM_RESPONSE_CODE
756    #[prost(string, repeated, tag = "132766")]
757    pub rp_code: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
758    /// PB_OFFSET + MNM_PRICING_INDICATOR
759    #[prost(uint32, optional, tag = "149138")]
760    pub presence_bits: ::core::option::Option<u32>,
761    /// PB_OFFSET + MNM_TICK_SIZE_TYPE
762    #[prost(string, optional, tag = "154167")]
763    pub tick_size_type: ::core::option::Option<::prost::alloc::string::String>,
764    /// PB_OFFSET + MNM_TICK_SIZE_FP_OPERATOR
765    #[prost(string, optional, tag = "154170")]
766    pub tick_size_fp_operator: ::core::option::Option<::prost::alloc::string::String>,
767    /// PB_OFFSET + MNM_TICK_SIZE_LP_OPERATOR
768    #[prost(string, optional, tag = "154171")]
769    pub tick_size_lp_operator: ::core::option::Option<::prost::alloc::string::String>,
770    /// PB_OFFSET + MNM_MIN_FPRICE_CHANGE
771    #[prost(double, optional, tag = "154387")]
772    pub min_fprice_change: ::core::option::Option<f64>,
773    /// PB_OFFSET + MNM_TICK_SIZE_FIRST_PRICE
774    #[prost(double, optional, tag = "154168")]
775    pub tick_size_first_price: ::core::option::Option<f64>,
776    /// PB_OFFSET + MNM_TICK_SIZE_LAST_PRICE
777    #[prost(double, optional, tag = "154169")]
778    pub tick_size_last_price: ::core::option::Option<f64>,
779}
780/// Nested message and enum types in `ResponseGiveTickSizeTypeTable`.
781pub mod response_give_tick_size_type_table {
782    /// bit constants are defined using enum
783    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
784    #[repr(i32)]
785    pub enum PresenceBits {
786        TickSizeFirstPrice = 1,
787        TickSizeLastPrice = 2,
788        TickSizeFpOperator = 4,
789        TickSizeLpOperator = 8,
790    }
791    impl PresenceBits {
792        /// String value of the enum field names used in the ProtoBuf definition.
793        ///
794        /// The values are not transformed in any way and thus are considered stable
795        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
796        pub fn as_str_name(&self) -> &'static str {
797            match self {
798                Self::TickSizeFirstPrice => "TICK_SIZE_FIRST_PRICE",
799                Self::TickSizeLastPrice => "TICK_SIZE_LAST_PRICE",
800                Self::TickSizeFpOperator => "TICK_SIZE_FP_OPERATOR",
801                Self::TickSizeLpOperator => "TICK_SIZE_LP_OPERATOR",
802            }
803        }
804        /// Creates an enum from field names used in the ProtoBuf definition.
805        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
806            match value {
807                "TICK_SIZE_FIRST_PRICE" => Some(Self::TickSizeFirstPrice),
808                "TICK_SIZE_LAST_PRICE" => Some(Self::TickSizeLastPrice),
809                "TICK_SIZE_FP_OPERATOR" => Some(Self::TickSizeFpOperator),
810                "TICK_SIZE_LP_OPERATOR" => Some(Self::TickSizeLpOperator),
811                _ => None,
812            }
813        }
814    }
815}
816/// PB_OFFSET = 100000, is the offset added for each MNM field id
817#[derive(Clone, PartialEq, ::prost::Message)]
818pub struct RequestGetInstrumentByUnderlying {
819    /// PB_OFFSET + MNM_TEMPLATE_ID
820    #[prost(int32, required, tag = "154467")]
821    pub template_id: i32,
822    /// PB_OFFSET + MNM_USER_MSG
823    #[prost(string, repeated, tag = "132760")]
824    pub user_msg: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
825    /// PB_OFFSET + MNM_UNDERLYING_SYMBOL
826    #[prost(string, optional, tag = "101026")]
827    pub underlying_symbol: ::core::option::Option<::prost::alloc::string::String>,
828    /// PB_OFFSET + MNM_EXCHANGE
829    #[prost(string, optional, tag = "110101")]
830    pub exchange: ::core::option::Option<::prost::alloc::string::String>,
831    /// PB_OFFSET + MNM_EXPIRATION_DATE
832    #[prost(string, optional, tag = "100067")]
833    pub expiration_date: ::core::option::Option<::prost::alloc::string::String>,
834}
835/// presence bits field defined here is an exact copy of response_reference_data.proto
836/// Make sure they are always the same in both proto files.
837#[derive(Clone, PartialEq, ::prost::Message)]
838pub struct ResponseGetInstrumentByUnderlying {
839    /// PB_OFFSET + MNM_TEMPLATE_ID
840    #[prost(int32, required, tag = "154467")]
841    pub template_id: i32,
842    /// PB_OFFSET + MNM_USER_MSG
843    #[prost(string, repeated, tag = "132760")]
844    pub user_msg: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
845    /// PB_OFFSET + MNM_REQUEST_HANDLER_RESPONSE_CODE
846    #[prost(string, repeated, tag = "132764")]
847    pub rq_handler_rp_code: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
848    /// PB_OFFSET + MNM_RESPONSE_CODE
849    #[prost(string, repeated, tag = "132766")]
850    pub rp_code: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
851    /// PB_OFFSET + MNM_PRICING_INDICATOR
852    #[prost(uint32, optional, tag = "149138")]
853    pub presence_bits: ::core::option::Option<u32>,
854    /// PB_OFFSET + MNM_DISPLAY_INDICATOR
855    #[prost(uint32, optional, tag = "154571")]
856    pub clear_bits: ::core::option::Option<u32>,
857    /// PB_OFFSET + MNM_SYMBOL
858    #[prost(string, optional, tag = "110100")]
859    pub symbol: ::core::option::Option<::prost::alloc::string::String>,
860    /// PB_OFFSET + MNM_EXCHANGE
861    #[prost(string, optional, tag = "110101")]
862    pub exchange: ::core::option::Option<::prost::alloc::string::String>,
863    /// PB_OFFSET + MNM_EXCHANGE_SYMBOL
864    #[prost(string, optional, tag = "110114")]
865    pub exchange_symbol: ::core::option::Option<::prost::alloc::string::String>,
866    /// PB_OFFSET + MNM_SYMBOL_NAME
867    #[prost(string, optional, tag = "100003")]
868    pub symbol_name: ::core::option::Option<::prost::alloc::string::String>,
869    /// PB_OFFSET + MNM_PRODUCT_CODE
870    #[prost(string, optional, tag = "100749")]
871    pub product_code: ::core::option::Option<::prost::alloc::string::String>,
872    /// PB_OFFSET + MNM_INSTRUMENT_TYPE
873    #[prost(string, optional, tag = "110116")]
874    pub instrument_type: ::core::option::Option<::prost::alloc::string::String>,
875    /// PB_OFFSET + MNM_UNDERLYING_SYMBOL
876    #[prost(string, optional, tag = "101026")]
877    pub underlying_symbol: ::core::option::Option<::prost::alloc::string::String>,
878    /// PB_OFFSET + MNM_EXPIRATION_DATE
879    #[prost(string, optional, tag = "100067")]
880    pub expiration_date: ::core::option::Option<::prost::alloc::string::String>,
881    /// PB_OFFSET + MNM_SYMBOL_CURRENCY
882    #[prost(string, optional, tag = "154382")]
883    pub currency: ::core::option::Option<::prost::alloc::string::String>,
884    /// PB_OFFSET + MNM_PUT_CALL_INDICATOR
885    #[prost(string, optional, tag = "100109")]
886    pub put_call_indicator: ::core::option::Option<::prost::alloc::string::String>,
887    /// PB_OFFSET + MNM_TICK_SIZE_TYPE
888    #[prost(string, optional, tag = "154167")]
889    pub tick_size_type: ::core::option::Option<::prost::alloc::string::String>,
890    /// PB_OFFSET + MNM_PRICE_DISPLAY_FORMAT
891    #[prost(string, optional, tag = "154390")]
892    pub price_display_format: ::core::option::Option<::prost::alloc::string::String>,
893    /// PB_OFFSET + MNM_STRIKE_PRICE
894    #[prost(double, optional, tag = "100066")]
895    pub strike_price: ::core::option::Option<f64>,
896    /// PB_OFFSET + MNM_FPRICE_TO_QPRICE
897    #[prost(double, optional, tag = "154384")]
898    pub ftoq_price: ::core::option::Option<f64>,
899    /// PB_OFFSET + MNM_QPRICE_TO_FPRICE
900    #[prost(double, optional, tag = "154385")]
901    pub qtof_price: ::core::option::Option<f64>,
902    /// PB_OFFSET + MNM_MIN_QPRICE_CHANGE
903    #[prost(double, optional, tag = "154386")]
904    pub min_qprice_change: ::core::option::Option<f64>,
905    /// PB_OFFSET + MNM_MIN_FPRICE_CHANGE
906    #[prost(double, optional, tag = "154387")]
907    pub min_fprice_change: ::core::option::Option<f64>,
908    /// PB_OFFSET + MNM_SINGLE_POINT_VALUE
909    #[prost(double, optional, tag = "154389")]
910    pub single_point_value: ::core::option::Option<f64>,
911}
912/// Nested message and enum types in `ResponseGetInstrumentByUnderlying`.
913pub mod response_get_instrument_by_underlying {
914    /// bit constants are defined using enum
915    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
916    #[repr(i32)]
917    pub enum PresenceBits {
918        ExchangeSymbol = 1,
919        SymbolName = 2,
920        ProductCode = 4,
921        InstrumentType = 8,
922        UnderlyingSymbol = 16,
923        ExpirationDate = 32,
924        Currency = 64,
925        PutCallIndicator = 128,
926        StrikePrice = 256,
927        FpriceToQprice = 512,
928        QpriceToFprice = 1024,
929        MinQpriceChange = 2048,
930        MinFrpiceChange = 4096,
931        SinglePointValue = 8192,
932        TickSizeType = 16384,
933        PriceDisplayFormat = 32768,
934    }
935    impl PresenceBits {
936        /// String value of the enum field names used in the ProtoBuf definition.
937        ///
938        /// The values are not transformed in any way and thus are considered stable
939        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
940        pub fn as_str_name(&self) -> &'static str {
941            match self {
942                Self::ExchangeSymbol => "EXCHANGE_SYMBOL",
943                Self::SymbolName => "SYMBOL_NAME",
944                Self::ProductCode => "PRODUCT_CODE",
945                Self::InstrumentType => "INSTRUMENT_TYPE",
946                Self::UnderlyingSymbol => "UNDERLYING_SYMBOL",
947                Self::ExpirationDate => "EXPIRATION_DATE",
948                Self::Currency => "CURRENCY",
949                Self::PutCallIndicator => "PUT_CALL_INDICATOR",
950                Self::StrikePrice => "STRIKE_PRICE",
951                Self::FpriceToQprice => "FPRICE_TO_QPRICE",
952                Self::QpriceToFprice => "QPRICE_TO_FPRICE",
953                Self::MinQpriceChange => "MIN_QPRICE_CHANGE",
954                Self::MinFrpiceChange => "MIN_FRPICE_CHANGE",
955                Self::SinglePointValue => "SINGLE_POINT_VALUE",
956                Self::TickSizeType => "TICK_SIZE_TYPE",
957                Self::PriceDisplayFormat => "PRICE_DISPLAY_FORMAT",
958            }
959        }
960        /// Creates an enum from field names used in the ProtoBuf definition.
961        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
962            match value {
963                "EXCHANGE_SYMBOL" => Some(Self::ExchangeSymbol),
964                "SYMBOL_NAME" => Some(Self::SymbolName),
965                "PRODUCT_CODE" => Some(Self::ProductCode),
966                "INSTRUMENT_TYPE" => Some(Self::InstrumentType),
967                "UNDERLYING_SYMBOL" => Some(Self::UnderlyingSymbol),
968                "EXPIRATION_DATE" => Some(Self::ExpirationDate),
969                "CURRENCY" => Some(Self::Currency),
970                "PUT_CALL_INDICATOR" => Some(Self::PutCallIndicator),
971                "STRIKE_PRICE" => Some(Self::StrikePrice),
972                "FPRICE_TO_QPRICE" => Some(Self::FpriceToQprice),
973                "QPRICE_TO_FPRICE" => Some(Self::QpriceToFprice),
974                "MIN_QPRICE_CHANGE" => Some(Self::MinQpriceChange),
975                "MIN_FRPICE_CHANGE" => Some(Self::MinFrpiceChange),
976                "SINGLE_POINT_VALUE" => Some(Self::SinglePointValue),
977                "TICK_SIZE_TYPE" => Some(Self::TickSizeType),
978                "PRICE_DISPLAY_FORMAT" => Some(Self::PriceDisplayFormat),
979                _ => None,
980            }
981        }
982    }
983}
984/// PB_OFFSET = 100000, is the offset added for each MNM field id
985#[derive(Clone, PartialEq, ::prost::Message)]
986pub struct ResponseGetInstrumentByUnderlyingKeys {
987    /// PB_OFFSET + MNM_TEMPLATE_ID
988    #[prost(int32, required, tag = "154467")]
989    pub template_id: i32,
990    /// PB_OFFSET + MNM_USER_MSG
991    #[prost(string, repeated, tag = "132760")]
992    pub user_msg: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
993    /// PB_OFFSET + MNM_RESPONSE_CODE
994    #[prost(string, repeated, tag = "132766")]
995    pub rp_code: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
996    /// PB_OFFSET + MNM_UNDERLYING_SYMBOL
997    #[prost(string, repeated, tag = "101026")]
998    pub underlying_symbol: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
999    /// PB_OFFSET + MNM_EXCHANGE
1000    #[prost(string, repeated, tag = "110101")]
1001    pub exchange: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
1002    /// PB_OFFSET + MNM_EXPIRATION_DATE
1003    #[prost(string, repeated, tag = "100067")]
1004    pub expiration_date: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
1005}
1006/// update bits and Request enum field defined here is an exact copy of request_market_data_update.proto
1007/// Make sure they are always the same in both proto files.
1008#[derive(Clone, PartialEq, ::prost::Message)]
1009pub struct RequestMarketDataUpdateByUnderlying {
1010    /// PB_OFFSET + MNM_TEMPLATE_ID
1011    #[prost(int32, required, tag = "154467")]
1012    pub template_id: i32,
1013    /// PB_OFFSET + MNM_USER_MSG
1014    #[prost(string, repeated, tag = "132760")]
1015    pub user_msg: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
1016    /// PB_OFFSET + MNM_UNDERLYING_SYMBOL
1017    #[prost(string, optional, tag = "101026")]
1018    pub underlying_symbol: ::core::option::Option<::prost::alloc::string::String>,
1019    /// PB_OFFSET + MNM_EXCHANGE
1020    #[prost(string, optional, tag = "110101")]
1021    pub exchange: ::core::option::Option<::prost::alloc::string::String>,
1022    /// PB_OFFSET + MNM_EXPIRATION_DATE
1023    #[prost(string, optional, tag = "100067")]
1024    pub expiration_date: ::core::option::Option<::prost::alloc::string::String>,
1025    /// PB_OFFSET + MNM_REQUEST
1026    #[prost(
1027        enumeration = "request_market_data_update_by_underlying::Request",
1028        optional,
1029        tag = "100000"
1030    )]
1031    pub request: ::core::option::Option<i32>,
1032    /// PB_OFFSET + MNM_MESSAGE_ID
1033    #[prost(uint32, optional, tag = "154211")]
1034    pub update_bits: ::core::option::Option<u32>,
1035}
1036/// Nested message and enum types in `RequestMarketDataUpdateByUnderlying`.
1037pub mod request_market_data_update_by_underlying {
1038    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
1039    #[repr(i32)]
1040    pub enum UpdateBits {
1041        LastTrade = 1,
1042        Bbo = 2,
1043        OrderBook = 4,
1044        Open = 8,
1045        OpeningIndicator = 16,
1046        HighLow = 32,
1047        HighBidLowAsk = 64,
1048        Close = 128,
1049        ClosingIndicator = 256,
1050        Settlement = 512,
1051        MarketMode = 1024,
1052        OpenInterest = 2048,
1053        MarginRate = 4096,
1054        HighPriceLimit = 8192,
1055        LowPriceLimit = 16384,
1056        ProjectedSettlement = 32768,
1057    }
1058    impl UpdateBits {
1059        /// String value of the enum field names used in the ProtoBuf definition.
1060        ///
1061        /// The values are not transformed in any way and thus are considered stable
1062        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
1063        pub fn as_str_name(&self) -> &'static str {
1064            match self {
1065                Self::LastTrade => "LAST_TRADE",
1066                Self::Bbo => "BBO",
1067                Self::OrderBook => "ORDER_BOOK",
1068                Self::Open => "OPEN",
1069                Self::OpeningIndicator => "OPENING_INDICATOR",
1070                Self::HighLow => "HIGH_LOW",
1071                Self::HighBidLowAsk => "HIGH_BID_LOW_ASK",
1072                Self::Close => "CLOSE",
1073                Self::ClosingIndicator => "CLOSING_INDICATOR",
1074                Self::Settlement => "SETTLEMENT",
1075                Self::MarketMode => "MARKET_MODE",
1076                Self::OpenInterest => "OPEN_INTEREST",
1077                Self::MarginRate => "MARGIN_RATE",
1078                Self::HighPriceLimit => "HIGH_PRICE_LIMIT",
1079                Self::LowPriceLimit => "LOW_PRICE_LIMIT",
1080                Self::ProjectedSettlement => "PROJECTED_SETTLEMENT",
1081            }
1082        }
1083        /// Creates an enum from field names used in the ProtoBuf definition.
1084        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
1085            match value {
1086                "LAST_TRADE" => Some(Self::LastTrade),
1087                "BBO" => Some(Self::Bbo),
1088                "ORDER_BOOK" => Some(Self::OrderBook),
1089                "OPEN" => Some(Self::Open),
1090                "OPENING_INDICATOR" => Some(Self::OpeningIndicator),
1091                "HIGH_LOW" => Some(Self::HighLow),
1092                "HIGH_BID_LOW_ASK" => Some(Self::HighBidLowAsk),
1093                "CLOSE" => Some(Self::Close),
1094                "CLOSING_INDICATOR" => Some(Self::ClosingIndicator),
1095                "SETTLEMENT" => Some(Self::Settlement),
1096                "MARKET_MODE" => Some(Self::MarketMode),
1097                "OPEN_INTEREST" => Some(Self::OpenInterest),
1098                "MARGIN_RATE" => Some(Self::MarginRate),
1099                "HIGH_PRICE_LIMIT" => Some(Self::HighPriceLimit),
1100                "LOW_PRICE_LIMIT" => Some(Self::LowPriceLimit),
1101                "PROJECTED_SETTLEMENT" => Some(Self::ProjectedSettlement),
1102                _ => None,
1103            }
1104        }
1105    }
1106    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
1107    #[repr(i32)]
1108    pub enum Request {
1109        Subscribe = 1,
1110        Unsubscribe = 2,
1111    }
1112    impl Request {
1113        /// String value of the enum field names used in the ProtoBuf definition.
1114        ///
1115        /// The values are not transformed in any way and thus are considered stable
1116        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
1117        pub fn as_str_name(&self) -> &'static str {
1118            match self {
1119                Self::Subscribe => "SUBSCRIBE",
1120                Self::Unsubscribe => "UNSUBSCRIBE",
1121            }
1122        }
1123        /// Creates an enum from field names used in the ProtoBuf definition.
1124        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
1125            match value {
1126                "SUBSCRIBE" => Some(Self::Subscribe),
1127                "UNSUBSCRIBE" => Some(Self::Unsubscribe),
1128                _ => None,
1129            }
1130        }
1131    }
1132}
1133/// PB_OFFSET = 100000, is the offset added for each MNM field id
1134#[derive(Clone, PartialEq, ::prost::Message)]
1135pub struct ResponseMarketDataUpdateByUnderlying {
1136    /// PB_OFFSET + MNM_TEMPLATE_ID
1137    #[prost(int32, required, tag = "154467")]
1138    pub template_id: i32,
1139    /// PB_OFFSET + MNM_USER_MSG
1140    #[prost(string, repeated, tag = "132760")]
1141    pub user_msg: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
1142    /// PB_OFFSET + MNM_RESPONSE_CODE
1143    #[prost(string, repeated, tag = "132766")]
1144    pub rp_code: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
1145}
1146/// PB_OFFSET = 100000, is the offset added for each MNM field id
1147#[derive(Clone, PartialEq, ::prost::Message)]
1148pub struct RequestSearchSymbols {
1149    /// PB_OFFSET + MNM_TEMPLATE_ID
1150    #[prost(int32, required, tag = "154467")]
1151    pub template_id: i32,
1152    /// PB_OFFSET + MNM_USER_MSG
1153    #[prost(string, repeated, tag = "132760")]
1154    pub user_msg: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
1155    /// PB_OFFSET + MNM_TEXT
1156    #[prost(string, optional, tag = "120008")]
1157    pub search_text: ::core::option::Option<::prost::alloc::string::String>,
1158    /// PB_OFFSET + MNM_EXCHANGE
1159    #[prost(string, optional, tag = "110101")]
1160    pub exchange: ::core::option::Option<::prost::alloc::string::String>,
1161    /// PB_OFFSET + MNM_PRODUCT_CODE
1162    #[prost(string, optional, tag = "100749")]
1163    pub product_code: ::core::option::Option<::prost::alloc::string::String>,
1164    /// PB_OFFSET + MNM_INSTRUMENT_TYPE
1165    #[prost(
1166        enumeration = "request_search_symbols::InstrumentType",
1167        optional,
1168        tag = "110116"
1169    )]
1170    pub instrument_type: ::core::option::Option<i32>,
1171    /// PB_OFFSET + MNM_SEARCH_PATTERN
1172    #[prost(
1173        enumeration = "request_search_symbols::Pattern",
1174        optional,
1175        tag = "155008"
1176    )]
1177    pub pattern: ::core::option::Option<i32>,
1178}
1179/// Nested message and enum types in `RequestSearchSymbols`.
1180pub mod request_search_symbols {
1181    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
1182    #[repr(i32)]
1183    pub enum Pattern {
1184        Equals = 1,
1185        Contains = 2,
1186    }
1187    impl Pattern {
1188        /// String value of the enum field names used in the ProtoBuf definition.
1189        ///
1190        /// The values are not transformed in any way and thus are considered stable
1191        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
1192        pub fn as_str_name(&self) -> &'static str {
1193            match self {
1194                Self::Equals => "EQUALS",
1195                Self::Contains => "CONTAINS",
1196            }
1197        }
1198        /// Creates an enum from field names used in the ProtoBuf definition.
1199        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
1200            match value {
1201                "EQUALS" => Some(Self::Equals),
1202                "CONTAINS" => Some(Self::Contains),
1203                _ => None,
1204            }
1205        }
1206    }
1207    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
1208    #[repr(i32)]
1209    pub enum InstrumentType {
1210        Future = 1,
1211        FutureOption = 2,
1212        FutureStrategy = 3,
1213        Equity = 4,
1214        EquityOption = 5,
1215        EquityStrategy = 6,
1216        Index = 7,
1217        IndexOption = 8,
1218        Spread = 9,
1219        Synthetic = 10,
1220    }
1221    impl InstrumentType {
1222        /// String value of the enum field names used in the ProtoBuf definition.
1223        ///
1224        /// The values are not transformed in any way and thus are considered stable
1225        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
1226        pub fn as_str_name(&self) -> &'static str {
1227            match self {
1228                Self::Future => "FUTURE",
1229                Self::FutureOption => "FUTURE_OPTION",
1230                Self::FutureStrategy => "FUTURE_STRATEGY",
1231                Self::Equity => "EQUITY",
1232                Self::EquityOption => "EQUITY_OPTION",
1233                Self::EquityStrategy => "EQUITY_STRATEGY",
1234                Self::Index => "INDEX",
1235                Self::IndexOption => "INDEX_OPTION",
1236                Self::Spread => "SPREAD",
1237                Self::Synthetic => "SYNTHETIC",
1238            }
1239        }
1240        /// Creates an enum from field names used in the ProtoBuf definition.
1241        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
1242            match value {
1243                "FUTURE" => Some(Self::Future),
1244                "FUTURE_OPTION" => Some(Self::FutureOption),
1245                "FUTURE_STRATEGY" => Some(Self::FutureStrategy),
1246                "EQUITY" => Some(Self::Equity),
1247                "EQUITY_OPTION" => Some(Self::EquityOption),
1248                "EQUITY_STRATEGY" => Some(Self::EquityStrategy),
1249                "INDEX" => Some(Self::Index),
1250                "INDEX_OPTION" => Some(Self::IndexOption),
1251                "SPREAD" => Some(Self::Spread),
1252                "SYNTHETIC" => Some(Self::Synthetic),
1253                _ => None,
1254            }
1255        }
1256    }
1257}
1258/// PB_OFFSET = 100000, is the offset added for each MNM field id
1259#[derive(Clone, PartialEq, ::prost::Message)]
1260pub struct ResponseSearchSymbols {
1261    /// PB_OFFSET + MNM_TEMPLATE_ID
1262    #[prost(int32, required, tag = "154467")]
1263    pub template_id: i32,
1264    /// PB_OFFSET + MNM_USER_MSG
1265    #[prost(string, repeated, tag = "132760")]
1266    pub user_msg: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
1267    /// PB_OFFSET + MNM_REQUEST_HANDLER_RESPONSE_CODE
1268    #[prost(string, repeated, tag = "132764")]
1269    pub rq_handler_rp_code: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
1270    /// PB_OFFSET + MNM_RESPONSE_CODE
1271    #[prost(string, repeated, tag = "132766")]
1272    pub rp_code: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
1273    /// PB_OFFSET + MNM_SYMBOL
1274    #[prost(string, optional, tag = "110100")]
1275    pub symbol: ::core::option::Option<::prost::alloc::string::String>,
1276    /// PB_OFFSET + MNM_EXCHANGE
1277    #[prost(string, optional, tag = "110101")]
1278    pub exchange: ::core::option::Option<::prost::alloc::string::String>,
1279    /// PB_OFFSET + MNM_SYMBOL_NAME
1280    #[prost(string, optional, tag = "100003")]
1281    pub symbol_name: ::core::option::Option<::prost::alloc::string::String>,
1282    /// PB_OFFSET + MNM_PRODUCT_CODE
1283    #[prost(string, optional, tag = "100749")]
1284    pub product_code: ::core::option::Option<::prost::alloc::string::String>,
1285    /// PB_OFFSET + MNM_INSTRUMENT_TYPE
1286    #[prost(string, optional, tag = "110116")]
1287    pub instrument_type: ::core::option::Option<::prost::alloc::string::String>,
1288    /// PB_OFFSET + MNM_EXPIRATION_DATE
1289    #[prost(string, optional, tag = "100067")]
1290    pub expiration_date: ::core::option::Option<::prost::alloc::string::String>,
1291}
1292/// PB_OFFSET = 100000, is the offset added for each MNM field id
1293#[derive(Clone, PartialEq, ::prost::Message)]
1294pub struct RequestProductCodes {
1295    /// PB_OFFSET + MNM_TEMPLATE_ID
1296    #[prost(int32, required, tag = "154467")]
1297    pub template_id: i32,
1298    /// PB_OFFSET + MNM_USER_MSG
1299    #[prost(string, repeated, tag = "132760")]
1300    pub user_msg: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
1301    /// PB_OFFSET + MNM_EXCHANGE
1302    #[prost(string, optional, tag = "110101")]
1303    pub exchange: ::core::option::Option<::prost::alloc::string::String>,
1304    /// PB_OFFSET + MNM_TOI_PRODUCTS_ONLY
1305    #[prost(bool, optional, tag = "153499")]
1306    pub give_toi_products_only: ::core::option::Option<bool>,
1307}
1308/// PB_OFFSET = 100000, is the offset added for each MNM field id
1309#[derive(Clone, PartialEq, ::prost::Message)]
1310pub struct ResponseProductCodes {
1311    /// PB_OFFSET + MNM_TEMPLATE_ID
1312    #[prost(int32, required, tag = "154467")]
1313    pub template_id: i32,
1314    /// PB_OFFSET + MNM_USER_MSG
1315    #[prost(string, repeated, tag = "132760")]
1316    pub user_msg: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
1317    /// PB_OFFSET + MNM_REQUEST_HANDLER_RESPONSE_CODE
1318    #[prost(string, repeated, tag = "132764")]
1319    pub rq_handler_rp_code: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
1320    /// PB_OFFSET + MNM_RESPONSE_CODE
1321    #[prost(string, repeated, tag = "132766")]
1322    pub rp_code: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
1323    /// PB_OFFSET + MNM_EXCHANGE
1324    #[prost(string, optional, tag = "110101")]
1325    pub exchange: ::core::option::Option<::prost::alloc::string::String>,
1326    /// PB_OFFSET + MNM_SYMBOL_NAME
1327    #[prost(string, optional, tag = "100003")]
1328    pub symbol_name: ::core::option::Option<::prost::alloc::string::String>,
1329    /// PB_OFFSET + MNM_PRODUCT_CODE
1330    #[prost(string, optional, tag = "100749")]
1331    pub product_code: ::core::option::Option<::prost::alloc::string::String>,
1332    /// PB_OFFSET + MNM_TIMEZONE_TIME_OF_INTEREST
1333    #[prost(string, optional, tag = "154682")]
1334    pub timezone_time_of_interest: ::core::option::Option<::prost::alloc::string::String>,
1335    /// PB_OFFSET + MNM_BEGIN_TIME_OF_INTEREST_MSM
1336    #[prost(int32, optional, tag = "154680")]
1337    pub begin_time_of_interest_msm: ::core::option::Option<i32>,
1338    /// PB_OFFSET + MNM_END_TIME_OF_INTEREST_MSM
1339    #[prost(int32, optional, tag = "154681")]
1340    pub end_time_of_interest_msm: ::core::option::Option<i32>,
1341}
1342/// PB_OFFSET = 100000, is the offset added for each MNM field id
1343#[derive(Clone, PartialEq, ::prost::Message)]
1344pub struct RequestFrontMonthContract {
1345    /// PB_OFFSET + MNM_TEMPLATE_ID
1346    #[prost(int32, required, tag = "154467")]
1347    pub template_id: i32,
1348    /// PB_OFFSET + MNM_USER_MSG
1349    #[prost(string, repeated, tag = "132760")]
1350    pub user_msg: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
1351    /// PB_OFFSET + MNM_SYMBOL
1352    #[prost(string, optional, tag = "110100")]
1353    pub symbol: ::core::option::Option<::prost::alloc::string::String>,
1354    /// PB_OFFSET + MNM_EXCHANGE
1355    #[prost(string, optional, tag = "110101")]
1356    pub exchange: ::core::option::Option<::prost::alloc::string::String>,
1357    /// PB_OFFSET + MNM_SUBSCRIBE_FLAG
1358    #[prost(bool, optional, tag = "154352")]
1359    pub need_updates: ::core::option::Option<bool>,
1360}
1361/// PB_OFFSET = 100000, is the offset added for each MNM field id
1362#[derive(Clone, PartialEq, ::prost::Message)]
1363pub struct ResponseFrontMonthContract {
1364    /// PB_OFFSET + MNM_TEMPLATE_ID
1365    #[prost(int32, required, tag = "154467")]
1366    pub template_id: i32,
1367    /// PB_OFFSET + MNM_USER_MSG
1368    #[prost(string, repeated, tag = "132760")]
1369    pub user_msg: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
1370    /// PB_OFFSET + MNM_RESPONSE_CODE
1371    #[prost(string, repeated, tag = "132766")]
1372    pub rp_code: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
1373    /// PB_OFFSET + MNM_SYMBOL
1374    #[prost(string, optional, tag = "110100")]
1375    pub symbol: ::core::option::Option<::prost::alloc::string::String>,
1376    /// PB_OFFSET + MNM_EXCHANGE
1377    #[prost(string, optional, tag = "110101")]
1378    pub exchange: ::core::option::Option<::prost::alloc::string::String>,
1379    /// PB_OFFSET + MNM_STATUS_INDICATOR
1380    #[prost(bool, optional, tag = "149166")]
1381    pub is_front_month_symbol: ::core::option::Option<bool>,
1382    /// PB_OFFSET + MNM_SYMBOL_NAME
1383    #[prost(string, optional, tag = "100003")]
1384    pub symbol_name: ::core::option::Option<::prost::alloc::string::String>,
1385    /// PB_OFFSET + MNM_TRADING_SYMBOL
1386    #[prost(string, optional, tag = "157095")]
1387    pub trading_symbol: ::core::option::Option<::prost::alloc::string::String>,
1388    /// PB_OFFSET + MNM_TRADING_EXCHANGE
1389    #[prost(string, optional, tag = "157096")]
1390    pub trading_exchange: ::core::option::Option<::prost::alloc::string::String>,
1391}
1392/// PB_OFFSET = 100000, is the offset added for each MNM field id
1393#[derive(Clone, PartialEq, ::prost::Message)]
1394pub struct RequestDepthByOrderSnapshot {
1395    /// PB_OFFSET + MNM_TEMPLATE_ID
1396    #[prost(int32, required, tag = "154467")]
1397    pub template_id: i32,
1398    /// PB_OFFSET + MNM_USER_MSG
1399    #[prost(string, repeated, tag = "132760")]
1400    pub user_msg: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
1401    /// PB_OFFSET + MNM_SYMBOL
1402    #[prost(string, optional, tag = "110100")]
1403    pub symbol: ::core::option::Option<::prost::alloc::string::String>,
1404    /// PB_OFFSET + MNM_EXCHANGE
1405    #[prost(string, optional, tag = "110101")]
1406    pub exchange: ::core::option::Option<::prost::alloc::string::String>,
1407    /// PB_OFFSET + MNM_MARKET_DEPTH_PRICE
1408    #[prost(double, optional, tag = "154405")]
1409    pub depth_price: ::core::option::Option<f64>,
1410}
1411/// PB_OFFSET = 100000, is the offset added for each MNM field id
1412#[derive(Clone, PartialEq, ::prost::Message)]
1413pub struct ResponseDepthByOrderSnapshot {
1414    /// PB_OFFSET + MNM_TEMPLATE_ID
1415    #[prost(int32, required, tag = "154467")]
1416    pub template_id: i32,
1417    /// PB_OFFSET + MNM_USER_MSG
1418    #[prost(string, repeated, tag = "132760")]
1419    pub user_msg: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
1420    /// PB_OFFSET + MNM_REQUEST_HANDLER_RESPONSE_CODE
1421    #[prost(string, repeated, tag = "132764")]
1422    pub rq_handler_rp_code: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
1423    /// PB_OFFSET + MNM_RESPONSE_CODE
1424    #[prost(string, repeated, tag = "132766")]
1425    pub rp_code: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
1426    /// PB_OFFSET + MNM_EXCHANGE
1427    #[prost(string, optional, tag = "110101")]
1428    pub exchange: ::core::option::Option<::prost::alloc::string::String>,
1429    /// PB_OFFSET + MNM_SYMBOL
1430    #[prost(string, optional, tag = "110100")]
1431    pub symbol: ::core::option::Option<::prost::alloc::string::String>,
1432    /// PB_OFFSET + MNM_SEQUENCE_NUMBER
1433    #[prost(uint64, optional, tag = "112002")]
1434    pub sequence_number: ::core::option::Option<u64>,
1435    /// PB_OFFSET + MNM_MARKET_DEPTH_SIDE
1436    #[prost(
1437        enumeration = "response_depth_by_order_snapshot::TransactionType",
1438        optional,
1439        tag = "153612"
1440    )]
1441    pub depth_side: ::core::option::Option<i32>,
1442    /// PB_OFFSET + MNM_MARKET_DEPTH_PRICE
1443    #[prost(double, optional, tag = "154405")]
1444    pub depth_price: ::core::option::Option<f64>,
1445    /// PB_OFFSET + MNM_MARKET_DEPTH_SIZE
1446    #[prost(int32, repeated, packed = "false", tag = "154406")]
1447    pub depth_size: ::prost::alloc::vec::Vec<i32>,
1448    /// PB_OFFSET + MNM_MARKET_DEPTH_ORDER_PRIORITY
1449    #[prost(uint64, repeated, packed = "false", tag = "153613")]
1450    pub depth_order_priority: ::prost::alloc::vec::Vec<u64>,
1451    /// PB_OFFSET + MNM_EXCH_ORD_ID
1452    #[prost(string, repeated, tag = "149238")]
1453    pub exchange_order_id: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
1454}
1455/// Nested message and enum types in `ResponseDepthByOrderSnapshot`.
1456pub mod response_depth_by_order_snapshot {
1457    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
1458    #[repr(i32)]
1459    pub enum TransactionType {
1460        Buy = 1,
1461        Sell = 2,
1462    }
1463    impl TransactionType {
1464        /// String value of the enum field names used in the ProtoBuf definition.
1465        ///
1466        /// The values are not transformed in any way and thus are considered stable
1467        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
1468        pub fn as_str_name(&self) -> &'static str {
1469            match self {
1470                Self::Buy => "BUY",
1471                Self::Sell => "SELL",
1472            }
1473        }
1474        /// Creates an enum from field names used in the ProtoBuf definition.
1475        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
1476            match value {
1477                "BUY" => Some(Self::Buy),
1478                "SELL" => Some(Self::Sell),
1479                _ => None,
1480            }
1481        }
1482    }
1483}
1484/// PB_OFFSET = 100000, is the offset added for each MNM field id
1485#[derive(Clone, PartialEq, ::prost::Message)]
1486pub struct RequestDepthByOrderUpdates {
1487    /// PB_OFFSET + MNM_TEMPLATE_ID
1488    #[prost(int32, required, tag = "154467")]
1489    pub template_id: i32,
1490    /// PB_OFFSET + MNM_USER_MSG
1491    #[prost(string, repeated, tag = "132760")]
1492    pub user_msg: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
1493    /// PB_OFFSET + MNM_REQUEST
1494    #[prost(
1495        enumeration = "request_depth_by_order_updates::Request",
1496        optional,
1497        tag = "100000"
1498    )]
1499    pub request: ::core::option::Option<i32>,
1500    /// PB_OFFSET + MNM_SYMBOL
1501    #[prost(string, optional, tag = "110100")]
1502    pub symbol: ::core::option::Option<::prost::alloc::string::String>,
1503    /// PB_OFFSET + MNM_EXCHANGE
1504    #[prost(string, optional, tag = "110101")]
1505    pub exchange: ::core::option::Option<::prost::alloc::string::String>,
1506    /// PB_OFFSET + MNM_MARKET_DEPTH_PRICE
1507    #[prost(double, optional, tag = "154405")]
1508    pub depth_price: ::core::option::Option<f64>,
1509}
1510/// Nested message and enum types in `RequestDepthByOrderUpdates`.
1511pub mod request_depth_by_order_updates {
1512    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
1513    #[repr(i32)]
1514    pub enum Request {
1515        Subscribe = 1,
1516        Unsubscribe = 2,
1517    }
1518    impl Request {
1519        /// String value of the enum field names used in the ProtoBuf definition.
1520        ///
1521        /// The values are not transformed in any way and thus are considered stable
1522        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
1523        pub fn as_str_name(&self) -> &'static str {
1524            match self {
1525                Self::Subscribe => "SUBSCRIBE",
1526                Self::Unsubscribe => "UNSUBSCRIBE",
1527            }
1528        }
1529        /// Creates an enum from field names used in the ProtoBuf definition.
1530        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
1531            match value {
1532                "SUBSCRIBE" => Some(Self::Subscribe),
1533                "UNSUBSCRIBE" => Some(Self::Unsubscribe),
1534                _ => None,
1535            }
1536        }
1537    }
1538}
1539/// PB_OFFSET = 100000, is the offset added for each MNM field id
1540#[derive(Clone, PartialEq, ::prost::Message)]
1541pub struct ResponseDepthByOrderUpdates {
1542    /// PB_OFFSET + MNM_TEMPLATE_ID
1543    #[prost(int32, required, tag = "154467")]
1544    pub template_id: i32,
1545    /// PB_OFFSET + MNM_USER_MSG
1546    #[prost(string, repeated, tag = "132760")]
1547    pub user_msg: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
1548    /// PB_OFFSET + MNM_RESPONSE_CODE
1549    #[prost(string, repeated, tag = "132766")]
1550    pub rp_code: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
1551}
1552/// PB_OFFSET = 100000, is the offset added for each MNM field id
1553#[derive(Clone, PartialEq, ::prost::Message)]
1554pub struct RequestGetVolumeAtPrice {
1555    /// PB_OFFSET + MNM_TEMPLATE_ID
1556    #[prost(int32, required, tag = "154467")]
1557    pub template_id: i32,
1558    /// PB_OFFSET + MNM_USER_MSG
1559    #[prost(string, repeated, tag = "132760")]
1560    pub user_msg: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
1561    /// PB_OFFSET + MNM_SYMBOL
1562    #[prost(string, optional, tag = "110100")]
1563    pub symbol: ::core::option::Option<::prost::alloc::string::String>,
1564    /// PB_OFFSET + MNM_EXCHANGE
1565    #[prost(string, optional, tag = "110101")]
1566    pub exchange: ::core::option::Option<::prost::alloc::string::String>,
1567}
1568/// PB_OFFSET = 100000, is the offset added for each MNM field id
1569#[derive(Clone, PartialEq, ::prost::Message)]
1570pub struct ResponseGetVolumeAtPrice {
1571    /// PB_OFFSET + MNM_TEMPLATE_ID
1572    #[prost(int32, required, tag = "154467")]
1573    pub template_id: i32,
1574    /// PB_OFFSET + MNM_USER_MSG
1575    #[prost(string, repeated, tag = "132760")]
1576    pub user_msg: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
1577    /// PB_OFFSET + MNM_REQUEST_HANDLER_RESPONSE_CODE
1578    #[prost(string, repeated, tag = "132764")]
1579    pub rq_handler_rp_code: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
1580    /// PB_OFFSET + MNM_RESPONSE_CODE
1581    #[prost(string, repeated, tag = "132766")]
1582    pub rp_code: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
1583    /// PB_OFFSET + MNM_SYMBOL
1584    #[prost(string, optional, tag = "110100")]
1585    pub symbol: ::core::option::Option<::prost::alloc::string::String>,
1586    /// PB_OFFSET + MNM_EXCHANGE
1587    #[prost(string, optional, tag = "110101")]
1588    pub exchange: ::core::option::Option<::prost::alloc::string::String>,
1589    /// PB_OFFSET + MNM_TRADE_PRICE
1590    #[prost(double, repeated, packed = "false", tag = "100006")]
1591    pub trade_price: ::prost::alloc::vec::Vec<f64>,
1592    /// PB_OFFSET + MNM_VOLUME_AT_PRICE
1593    #[prost(int32, repeated, packed = "false", tag = "156980")]
1594    pub volume_at_price: ::prost::alloc::vec::Vec<i32>,
1595    /// PB_OFFSET + MNM_SECONDS_SINCE_BOE
1596    #[prost(int32, optional, tag = "150100")]
1597    pub ssboe: ::core::option::Option<i32>,
1598    /// PB_OFFSET + MNM_USECS
1599    #[prost(int32, optional, tag = "150101")]
1600    pub usecs: ::core::option::Option<i32>,
1601}
1602/// PB_OFFSET = 100000, is the offset added for each MNM field id
1603#[derive(Clone, PartialEq, ::prost::Message)]
1604pub struct BestBidOffer {
1605    /// PB_OFFSET + MNM_TEMPLATE_ID
1606    #[prost(int32, required, tag = "154467")]
1607    pub template_id: i32,
1608    /// PB_OFFSET + MNM_SYMBOL
1609    #[prost(string, optional, tag = "110100")]
1610    pub symbol: ::core::option::Option<::prost::alloc::string::String>,
1611    /// PB_OFFSET + MNM_EXCHANGE
1612    #[prost(string, optional, tag = "110101")]
1613    pub exchange: ::core::option::Option<::prost::alloc::string::String>,
1614    /// PB_OFFSET + MNM_PRICING_INDICATOR
1615    #[prost(uint32, optional, tag = "149138")]
1616    pub presence_bits: ::core::option::Option<u32>,
1617    /// PB_OFFSET + MNM_DISPLAY_INDICATOR
1618    #[prost(uint32, optional, tag = "154571")]
1619    pub clear_bits: ::core::option::Option<u32>,
1620    /// PB_OFFSET + MNM_UPDATE_TYPE
1621    #[prost(bool, optional, tag = "110121")]
1622    pub is_snapshot: ::core::option::Option<bool>,
1623    /// PB_OFFSET + MNM_BID_PRICE
1624    #[prost(double, optional, tag = "100022")]
1625    pub bid_price: ::core::option::Option<f64>,
1626    /// PB_OFFSET + MNM_BID_SIZE
1627    #[prost(int32, optional, tag = "100030")]
1628    pub bid_size: ::core::option::Option<i32>,
1629    /// PB_OFFSET + MNM_BID_NO_OF_ORDERS
1630    #[prost(int32, optional, tag = "154403")]
1631    pub bid_orders: ::core::option::Option<i32>,
1632    /// PB_OFFSET + MNM_BID_IMPLICIT_SIZE
1633    #[prost(int32, optional, tag = "154867")]
1634    pub bid_implicit_size: ::core::option::Option<i32>,
1635    #[prost(string, optional, tag = "100266")]
1636    pub bid_time: ::core::option::Option<::prost::alloc::string::String>,
1637    /// PB_OFFSET + MNM_ASK_PRICE
1638    #[prost(double, optional, tag = "100025")]
1639    pub ask_price: ::core::option::Option<f64>,
1640    /// PB_OFFSET + MNM_ASK_SIZE
1641    #[prost(int32, optional, tag = "100031")]
1642    pub ask_size: ::core::option::Option<i32>,
1643    /// PB_OFFSET + MNM_ASK_NO_OF_ORDERS
1644    #[prost(int32, optional, tag = "154404")]
1645    pub ask_orders: ::core::option::Option<i32>,
1646    /// PB_OFFSET + MNM_ASK_IMPLICIT_SIZE
1647    #[prost(int32, optional, tag = "154868")]
1648    pub ask_implicit_size: ::core::option::Option<i32>,
1649    #[prost(string, optional, tag = "100267")]
1650    pub ask_time: ::core::option::Option<::prost::alloc::string::String>,
1651    /// PB_OFFSET + MNM_LEAN_PRICE
1652    #[prost(double, optional, tag = "154909")]
1653    pub lean_price: ::core::option::Option<f64>,
1654    /// PB_OFFSET + MNM_SECONDS_SINCE_BOE
1655    #[prost(int32, optional, tag = "150100")]
1656    pub ssboe: ::core::option::Option<i32>,
1657    /// PB_OFFSET + MNM_USECS
1658    #[prost(int32, optional, tag = "150101")]
1659    pub usecs: ::core::option::Option<i32>,
1660}
1661/// Nested message and enum types in `BestBidOffer`.
1662pub mod best_bid_offer {
1663    /// below enum is just for reference only, not used in this message
1664    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
1665    #[repr(i32)]
1666    pub enum PresenceBits {
1667        Bid = 1,
1668        Ask = 2,
1669        LeanPrice = 4,
1670    }
1671    impl PresenceBits {
1672        /// String value of the enum field names used in the ProtoBuf definition.
1673        ///
1674        /// The values are not transformed in any way and thus are considered stable
1675        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
1676        pub fn as_str_name(&self) -> &'static str {
1677            match self {
1678                Self::Bid => "BID",
1679                Self::Ask => "ASK",
1680                Self::LeanPrice => "LEAN_PRICE",
1681            }
1682        }
1683        /// Creates an enum from field names used in the ProtoBuf definition.
1684        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
1685            match value {
1686                "BID" => Some(Self::Bid),
1687                "ASK" => Some(Self::Ask),
1688                "LEAN_PRICE" => Some(Self::LeanPrice),
1689                _ => None,
1690            }
1691        }
1692    }
1693}
1694/// PB_OFFSET = 100000 , is the offset added for each MNM field id
1695#[derive(Clone, PartialEq, ::prost::Message)]
1696pub struct OrderBook {
1697    /// PB_OFFSET + MNM_TEMPLATE_ID
1698    #[prost(int32, required, tag = "154467")]
1699    pub template_id: i32,
1700    /// PB_OFFSET + MNM_SYMBOL
1701    #[prost(string, optional, tag = "110100")]
1702    pub symbol: ::core::option::Option<::prost::alloc::string::String>,
1703    /// PB_OFFSET + MNM_EXCHANGE
1704    #[prost(string, optional, tag = "110101")]
1705    pub exchange: ::core::option::Option<::prost::alloc::string::String>,
1706    /// PB_OFFSET + MNM_PRICING_INDICATOR
1707    #[prost(uint32, optional, tag = "149138")]
1708    pub presence_bits: ::core::option::Option<u32>,
1709    /// PB_OFFSET + MNM_MARKET_DEPTH_UPDATE_TYPE
1710    #[prost(enumeration = "order_book::UpdateType", optional, tag = "157608")]
1711    pub update_type: ::core::option::Option<i32>,
1712    /// PB_OFFSET + MNM_MARKET_DEPTH_BID_PRICE
1713    #[prost(double, repeated, packed = "false", tag = "154282")]
1714    pub bid_price: ::prost::alloc::vec::Vec<f64>,
1715    /// PB_OFFSET + MNM_MARKET_DEPTH_BID_SIZE
1716    #[prost(int32, repeated, packed = "false", tag = "154283")]
1717    pub bid_size: ::prost::alloc::vec::Vec<i32>,
1718    /// PB_OFFSET + MNM_MARKET_DEPTH_BID_NO_OF_ORDERS
1719    #[prost(int32, repeated, packed = "false", tag = "154401")]
1720    pub bid_orders: ::prost::alloc::vec::Vec<i32>,
1721    /// PB_OFFSET + MNM_MARKET_DEPTH_IMPLICIT_BID_SIZE
1722    #[prost(int32, repeated, packed = "false", tag = "154412")]
1723    pub impl_bid_size: ::prost::alloc::vec::Vec<i32>,
1724    /// PB_OFFSET + MNM_MARKET_DEPTH_ASK_PRICE
1725    #[prost(double, repeated, packed = "false", tag = "154284")]
1726    pub ask_price: ::prost::alloc::vec::Vec<f64>,
1727    /// PB_OFFSET + MNM_MARKET_DEPTH_ASK_SIZE
1728    #[prost(int32, repeated, packed = "false", tag = "154285")]
1729    pub ask_size: ::prost::alloc::vec::Vec<i32>,
1730    /// PB_OFFSET + MNM_MARKET_DEPTH_ASK_NO_OF_ORDERS
1731    #[prost(int32, repeated, packed = "false", tag = "154402")]
1732    pub ask_orders: ::prost::alloc::vec::Vec<i32>,
1733    /// PB_OFFSET + MNM_MARKET_DEPTH_IMPLICIT_ASK_SIZE
1734    #[prost(int32, repeated, packed = "false", tag = "154415")]
1735    pub impl_ask_size: ::prost::alloc::vec::Vec<i32>,
1736    /// PB_OFFSET + MNM_SECONDS_SINCE_BOE
1737    #[prost(int32, optional, tag = "150100")]
1738    pub ssboe: ::core::option::Option<i32>,
1739    /// PB_OFFSET + MNM_USECS
1740    #[prost(int32, optional, tag = "150101")]
1741    pub usecs: ::core::option::Option<i32>,
1742}
1743/// Nested message and enum types in `OrderBook`.
1744pub mod order_book {
1745    /// below enum is just for reference only, not used in this message
1746    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
1747    #[repr(i32)]
1748    pub enum PresenceBits {
1749        Bid = 1,
1750        Ask = 2,
1751    }
1752    impl PresenceBits {
1753        /// String value of the enum field names used in the ProtoBuf definition.
1754        ///
1755        /// The values are not transformed in any way and thus are considered stable
1756        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
1757        pub fn as_str_name(&self) -> &'static str {
1758            match self {
1759                Self::Bid => "BID",
1760                Self::Ask => "ASK",
1761            }
1762        }
1763        /// Creates an enum from field names used in the ProtoBuf definition.
1764        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
1765            match value {
1766                "BID" => Some(Self::Bid),
1767                "ASK" => Some(Self::Ask),
1768                _ => None,
1769            }
1770        }
1771    }
1772    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
1773    #[repr(i32)]
1774    pub enum UpdateType {
1775        ClearOrderBook = 1,
1776        NoBook = 2,
1777        SnapshotImage = 3,
1778        Begin = 4,
1779        Middle = 5,
1780        End = 6,
1781        Solo = 7,
1782    }
1783    impl UpdateType {
1784        /// String value of the enum field names used in the ProtoBuf definition.
1785        ///
1786        /// The values are not transformed in any way and thus are considered stable
1787        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
1788        pub fn as_str_name(&self) -> &'static str {
1789            match self {
1790                Self::ClearOrderBook => "CLEAR_ORDER_BOOK",
1791                Self::NoBook => "NO_BOOK",
1792                Self::SnapshotImage => "SNAPSHOT_IMAGE",
1793                Self::Begin => "BEGIN",
1794                Self::Middle => "MIDDLE",
1795                Self::End => "END",
1796                Self::Solo => "SOLO",
1797            }
1798        }
1799        /// Creates an enum from field names used in the ProtoBuf definition.
1800        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
1801            match value {
1802                "CLEAR_ORDER_BOOK" => Some(Self::ClearOrderBook),
1803                "NO_BOOK" => Some(Self::NoBook),
1804                "SNAPSHOT_IMAGE" => Some(Self::SnapshotImage),
1805                "BEGIN" => Some(Self::Begin),
1806                "MIDDLE" => Some(Self::Middle),
1807                "END" => Some(Self::End),
1808                "SOLO" => Some(Self::Solo),
1809                _ => None,
1810            }
1811        }
1812    }
1813}
1814/// PB_OFFSET = 100000, is the offset added for each MNM field id
1815#[derive(Clone, PartialEq, ::prost::Message)]
1816pub struct LastTrade {
1817    /// PB_OFFSET + MNM_TEMPLATE_ID
1818    #[prost(int32, required, tag = "154467")]
1819    pub template_id: i32,
1820    /// PB_OFFSET + MNM_SYMBOL
1821    #[prost(string, optional, tag = "110100")]
1822    pub symbol: ::core::option::Option<::prost::alloc::string::String>,
1823    /// PB_OFFSET + MNM_EXCHANGE
1824    #[prost(string, optional, tag = "110101")]
1825    pub exchange: ::core::option::Option<::prost::alloc::string::String>,
1826    /// PB_OFFSET + MNM_PRICING_INDICATOR
1827    #[prost(uint32, optional, tag = "149138")]
1828    pub presence_bits: ::core::option::Option<u32>,
1829    /// PB_OFFSET + MNM_DISPLAY_INDICATOR
1830    #[prost(uint32, optional, tag = "154571")]
1831    pub clear_bits: ::core::option::Option<u32>,
1832    /// PB_OFFSET + MNM_UPDATE_TYPE
1833    #[prost(bool, optional, tag = "110121")]
1834    pub is_snapshot: ::core::option::Option<bool>,
1835    /// PB_OFFSET + MNM_TRADE_PRICE
1836    #[prost(double, optional, tag = "100006")]
1837    pub trade_price: ::core::option::Option<f64>,
1838    /// PB_OFFSET + MNM_TRADE_SIZE
1839    #[prost(int32, optional, tag = "100178")]
1840    pub trade_size: ::core::option::Option<i32>,
1841    /// PB_OFFSET + MNM_TRANSACTION_TYPE
1842    #[prost(enumeration = "last_trade::TransactionType", optional, tag = "112003")]
1843    pub aggressor: ::core::option::Option<i32>,
1844    /// PB_OFFSET + MNM_EXCH_ORD_ID
1845    #[prost(string, optional, tag = "149238")]
1846    pub exchange_order_id: ::core::option::Option<::prost::alloc::string::String>,
1847    /// PB_OFFSET + MNM_AGGRESSOR_EXCH_ORD_ID
1848    #[prost(string, optional, tag = "154641")]
1849    pub aggressor_exchange_order_id: ::core::option::Option<::prost::alloc::string::String>,
1850    /// PB_OFFSET + MNM_NET_CHANGE
1851    #[prost(double, optional, tag = "100011")]
1852    pub net_change: ::core::option::Option<f64>,
1853    /// PB_OFFSET + MNM_PERCENT_CHANGE
1854    #[prost(double, optional, tag = "100056")]
1855    pub percent_change: ::core::option::Option<f64>,
1856    /// PB_OFFSET + MNM_TRADE_VOLUME
1857    #[prost(uint64, optional, tag = "100032")]
1858    pub volume: ::core::option::Option<u64>,
1859    /// PB_OFFSET + MNM_VWAP
1860    #[prost(double, optional, tag = "101379")]
1861    pub vwap: ::core::option::Option<f64>,
1862    #[prost(string, optional, tag = "100379")]
1863    pub trade_time: ::core::option::Option<::prost::alloc::string::String>,
1864    /// PB_OFFSET + MNM_SECONDS_SINCE_BOE
1865    #[prost(int32, optional, tag = "150100")]
1866    pub ssboe: ::core::option::Option<i32>,
1867    /// PB_OFFSET + MNM_USECS
1868    #[prost(int32, optional, tag = "150101")]
1869    pub usecs: ::core::option::Option<i32>,
1870    /// PB_OFFSET + MNM_SOURCE_SSBOE
1871    #[prost(int32, optional, tag = "150400")]
1872    pub source_ssboe: ::core::option::Option<i32>,
1873    /// PB_OFFSET + MNM_SOURCE_USECS
1874    #[prost(int32, optional, tag = "150401")]
1875    pub source_usecs: ::core::option::Option<i32>,
1876    /// PB_OFFSET + MNM_SOURCE_NSECS
1877    #[prost(int32, optional, tag = "150404")]
1878    pub source_nsecs: ::core::option::Option<i32>,
1879    /// PB_OFFSET + MNM_JOP_SSBOE
1880    #[prost(int32, optional, tag = "150600")]
1881    pub jop_ssboe: ::core::option::Option<i32>,
1882    /// PB_OFFSET + MNM_JOP_NSECS
1883    #[prost(int32, optional, tag = "150604")]
1884    pub jop_nsecs: ::core::option::Option<i32>,
1885}
1886/// Nested message and enum types in `LastTrade`.
1887pub mod last_trade {
1888    /// below enum is just for reference only, not used in this message
1889    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
1890    #[repr(i32)]
1891    pub enum PresenceBits {
1892        LastTrade = 1,
1893        NetChange = 2,
1894        PrecentChange = 4,
1895        Volume = 8,
1896        Vwap = 16,
1897    }
1898    impl PresenceBits {
1899        /// String value of the enum field names used in the ProtoBuf definition.
1900        ///
1901        /// The values are not transformed in any way and thus are considered stable
1902        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
1903        pub fn as_str_name(&self) -> &'static str {
1904            match self {
1905                Self::LastTrade => "LAST_TRADE",
1906                Self::NetChange => "NET_CHANGE",
1907                Self::PrecentChange => "PRECENT_CHANGE",
1908                Self::Volume => "VOLUME",
1909                Self::Vwap => "VWAP",
1910            }
1911        }
1912        /// Creates an enum from field names used in the ProtoBuf definition.
1913        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
1914            match value {
1915                "LAST_TRADE" => Some(Self::LastTrade),
1916                "NET_CHANGE" => Some(Self::NetChange),
1917                "PRECENT_CHANGE" => Some(Self::PrecentChange),
1918                "VOLUME" => Some(Self::Volume),
1919                "VWAP" => Some(Self::Vwap),
1920                _ => None,
1921            }
1922        }
1923    }
1924    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
1925    #[repr(i32)]
1926    pub enum TransactionType {
1927        Buy = 1,
1928        Sell = 2,
1929    }
1930    impl TransactionType {
1931        /// String value of the enum field names used in the ProtoBuf definition.
1932        ///
1933        /// The values are not transformed in any way and thus are considered stable
1934        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
1935        pub fn as_str_name(&self) -> &'static str {
1936            match self {
1937                Self::Buy => "BUY",
1938                Self::Sell => "SELL",
1939            }
1940        }
1941        /// Creates an enum from field names used in the ProtoBuf definition.
1942        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
1943            match value {
1944                "BUY" => Some(Self::Buy),
1945                "SELL" => Some(Self::Sell),
1946                _ => None,
1947            }
1948        }
1949    }
1950}
1951/// PB_OFFSET = 100000, is the offset added for each MNM field id
1952#[derive(Clone, PartialEq, ::prost::Message)]
1953pub struct TradeStatistics {
1954    /// PB_OFFSET + MNM_TEMPLATE_ID
1955    #[prost(int32, required, tag = "154467")]
1956    pub template_id: i32,
1957    /// PB_OFFSET + MNM_SYMBOL
1958    #[prost(string, optional, tag = "110100")]
1959    pub symbol: ::core::option::Option<::prost::alloc::string::String>,
1960    /// PB_OFFSET + MNM_EXCHANGE
1961    #[prost(string, optional, tag = "110101")]
1962    pub exchange: ::core::option::Option<::prost::alloc::string::String>,
1963    /// PB_OFFSET + MNM_PRICING_INDICATOR
1964    #[prost(uint32, optional, tag = "149138")]
1965    pub presence_bits: ::core::option::Option<u32>,
1966    /// PB_OFFSET + MNM_DISPLAY_INDICATOR
1967    #[prost(uint32, optional, tag = "154571")]
1968    pub clear_bits: ::core::option::Option<u32>,
1969    /// PB_OFFSET + MNM_UPDATE_TYPE
1970    #[prost(bool, optional, tag = "110121")]
1971    pub is_snapshot: ::core::option::Option<bool>,
1972    /// PB_OFFSET + MNM_OPEN_PRICE
1973    #[prost(double, optional, tag = "100019")]
1974    pub open_price: ::core::option::Option<f64>,
1975    /// PB_OFFSET + MNM_HIGH_PRICE
1976    #[prost(double, optional, tag = "100012")]
1977    pub high_price: ::core::option::Option<f64>,
1978    /// PB_OFFSET + MNM_LOW_PRICE
1979    #[prost(double, optional, tag = "100013")]
1980    pub low_price: ::core::option::Option<f64>,
1981    /// PB_OFFSET + MNM_SECONDS_SINCE_BOE
1982    #[prost(int32, optional, tag = "150100")]
1983    pub ssboe: ::core::option::Option<i32>,
1984    /// PB_OFFSET + MNM_USECS
1985    #[prost(int32, optional, tag = "150101")]
1986    pub usecs: ::core::option::Option<i32>,
1987    /// PB_OFFSET + MNM_SOURCE_SSBOE
1988    #[prost(int32, optional, tag = "150400")]
1989    pub source_ssboe: ::core::option::Option<i32>,
1990    /// PB_OFFSET + MNM_SOURCE_USECS
1991    #[prost(int32, optional, tag = "150401")]
1992    pub source_usecs: ::core::option::Option<i32>,
1993    /// PB_OFFSET + MNM_SOURCE_NSECS
1994    #[prost(int32, optional, tag = "150404")]
1995    pub source_nsecs: ::core::option::Option<i32>,
1996    /// PB_OFFSET + MNM_JOP_SSBOE
1997    #[prost(int32, optional, tag = "150600")]
1998    pub jop_ssboe: ::core::option::Option<i32>,
1999    /// PB_OFFSET + MNM_JOP_NSECS
2000    #[prost(int32, optional, tag = "150604")]
2001    pub jop_nsecs: ::core::option::Option<i32>,
2002}
2003/// Nested message and enum types in `TradeStatistics`.
2004pub mod trade_statistics {
2005    /// below enum is just for reference only, not used in this message
2006    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
2007    #[repr(i32)]
2008    pub enum PresenceBits {
2009        Open = 1,
2010        High = 2,
2011        Low = 4,
2012    }
2013    impl PresenceBits {
2014        /// String value of the enum field names used in the ProtoBuf definition.
2015        ///
2016        /// The values are not transformed in any way and thus are considered stable
2017        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
2018        pub fn as_str_name(&self) -> &'static str {
2019            match self {
2020                Self::Open => "OPEN",
2021                Self::High => "HIGH",
2022                Self::Low => "LOW",
2023            }
2024        }
2025        /// Creates an enum from field names used in the ProtoBuf definition.
2026        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
2027            match value {
2028                "OPEN" => Some(Self::Open),
2029                "HIGH" => Some(Self::High),
2030                "LOW" => Some(Self::Low),
2031                _ => None,
2032            }
2033        }
2034    }
2035}
2036/// PB_OFFSET = 100000, is the offset added for each MNM field id
2037#[derive(Clone, PartialEq, ::prost::Message)]
2038pub struct QuoteStatistics {
2039    /// PB_OFFSET + MNM_TEMPLATE_ID
2040    #[prost(int32, required, tag = "154467")]
2041    pub template_id: i32,
2042    /// PB_OFFSET + MNM_SYMBOL
2043    #[prost(string, optional, tag = "110100")]
2044    pub symbol: ::core::option::Option<::prost::alloc::string::String>,
2045    /// PB_OFFSET + MNM_EXCHANGE
2046    #[prost(string, optional, tag = "110101")]
2047    pub exchange: ::core::option::Option<::prost::alloc::string::String>,
2048    /// PB_OFFSET + MNM_PRICING_INDICATOR
2049    #[prost(uint32, optional, tag = "149138")]
2050    pub presence_bits: ::core::option::Option<u32>,
2051    /// PB_OFFSET + MNM_DISPLAY_INDICATOR
2052    #[prost(uint32, optional, tag = "154571")]
2053    pub clear_bits: ::core::option::Option<u32>,
2054    /// PB_OFFSET + MNM_UPDATE_TYPE
2055    #[prost(bool, optional, tag = "110121")]
2056    pub is_snapshot: ::core::option::Option<bool>,
2057    /// PB_OFFSET + MNM_HIGHEST_BID_PRICE
2058    #[prost(double, optional, tag = "154195")]
2059    pub highest_bid_price: ::core::option::Option<f64>,
2060    /// PB_OFFSET + MNM_LOWEST_ASK_PRICE
2061    #[prost(double, optional, tag = "154197")]
2062    pub lowest_ask_price: ::core::option::Option<f64>,
2063    /// PB_OFFSET + MNM_SECONDS_SINCE_BOE
2064    #[prost(int32, optional, tag = "150100")]
2065    pub ssboe: ::core::option::Option<i32>,
2066    /// PB_OFFSET + MNM_USECS
2067    #[prost(int32, optional, tag = "150101")]
2068    pub usecs: ::core::option::Option<i32>,
2069}
2070/// Nested message and enum types in `QuoteStatistics`.
2071pub mod quote_statistics {
2072    /// below enum is just for reference only, not used in this message
2073    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
2074    #[repr(i32)]
2075    pub enum PresenceBits {
2076        HighestBid = 1,
2077        LowestAsk = 2,
2078    }
2079    impl PresenceBits {
2080        /// String value of the enum field names used in the ProtoBuf definition.
2081        ///
2082        /// The values are not transformed in any way and thus are considered stable
2083        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
2084        pub fn as_str_name(&self) -> &'static str {
2085            match self {
2086                Self::HighestBid => "HIGHEST_BID",
2087                Self::LowestAsk => "LOWEST_ASK",
2088            }
2089        }
2090        /// Creates an enum from field names used in the ProtoBuf definition.
2091        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
2092            match value {
2093                "HIGHEST_BID" => Some(Self::HighestBid),
2094                "LOWEST_ASK" => Some(Self::LowestAsk),
2095                _ => None,
2096            }
2097        }
2098    }
2099}
2100/// PB_OFFSET = 100000, is the offset added for each MNM field id
2101#[derive(Clone, PartialEq, ::prost::Message)]
2102pub struct IndicatorPrices {
2103    /// PB_OFFSET + MNM_TEMPLATE_ID
2104    #[prost(int32, required, tag = "154467")]
2105    pub template_id: i32,
2106    /// PB_OFFSET + MNM_SYMBOL
2107    #[prost(string, optional, tag = "110100")]
2108    pub symbol: ::core::option::Option<::prost::alloc::string::String>,
2109    /// PB_OFFSET + MNM_EXCHANGE
2110    #[prost(string, optional, tag = "110101")]
2111    pub exchange: ::core::option::Option<::prost::alloc::string::String>,
2112    /// PB_OFFSET + MNM_PRICING_INDICATOR
2113    #[prost(uint32, optional, tag = "149138")]
2114    pub presence_bits: ::core::option::Option<u32>,
2115    /// PB_OFFSET + MNM_DISPLAY_INDICATOR
2116    #[prost(uint32, optional, tag = "154571")]
2117    pub clear_bits: ::core::option::Option<u32>,
2118    /// PB_OFFSET + MNM_UPDATE_TYPE
2119    #[prost(bool, optional, tag = "110121")]
2120    pub is_snapshot: ::core::option::Option<bool>,
2121    /// PB_OFFSET + MNM_OPENING_INDICATOR
2122    #[prost(double, optional, tag = "154522")]
2123    pub opening_indicator: ::core::option::Option<f64>,
2124    /// PB_OFFSET + MNM_CLOSING_INDICATOR
2125    #[prost(double, optional, tag = "154064")]
2126    pub closing_indicator: ::core::option::Option<f64>,
2127    /// PB_OFFSET + MNM_SECONDS_SINCE_BOE
2128    #[prost(int32, optional, tag = "150100")]
2129    pub ssboe: ::core::option::Option<i32>,
2130    /// PB_OFFSET + MNM_USECS
2131    #[prost(int32, optional, tag = "150101")]
2132    pub usecs: ::core::option::Option<i32>,
2133}
2134/// Nested message and enum types in `IndicatorPrices`.
2135pub mod indicator_prices {
2136    /// below enum is just for reference only, not used in this message
2137    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
2138    #[repr(i32)]
2139    pub enum PresenceBits {
2140        OpeningIndicator = 1,
2141        ClosingIndicator = 2,
2142    }
2143    impl PresenceBits {
2144        /// String value of the enum field names used in the ProtoBuf definition.
2145        ///
2146        /// The values are not transformed in any way and thus are considered stable
2147        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
2148        pub fn as_str_name(&self) -> &'static str {
2149            match self {
2150                Self::OpeningIndicator => "OPENING_INDICATOR",
2151                Self::ClosingIndicator => "CLOSING_INDICATOR",
2152            }
2153        }
2154        /// Creates an enum from field names used in the ProtoBuf definition.
2155        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
2156            match value {
2157                "OPENING_INDICATOR" => Some(Self::OpeningIndicator),
2158                "CLOSING_INDICATOR" => Some(Self::ClosingIndicator),
2159                _ => None,
2160            }
2161        }
2162    }
2163}
2164/// PB_OFFSET = 100000, is the offset added for each MNM field id
2165#[derive(Clone, PartialEq, ::prost::Message)]
2166pub struct OpenInterest {
2167    /// PB_OFFSET + MNM_TEMPLATE_ID
2168    #[prost(int32, required, tag = "154467")]
2169    pub template_id: i32,
2170    /// PB_OFFSET + MNM_SYMBOL
2171    #[prost(string, optional, tag = "110100")]
2172    pub symbol: ::core::option::Option<::prost::alloc::string::String>,
2173    /// PB_OFFSET + MNM_EXCHANGE
2174    #[prost(string, optional, tag = "110101")]
2175    pub exchange: ::core::option::Option<::prost::alloc::string::String>,
2176    /// PB_OFFSET + MNM_UPDATE_TYPE
2177    #[prost(bool, optional, tag = "110121")]
2178    pub is_snapshot: ::core::option::Option<bool>,
2179    /// PB_OFFSET + MNM_DISPLAY_INDICATOR
2180    #[prost(bool, optional, tag = "154571")]
2181    pub should_clear: ::core::option::Option<bool>,
2182    /// PB_OFFSET + MNM_OPEN_INTEREST
2183    #[prost(uint64, optional, tag = "100064")]
2184    pub open_interest: ::core::option::Option<u64>,
2185    /// PB_OFFSET + MNM_SECONDS_SINCE_BOE
2186    #[prost(int32, optional, tag = "150100")]
2187    pub ssboe: ::core::option::Option<i32>,
2188    /// PB_OFFSET + MNM_USECS
2189    #[prost(int32, optional, tag = "150101")]
2190    pub usecs: ::core::option::Option<i32>,
2191}
2192#[derive(Clone, PartialEq, ::prost::Message)]
2193pub struct EndOfDayPrices {
2194    #[prost(int32, required, tag = "154467")]
2195    pub template_id: i32,
2196    #[prost(string, optional, tag = "110100")]
2197    pub symbol: ::core::option::Option<::prost::alloc::string::String>,
2198    #[prost(string, optional, tag = "110101")]
2199    pub exchange: ::core::option::Option<::prost::alloc::string::String>,
2200    #[prost(uint32, optional, tag = "149138")]
2201    pub presence_bits: ::core::option::Option<u32>,
2202    #[prost(uint32, optional, tag = "154571")]
2203    pub clear_bits: ::core::option::Option<u32>,
2204    #[prost(bool, optional, tag = "110121")]
2205    pub is_snapshot: ::core::option::Option<bool>,
2206    #[prost(double, optional, tag = "100021")]
2207    pub close_price: ::core::option::Option<f64>,
2208    #[prost(string, optional, tag = "100079")]
2209    pub close_date: ::core::option::Option<::prost::alloc::string::String>,
2210    #[prost(double, optional, tag = "154124")]
2211    pub adjusted_close_price: ::core::option::Option<f64>,
2212    #[prost(double, optional, tag = "100070")]
2213    pub settlement_price: ::core::option::Option<f64>,
2214    #[prost(string, optional, tag = "154132")]
2215    pub settlement_date: ::core::option::Option<::prost::alloc::string::String>,
2216    #[prost(string, optional, tag = "154637")]
2217    pub settlement_price_type: ::core::option::Option<::prost::alloc::string::String>,
2218    #[prost(double, optional, tag = "155005")]
2219    pub projected_settlement_price: ::core::option::Option<f64>,
2220    #[prost(int32, optional, tag = "150100")]
2221    pub ssboe: ::core::option::Option<i32>,
2222    #[prost(int32, optional, tag = "150101")]
2223    pub usecs: ::core::option::Option<i32>,
2224}
2225/// Nested message and enum types in `EndOfDayPrices`.
2226pub mod end_of_day_prices {
2227    /// below enum is just for reference only, not used in this message
2228    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
2229    #[repr(i32)]
2230    pub enum PresenceBits {
2231        Close = 1,
2232        Settlement = 2,
2233        ProjectedSettlement = 4,
2234        AdjustedClose = 8,
2235    }
2236    impl PresenceBits {
2237        /// String value of the enum field names used in the ProtoBuf definition.
2238        ///
2239        /// The values are not transformed in any way and thus are considered stable
2240        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
2241        pub fn as_str_name(&self) -> &'static str {
2242            match self {
2243                Self::Close => "CLOSE",
2244                Self::Settlement => "SETTLEMENT",
2245                Self::ProjectedSettlement => "PROJECTED_SETTLEMENT",
2246                Self::AdjustedClose => "ADJUSTED_CLOSE",
2247            }
2248        }
2249        /// Creates an enum from field names used in the ProtoBuf definition.
2250        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
2251            match value {
2252                "CLOSE" => Some(Self::Close),
2253                "SETTLEMENT" => Some(Self::Settlement),
2254                "PROJECTED_SETTLEMENT" => Some(Self::ProjectedSettlement),
2255                "ADJUSTED_CLOSE" => Some(Self::AdjustedClose),
2256                _ => None,
2257            }
2258        }
2259    }
2260}
2261#[derive(Clone, PartialEq, ::prost::Message)]
2262pub struct MarketMode {
2263    #[prost(int32, required, tag = "154467")]
2264    pub template_id: i32,
2265    #[prost(string, optional, tag = "110100")]
2266    pub symbol: ::core::option::Option<::prost::alloc::string::String>,
2267    #[prost(string, optional, tag = "110101")]
2268    pub exchange: ::core::option::Option<::prost::alloc::string::String>,
2269    #[prost(string, optional, tag = "154106")]
2270    pub market_mode: ::core::option::Option<::prost::alloc::string::String>,
2271    #[prost(string, optional, tag = "154838")]
2272    pub halt_reason: ::core::option::Option<::prost::alloc::string::String>,
2273    #[prost(string, optional, tag = "100016")]
2274    pub trade_date: ::core::option::Option<::prost::alloc::string::String>,
2275    #[prost(int32, optional, tag = "150100")]
2276    pub ssboe: ::core::option::Option<i32>,
2277    #[prost(int32, optional, tag = "150101")]
2278    pub usecs: ::core::option::Option<i32>,
2279}
2280/// PB_OFFSET = 100000, is the offset added for each MNM field id
2281#[derive(Clone, PartialEq, ::prost::Message)]
2282pub struct FrontMonthContractUpdate {
2283    /// PB_OFFSET + MNM_TEMPLATE_ID
2284    #[prost(int32, required, tag = "154467")]
2285    pub template_id: i32,
2286    /// PB_OFFSET + MNM_SYMBOL
2287    #[prost(string, optional, tag = "110100")]
2288    pub symbol: ::core::option::Option<::prost::alloc::string::String>,
2289    /// PB_OFFSET + MNM_EXCHANGE
2290    #[prost(string, optional, tag = "110101")]
2291    pub exchange: ::core::option::Option<::prost::alloc::string::String>,
2292    /// PB_OFFSET + MNM_STATUS_INDICATOR
2293    #[prost(bool, optional, tag = "149166")]
2294    pub is_front_month_symbol: ::core::option::Option<bool>,
2295    /// PB_OFFSET + MNM_SYMBOL_NAME
2296    #[prost(string, optional, tag = "100003")]
2297    pub symbol_name: ::core::option::Option<::prost::alloc::string::String>,
2298    /// PB_OFFSET + MNM_TRADING_SYMBOL
2299    #[prost(string, optional, tag = "157095")]
2300    pub trading_symbol: ::core::option::Option<::prost::alloc::string::String>,
2301    /// PB_OFFSET + MNM_TRADING_EXCHANGE
2302    #[prost(string, optional, tag = "157096")]
2303    pub trading_exchange: ::core::option::Option<::prost::alloc::string::String>,
2304}
2305/// PB_OFFSET = 100000 , is the offset added for each MNM field id
2306#[derive(Clone, PartialEq, ::prost::Message)]
2307pub struct DepthByOrder {
2308    /// PB_OFFSET + MNM_TEMPLATE_ID
2309    #[prost(int32, required, tag = "154467")]
2310    pub template_id: i32,
2311    /// PB_OFFSET + MNM_SYMBOL
2312    #[prost(string, optional, tag = "110100")]
2313    pub symbol: ::core::option::Option<::prost::alloc::string::String>,
2314    /// PB_OFFSET + MNM_EXCHANGE
2315    #[prost(string, optional, tag = "110101")]
2316    pub exchange: ::core::option::Option<::prost::alloc::string::String>,
2317    /// PB_OFFSET + MNM_SEQUENCE_NUMBER
2318    #[prost(uint64, optional, tag = "112002")]
2319    pub sequence_number: ::core::option::Option<u64>,
2320    /// PB_OFFSET + MNM_UPDATE_TYPE
2321    #[prost(
2322        enumeration = "depth_by_order::UpdateType",
2323        repeated,
2324        packed = "false",
2325        tag = "110121"
2326    )]
2327    pub update_type: ::prost::alloc::vec::Vec<i32>,
2328    /// PB_OFFSET + MNM_MARKET_DEPTH_SIDE
2329    #[prost(
2330        enumeration = "depth_by_order::TransactionType",
2331        repeated,
2332        packed = "false",
2333        tag = "153612"
2334    )]
2335    pub transaction_type: ::prost::alloc::vec::Vec<i32>,
2336    /// PB_OFFSET + MNM_MARKET_DEPTH_PRICE
2337    #[prost(double, repeated, packed = "false", tag = "154405")]
2338    pub depth_price: ::prost::alloc::vec::Vec<f64>,
2339    /// PB_OFFSET + MNM_PREVIOUS_MARKET_DEPTH_PRICE
2340    #[prost(double, repeated, packed = "false", tag = "154906")]
2341    pub prev_depth_price: ::prost::alloc::vec::Vec<f64>,
2342    /// PB_OFFSET + MNM_PREVIOUS_MARKET_DEPTH_PRICE_FLAG
2343    #[prost(bool, repeated, packed = "false", tag = "154930")]
2344    pub prev_depth_price_flag: ::prost::alloc::vec::Vec<bool>,
2345    /// PB_OFFSET + MNM_MARKET_DEPTH_SIZE
2346    #[prost(int32, repeated, packed = "false", tag = "154406")]
2347    pub depth_size: ::prost::alloc::vec::Vec<i32>,
2348    /// PB_OFFSET + MNM_MARKET_DEPTH_ORDER_PRIORITY
2349    #[prost(uint64, repeated, packed = "false", tag = "153613")]
2350    pub depth_order_priority: ::prost::alloc::vec::Vec<u64>,
2351    /// PB_OFFSET + MNM_EXCH_ORD_ID
2352    #[prost(string, repeated, tag = "149238")]
2353    pub exchange_order_id: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
2354    /// PB_OFFSET + MNM_SECONDS_SINCE_BOE
2355    #[prost(int32, optional, tag = "150100")]
2356    pub ssboe: ::core::option::Option<i32>,
2357    /// PB_OFFSET + MNM_USECS
2358    #[prost(int32, optional, tag = "150101")]
2359    pub usecs: ::core::option::Option<i32>,
2360    /// PB_OFFSET + MNM_SOURCE_SSBOE
2361    #[prost(int32, optional, tag = "150400")]
2362    pub source_ssboe: ::core::option::Option<i32>,
2363    /// PB_OFFSET + MNM_SOURCE_USECS
2364    #[prost(int32, optional, tag = "150401")]
2365    pub source_usecs: ::core::option::Option<i32>,
2366    /// PB_OFFSET + MNM_SOURCE_NSECS
2367    #[prost(int32, optional, tag = "150404")]
2368    pub source_nsecs: ::core::option::Option<i32>,
2369    /// PB_OFFSET + MNM_JOP_SSBOE
2370    #[prost(int32, optional, tag = "150600")]
2371    pub jop_ssboe: ::core::option::Option<i32>,
2372    /// PB_OFFSET + MNM_JOP_NSECS
2373    #[prost(int32, optional, tag = "150604")]
2374    pub jop_nsecs: ::core::option::Option<i32>,
2375}
2376/// Nested message and enum types in `DepthByOrder`.
2377pub mod depth_by_order {
2378    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
2379    #[repr(i32)]
2380    pub enum TransactionType {
2381        Buy = 1,
2382        Sell = 2,
2383    }
2384    impl TransactionType {
2385        /// String value of the enum field names used in the ProtoBuf definition.
2386        ///
2387        /// The values are not transformed in any way and thus are considered stable
2388        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
2389        pub fn as_str_name(&self) -> &'static str {
2390            match self {
2391                Self::Buy => "BUY",
2392                Self::Sell => "SELL",
2393            }
2394        }
2395        /// Creates an enum from field names used in the ProtoBuf definition.
2396        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
2397            match value {
2398                "BUY" => Some(Self::Buy),
2399                "SELL" => Some(Self::Sell),
2400                _ => None,
2401            }
2402        }
2403    }
2404    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
2405    #[repr(i32)]
2406    pub enum UpdateType {
2407        New = 1,
2408        Change = 2,
2409        Delete = 3,
2410    }
2411    impl UpdateType {
2412        /// String value of the enum field names used in the ProtoBuf definition.
2413        ///
2414        /// The values are not transformed in any way and thus are considered stable
2415        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
2416        pub fn as_str_name(&self) -> &'static str {
2417            match self {
2418                Self::New => "NEW",
2419                Self::Change => "CHANGE",
2420                Self::Delete => "DELETE",
2421            }
2422        }
2423        /// Creates an enum from field names used in the ProtoBuf definition.
2424        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
2425            match value {
2426                "NEW" => Some(Self::New),
2427                "CHANGE" => Some(Self::Change),
2428                "DELETE" => Some(Self::Delete),
2429                _ => None,
2430            }
2431        }
2432    }
2433}
2434/// PB_OFFSET = 100000 , is the offset added for each MNM field id
2435#[derive(Clone, PartialEq, ::prost::Message)]
2436pub struct DepthByOrderEndEvent {
2437    /// PB_OFFSET + MNM_TEMPLATE_ID
2438    #[prost(int32, required, tag = "154467")]
2439    pub template_id: i32,
2440    /// PB_OFFSET + MNM_SYMBOL
2441    #[prost(string, repeated, tag = "110100")]
2442    pub symbol: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
2443    /// PB_OFFSET + MNM_EXCHANGE
2444    #[prost(string, repeated, tag = "110101")]
2445    pub exchange: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
2446    /// PB_OFFSET + MNM_SEQUENCE_NUMBER
2447    #[prost(uint64, optional, tag = "112002")]
2448    pub sequence_number: ::core::option::Option<u64>,
2449    /// PB_OFFSET + MNM_SECONDS_SINCE_BOE
2450    #[prost(int32, optional, tag = "150100")]
2451    pub ssboe: ::core::option::Option<i32>,
2452    /// PB_OFFSET + MNM_USECS
2453    #[prost(int32, optional, tag = "150101")]
2454    pub usecs: ::core::option::Option<i32>,
2455}
2456/// PB_OFFSET = 100000, is the offset added for each MNM field id
2457#[derive(Clone, PartialEq, ::prost::Message)]
2458pub struct SymbolMarginRate {
2459    /// PB_OFFSET + MNM_TEMPLATE_ID
2460    #[prost(int32, required, tag = "154467")]
2461    pub template_id: i32,
2462    /// PB_OFFSET + MNM_SYMBOL
2463    #[prost(string, optional, tag = "110100")]
2464    pub symbol: ::core::option::Option<::prost::alloc::string::String>,
2465    /// PB_OFFSET + MNM_EXCHANGE
2466    #[prost(string, optional, tag = "110101")]
2467    pub exchange: ::core::option::Option<::prost::alloc::string::String>,
2468    /// PB_OFFSET + MNM_UPDATE_TYPE
2469    #[prost(bool, optional, tag = "110121")]
2470    pub is_snapshot: ::core::option::Option<bool>,
2471    /// PB_OFFSET + MNM_MARGIN_RATE
2472    #[prost(double, optional, tag = "154103")]
2473    pub margin_rate: ::core::option::Option<f64>,
2474}
2475/// PB_OFFSET = 100000, is the offset added for each MNM field id
2476#[derive(Clone, PartialEq, ::prost::Message)]
2477pub struct OrderPriceLimits {
2478    /// PB_OFFSET + MNM_TEMPLATE_ID
2479    #[prost(int32, required, tag = "154467")]
2480    pub template_id: i32,
2481    /// PB_OFFSET + MNM_SYMBOL
2482    #[prost(string, optional, tag = "110100")]
2483    pub symbol: ::core::option::Option<::prost::alloc::string::String>,
2484    /// PB_OFFSET + MNM_EXCHANGE
2485    #[prost(string, optional, tag = "110101")]
2486    pub exchange: ::core::option::Option<::prost::alloc::string::String>,
2487    /// PB_OFFSET + MNM_PRICING_INDICATOR
2488    #[prost(uint32, optional, tag = "149138")]
2489    pub presence_bits: ::core::option::Option<u32>,
2490    /// PB_OFFSET + MNM_DISPLAY_INDICATOR
2491    #[prost(uint32, optional, tag = "154571")]
2492    pub clear_bits: ::core::option::Option<u32>,
2493    /// PB_OFFSET + MNM_UPDATE_TYPE
2494    #[prost(bool, optional, tag = "110121")]
2495    pub is_snapshot: ::core::option::Option<bool>,
2496    /// PB_OFFSET + MNM_HIGH_PRICE_LIMIT
2497    #[prost(double, optional, tag = "154079")]
2498    pub high_price_limit: ::core::option::Option<f64>,
2499    /// PB_OFFSET + MNM_LOW_PRICE_LIMIT
2500    #[prost(double, optional, tag = "154101")]
2501    pub low_price_limit: ::core::option::Option<f64>,
2502    /// PB_OFFSET + MNM_SECONDS_SINCE_BOE
2503    #[prost(int32, optional, tag = "150100")]
2504    pub ssboe: ::core::option::Option<i32>,
2505    /// PB_OFFSET + MNM_USECS
2506    #[prost(int32, optional, tag = "150101")]
2507    pub usecs: ::core::option::Option<i32>,
2508}
2509/// Nested message and enum types in `OrderPriceLimits`.
2510pub mod order_price_limits {
2511    /// below enum is just for reference only, not used in this message
2512    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
2513    #[repr(i32)]
2514    pub enum PresenceBits {
2515        HighPriceLimit = 1,
2516        LowPriceLimit = 2,
2517    }
2518    impl PresenceBits {
2519        /// String value of the enum field names used in the ProtoBuf definition.
2520        ///
2521        /// The values are not transformed in any way and thus are considered stable
2522        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
2523        pub fn as_str_name(&self) -> &'static str {
2524            match self {
2525                Self::HighPriceLimit => "HIGH_PRICE_LIMIT",
2526                Self::LowPriceLimit => "LOW_PRICE_LIMIT",
2527            }
2528        }
2529        /// Creates an enum from field names used in the ProtoBuf definition.
2530        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
2531            match value {
2532                "HIGH_PRICE_LIMIT" => Some(Self::HighPriceLimit),
2533                "LOW_PRICE_LIMIT" => Some(Self::LowPriceLimit),
2534                _ => None,
2535            }
2536        }
2537    }
2538}
2539/// PB_OFFSET = 100000 , is the offset added for each MNM field id
2540#[derive(Clone, PartialEq, ::prost::Message)]
2541pub struct RequestLoginInfo {
2542    /// PB_OFFSET + MNM_TEMPLATE_ID
2543    #[prost(int32, required, tag = "154467")]
2544    pub template_id: i32,
2545    /// PB_OFFSET + MNM_USER_MSG
2546    #[prost(string, repeated, tag = "132760")]
2547    pub user_msg: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
2548}
2549/// PB_OFFSET = 100000, is the offset added for each MNM field id
2550#[derive(Clone, PartialEq, ::prost::Message)]
2551pub struct ResponseLoginInfo {
2552    /// PB_OFFSET + MNM_TEMPLATE_ID
2553    #[prost(int32, required, tag = "154467")]
2554    pub template_id: i32,
2555    /// PB_OFFSET + MNM_USER_MSG
2556    #[prost(string, repeated, tag = "132760")]
2557    pub user_msg: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
2558    /// PB_OFFSET + MNM_RESPONSE_CODE
2559    #[prost(string, repeated, tag = "132766")]
2560    pub rp_code: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
2561    /// PB_OFFSET + MNM_FCM_ID
2562    #[prost(string, optional, tag = "154013")]
2563    pub fcm_id: ::core::option::Option<::prost::alloc::string::String>,
2564    /// PB_OFFSET + MNM_IB_ID
2565    #[prost(string, optional, tag = "154014")]
2566    pub ib_id: ::core::option::Option<::prost::alloc::string::String>,
2567    /// PB_OFFSET + MNM_FIRST_NAME
2568    #[prost(string, optional, tag = "154216")]
2569    pub first_name: ::core::option::Option<::prost::alloc::string::String>,
2570    /// PB_OFFSET + MNM_LAST_NAME
2571    #[prost(string, optional, tag = "154217")]
2572    pub last_name: ::core::option::Option<::prost::alloc::string::String>,
2573    /// PB_OFFSET + MNM_USER_TYPE
2574    #[prost(
2575        enumeration = "response_login_info::UserType",
2576        optional,
2577        tag = "154036"
2578    )]
2579    pub user_type: ::core::option::Option<i32>,
2580}
2581/// Nested message and enum types in `ResponseLoginInfo`.
2582pub mod response_login_info {
2583    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
2584    #[repr(i32)]
2585    pub enum UserType {
2586        Admin = 0,
2587        Fcm = 1,
2588        Ib = 2,
2589        Trader = 3,
2590    }
2591    impl UserType {
2592        /// String value of the enum field names used in the ProtoBuf definition.
2593        ///
2594        /// The values are not transformed in any way and thus are considered stable
2595        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
2596        pub fn as_str_name(&self) -> &'static str {
2597            match self {
2598                Self::Admin => "USER_TYPE_ADMIN",
2599                Self::Fcm => "USER_TYPE_FCM",
2600                Self::Ib => "USER_TYPE_IB",
2601                Self::Trader => "USER_TYPE_TRADER",
2602            }
2603        }
2604        /// Creates an enum from field names used in the ProtoBuf definition.
2605        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
2606            match value {
2607                "USER_TYPE_ADMIN" => Some(Self::Admin),
2608                "USER_TYPE_FCM" => Some(Self::Fcm),
2609                "USER_TYPE_IB" => Some(Self::Ib),
2610                "USER_TYPE_TRADER" => Some(Self::Trader),
2611                _ => None,
2612            }
2613        }
2614    }
2615}
2616/// PB_OFFSET = 100000, is the offset added for each MNM field id
2617#[derive(Clone, PartialEq, ::prost::Message)]
2618pub struct RequestAccountList {
2619    /// PB_OFFSET + MNM_TEMPLATE_ID
2620    #[prost(int32, required, tag = "154467")]
2621    pub template_id: i32,
2622    /// PB_OFFSET + MNM_USER_MSG
2623    #[prost(string, repeated, tag = "132760")]
2624    pub user_msg: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
2625    /// PB_OFFSET + MNM_FCM_ID
2626    #[prost(string, optional, tag = "154013")]
2627    pub fcm_id: ::core::option::Option<::prost::alloc::string::String>,
2628    /// PB_OFFSET + MNM_IB_ID
2629    #[prost(string, optional, tag = "154014")]
2630    pub ib_id: ::core::option::Option<::prost::alloc::string::String>,
2631    /// PB_OFFSET + MNM_USER_TYPE
2632    #[prost(
2633        enumeration = "request_account_list::UserType",
2634        optional,
2635        tag = "154036"
2636    )]
2637    pub user_type: ::core::option::Option<i32>,
2638}
2639/// Nested message and enum types in `RequestAccountList`.
2640pub mod request_account_list {
2641    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
2642    #[repr(i32)]
2643    pub enum UserType {
2644        Fcm = 1,
2645        Ib = 2,
2646        Trader = 3,
2647    }
2648    impl UserType {
2649        /// String value of the enum field names used in the ProtoBuf definition.
2650        ///
2651        /// The values are not transformed in any way and thus are considered stable
2652        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
2653        pub fn as_str_name(&self) -> &'static str {
2654            match self {
2655                Self::Fcm => "USER_TYPE_FCM",
2656                Self::Ib => "USER_TYPE_IB",
2657                Self::Trader => "USER_TYPE_TRADER",
2658            }
2659        }
2660        /// Creates an enum from field names used in the ProtoBuf definition.
2661        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
2662            match value {
2663                "USER_TYPE_FCM" => Some(Self::Fcm),
2664                "USER_TYPE_IB" => Some(Self::Ib),
2665                "USER_TYPE_TRADER" => Some(Self::Trader),
2666                _ => None,
2667            }
2668        }
2669    }
2670}
2671#[derive(Clone, PartialEq, ::prost::Message)]
2672pub struct ResponseAccountList {
2673    #[prost(int32, required, tag = "154467")]
2674    pub template_id: i32,
2675    #[prost(string, repeated, tag = "132760")]
2676    pub user_msg: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
2677    #[prost(string, repeated, tag = "132764")]
2678    pub rq_handler_rp_code: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
2679    #[prost(string, repeated, tag = "132766")]
2680    pub rp_code: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
2681    #[prost(string, optional, tag = "154013")]
2682    pub fcm_id: ::core::option::Option<::prost::alloc::string::String>,
2683    #[prost(string, optional, tag = "154014")]
2684    pub ib_id: ::core::option::Option<::prost::alloc::string::String>,
2685    #[prost(string, optional, tag = "154008")]
2686    pub account_id: ::core::option::Option<::prost::alloc::string::String>,
2687    #[prost(string, optional, tag = "154002")]
2688    pub account_name: ::core::option::Option<::prost::alloc::string::String>,
2689    #[prost(string, optional, tag = "154383")]
2690    pub account_currency: ::core::option::Option<::prost::alloc::string::String>,
2691    #[prost(string, optional, tag = "131035")]
2692    pub account_auto_liquidate: ::core::option::Option<::prost::alloc::string::String>,
2693    #[prost(string, optional, tag = "131040")]
2694    pub auto_liq_threshold_current_value: ::core::option::Option<::prost::alloc::string::String>,
2695}
2696/// PB_OFFSET = 100000, is the offset added for each MNM field id
2697#[derive(Clone, PartialEq, ::prost::Message)]
2698pub struct RequestAccountRmsInfo {
2699    /// PB_OFFSET + MNM_TEMPLATE_ID
2700    #[prost(int32, required, tag = "154467")]
2701    pub template_id: i32,
2702    /// PB_OFFSET + MNM_USER_MSG
2703    #[prost(string, repeated, tag = "132760")]
2704    pub user_msg: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
2705    /// PB_OFFSET + MNM_FCM_ID
2706    #[prost(string, optional, tag = "154013")]
2707    pub fcm_id: ::core::option::Option<::prost::alloc::string::String>,
2708    /// PB_OFFSET + MNM_IB_ID
2709    #[prost(string, optional, tag = "154014")]
2710    pub ib_id: ::core::option::Option<::prost::alloc::string::String>,
2711    /// PB_OFFSET + MNM_USER_TYPE
2712    #[prost(
2713        enumeration = "request_account_rms_info::UserType",
2714        optional,
2715        tag = "154036"
2716    )]
2717    pub user_type: ::core::option::Option<i32>,
2718}
2719/// Nested message and enum types in `RequestAccountRmsInfo`.
2720pub mod request_account_rms_info {
2721    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
2722    #[repr(i32)]
2723    pub enum UserType {
2724        Fcm = 1,
2725        Ib = 2,
2726        Trader = 3,
2727    }
2728    impl UserType {
2729        /// String value of the enum field names used in the ProtoBuf definition.
2730        ///
2731        /// The values are not transformed in any way and thus are considered stable
2732        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
2733        pub fn as_str_name(&self) -> &'static str {
2734            match self {
2735                Self::Fcm => "USER_TYPE_FCM",
2736                Self::Ib => "USER_TYPE_IB",
2737                Self::Trader => "USER_TYPE_TRADER",
2738            }
2739        }
2740        /// Creates an enum from field names used in the ProtoBuf definition.
2741        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
2742            match value {
2743                "USER_TYPE_FCM" => Some(Self::Fcm),
2744                "USER_TYPE_IB" => Some(Self::Ib),
2745                "USER_TYPE_TRADER" => Some(Self::Trader),
2746                _ => None,
2747            }
2748        }
2749    }
2750}
2751/// PB_OFFSET = 100000, is the offset added for each MNM field id
2752#[derive(Clone, PartialEq, ::prost::Message)]
2753pub struct ResponseAccountRmsInfo {
2754    /// PB_OFFSET + MNM_TEMPLATE_ID
2755    #[prost(int32, required, tag = "154467")]
2756    pub template_id: i32,
2757    /// PB_OFFSET + MNM_USER_MSG
2758    #[prost(string, repeated, tag = "132760")]
2759    pub user_msg: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
2760    /// PB_OFFSET + MNM_REQUEST_HANDLER_RESPONSE_CODE
2761    #[prost(string, repeated, tag = "132764")]
2762    pub rq_handler_rp_code: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
2763    /// PB_OFFSET + MNM_RESPONSE_CODE
2764    #[prost(string, repeated, tag = "132766")]
2765    pub rp_code: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
2766    /// PB_OFFSET + MNM_FIELD_PRESENCE_BITS
2767    #[prost(uint32, optional, tag = "153622")]
2768    pub presence_bits: ::core::option::Option<u32>,
2769    /// PB_OFFSET + MNM_FCM_ID
2770    #[prost(string, optional, tag = "154013")]
2771    pub fcm_id: ::core::option::Option<::prost::alloc::string::String>,
2772    /// PB_OFFSET + MNM_IB_ID
2773    #[prost(string, optional, tag = "154014")]
2774    pub ib_id: ::core::option::Option<::prost::alloc::string::String>,
2775    /// PB_OFFSET + MNM_ACCOUNT_ID
2776    #[prost(string, optional, tag = "154008")]
2777    pub account_id: ::core::option::Option<::prost::alloc::string::String>,
2778    /// PB_OFFSET + MNM_ACCOUNT_CURRENCY
2779    #[prost(string, optional, tag = "154383")]
2780    pub currency: ::core::option::Option<::prost::alloc::string::String>,
2781    /// PB_OFFSET + MNM_ACCOUNT_STATUS
2782    #[prost(string, optional, tag = "154003")]
2783    pub status: ::core::option::Option<::prost::alloc::string::String>,
2784    /// PB_OFFSET + MNM_ALGORITHM
2785    #[prost(string, optional, tag = "150142")]
2786    pub algorithm: ::core::option::Option<::prost::alloc::string::String>,
2787    /// PB_OFFSET + MNM_ACCOUNT_AUTO_LIQUIDATE_CRITERIA
2788    #[prost(string, optional, tag = "131036")]
2789    pub auto_liquidate_criteria: ::core::option::Option<::prost::alloc::string::String>,
2790    /// PB_OFFSET + MNM_ACCOUNT_AUTO_LIQUIDATE
2791    #[prost(
2792        enumeration = "response_account_rms_info::AutoLiquidateFlag",
2793        optional,
2794        tag = "131035"
2795    )]
2796    pub auto_liquidate: ::core::option::Option<i32>,
2797    /// PB_OFFSET + MNM_DISABLE_ON_AUTO_LIQUIDATE_FLAG
2798    #[prost(
2799        enumeration = "response_account_rms_info::AutoLiquidateFlag",
2800        optional,
2801        tag = "131038"
2802    )]
2803    pub disable_on_auto_liquidate: ::core::option::Option<i32>,
2804    /// PB_OFFSET + MNM_ACCOUNT_AUTO_LIQUIDATE_THRESHOLD
2805    #[prost(double, optional, tag = "131037")]
2806    pub auto_liquidate_threshold: ::core::option::Option<f64>,
2807    /// PB_OFFSET + MNM_AUTO_LIQ_MAX_MIN_ACCOUNT_BALANCE
2808    #[prost(double, optional, tag = "131039")]
2809    pub auto_liquidate_max_min_account_balance: ::core::option::Option<f64>,
2810    /// PB_OFFSET + MNM_LOSS_LIMIT
2811    #[prost(double, optional, tag = "154019")]
2812    pub loss_limit: ::core::option::Option<f64>,
2813    /// PB_OFFSET + MNM_MINIMUM_ACCOUNT_BALANCE
2814    #[prost(double, optional, tag = "156968")]
2815    pub min_account_balance: ::core::option::Option<f64>,
2816    /// PB_OFFSET + MNM_MIN_MARGIN_BALANCE
2817    #[prost(double, optional, tag = "156976")]
2818    pub min_margin_balance: ::core::option::Option<f64>,
2819    /// PB_OFFSET + MNM_DEFAULT_COMMISSION
2820    #[prost(double, optional, tag = "153368")]
2821    pub default_commission: ::core::option::Option<f64>,
2822    /// PB_OFFSET + MNM_BUY_LIMIT
2823    #[prost(int32, optional, tag = "154009")]
2824    pub buy_limit: ::core::option::Option<i32>,
2825    /// PB_OFFSET + MNM_MAX_LIMIT_QUAN
2826    #[prost(int32, optional, tag = "110105")]
2827    pub max_order_quantity: ::core::option::Option<i32>,
2828    /// PB_OFFSET + MNM_SELL_LIMIT
2829    #[prost(int32, optional, tag = "154035")]
2830    pub sell_limit: ::core::option::Option<i32>,
2831    /// PB_OFFSET + MNM_CHECK_MIN_ACCT_BALANCE
2832    #[prost(bool, optional, tag = "156972")]
2833    pub check_min_account_balance: ::core::option::Option<bool>,
2834}
2835/// Nested message and enum types in `ResponseAccountRmsInfo`.
2836pub mod response_account_rms_info {
2837    /// below enum is just for reference only, not used in this message
2838    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
2839    #[repr(i32)]
2840    pub enum PresenceBits {
2841        BuyLimit = 1,
2842        SellLimit = 2,
2843        LossLimit = 4,
2844        MaxOrderQuantity = 8,
2845        MinAccountBalance = 16,
2846        MinMarginBalance = 32,
2847        Algorithm = 64,
2848        Status = 128,
2849        Currency = 256,
2850        DefaultCommission = 512,
2851    }
2852    impl PresenceBits {
2853        /// String value of the enum field names used in the ProtoBuf definition.
2854        ///
2855        /// The values are not transformed in any way and thus are considered stable
2856        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
2857        pub fn as_str_name(&self) -> &'static str {
2858            match self {
2859                Self::BuyLimit => "BUY_LIMIT",
2860                Self::SellLimit => "SELL_LIMIT",
2861                Self::LossLimit => "LOSS_LIMIT",
2862                Self::MaxOrderQuantity => "MAX_ORDER_QUANTITY",
2863                Self::MinAccountBalance => "MIN_ACCOUNT_BALANCE",
2864                Self::MinMarginBalance => "MIN_MARGIN_BALANCE",
2865                Self::Algorithm => "ALGORITHM",
2866                Self::Status => "STATUS",
2867                Self::Currency => "CURRENCY",
2868                Self::DefaultCommission => "DEFAULT_COMMISSION",
2869            }
2870        }
2871        /// Creates an enum from field names used in the ProtoBuf definition.
2872        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
2873            match value {
2874                "BUY_LIMIT" => Some(Self::BuyLimit),
2875                "SELL_LIMIT" => Some(Self::SellLimit),
2876                "LOSS_LIMIT" => Some(Self::LossLimit),
2877                "MAX_ORDER_QUANTITY" => Some(Self::MaxOrderQuantity),
2878                "MIN_ACCOUNT_BALANCE" => Some(Self::MinAccountBalance),
2879                "MIN_MARGIN_BALANCE" => Some(Self::MinMarginBalance),
2880                "ALGORITHM" => Some(Self::Algorithm),
2881                "STATUS" => Some(Self::Status),
2882                "CURRENCY" => Some(Self::Currency),
2883                "DEFAULT_COMMISSION" => Some(Self::DefaultCommission),
2884                _ => None,
2885            }
2886        }
2887    }
2888    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
2889    #[repr(i32)]
2890    pub enum AutoLiquidateFlag {
2891        Enabled = 1,
2892        Disabled = 2,
2893    }
2894    impl AutoLiquidateFlag {
2895        /// String value of the enum field names used in the ProtoBuf definition.
2896        ///
2897        /// The values are not transformed in any way and thus are considered stable
2898        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
2899        pub fn as_str_name(&self) -> &'static str {
2900            match self {
2901                Self::Enabled => "ENABLED",
2902                Self::Disabled => "DISABLED",
2903            }
2904        }
2905        /// Creates an enum from field names used in the ProtoBuf definition.
2906        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
2907            match value {
2908                "ENABLED" => Some(Self::Enabled),
2909                "DISABLED" => Some(Self::Disabled),
2910                _ => None,
2911            }
2912        }
2913    }
2914}
2915#[derive(Clone, PartialEq, ::prost::Message)]
2916pub struct RequestAccountRmsUpdates {
2917    #[prost(int32, required, tag = "154467")]
2918    pub template_id: i32,
2919    #[prost(string, repeated, tag = "132760")]
2920    pub user_msg: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
2921    #[prost(string, optional, tag = "154013")]
2922    pub fcm_id: ::core::option::Option<::prost::alloc::string::String>,
2923    #[prost(string, optional, tag = "154014")]
2924    pub ib_id: ::core::option::Option<::prost::alloc::string::String>,
2925    #[prost(string, optional, tag = "154008")]
2926    pub account_id: ::core::option::Option<::prost::alloc::string::String>,
2927    /// values can be either 'subscribe' or 'unsubscribe'
2928    #[prost(string, optional, tag = "100000")]
2929    pub request: ::core::option::Option<::prost::alloc::string::String>,
2930    #[prost(int32, optional, tag = "154211")]
2931    pub update_bits: ::core::option::Option<i32>,
2932}
2933/// Nested message and enum types in `RequestAccountRmsUpdates`.
2934pub mod request_account_rms_updates {
2935    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
2936    #[repr(i32)]
2937    pub enum UpdateBits {
2938        AutoLiqThresholdCurrentValue = 1,
2939    }
2940    impl UpdateBits {
2941        /// String value of the enum field names used in the ProtoBuf definition.
2942        ///
2943        /// The values are not transformed in any way and thus are considered stable
2944        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
2945        pub fn as_str_name(&self) -> &'static str {
2946            match self {
2947                Self::AutoLiqThresholdCurrentValue => "AUTO_LIQ_THRESHOLD_CURRENT_VALUE",
2948            }
2949        }
2950        /// Creates an enum from field names used in the ProtoBuf definition.
2951        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
2952            match value {
2953                "AUTO_LIQ_THRESHOLD_CURRENT_VALUE" => Some(Self::AutoLiqThresholdCurrentValue),
2954                _ => None,
2955            }
2956        }
2957    }
2958}
2959#[derive(Clone, PartialEq, ::prost::Message)]
2960pub struct ResponseAccountRmsUpdates {
2961    #[prost(int32, required, tag = "154467")]
2962    pub template_id: i32,
2963    #[prost(string, repeated, tag = "132760")]
2964    pub user_msg: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
2965    #[prost(string, repeated, tag = "132766")]
2966    pub rp_code: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
2967}
2968/// PB_OFFSET = 100000, is the offset added for each MNM field id
2969#[derive(Clone, PartialEq, ::prost::Message)]
2970pub struct RequestProductRmsInfo {
2971    /// PB_OFFSET + MNM_TEMPLATE_ID
2972    #[prost(int32, required, tag = "154467")]
2973    pub template_id: i32,
2974    /// PB_OFFSET + MNM_USER_MSG
2975    #[prost(string, repeated, tag = "132760")]
2976    pub user_msg: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
2977    /// PB_OFFSET + MNM_FCM_ID
2978    #[prost(string, optional, tag = "154013")]
2979    pub fcm_id: ::core::option::Option<::prost::alloc::string::String>,
2980    /// PB_OFFSET + MNM_IB_ID
2981    #[prost(string, optional, tag = "154014")]
2982    pub ib_id: ::core::option::Option<::prost::alloc::string::String>,
2983    /// PB_OFFSET + MNM_ACCOUNT_ID
2984    #[prost(string, optional, tag = "154008")]
2985    pub account_id: ::core::option::Option<::prost::alloc::string::String>,
2986}
2987/// PB_OFFSET = 100000, is the offset added for each MNM field id
2988#[derive(Clone, PartialEq, ::prost::Message)]
2989pub struct ResponseProductRmsInfo {
2990    /// PB_OFFSET + MNM_TEMPLATE_ID
2991    #[prost(int32, required, tag = "154467")]
2992    pub template_id: i32,
2993    /// PB_OFFSET + MNM_USER_MSG
2994    #[prost(string, repeated, tag = "132760")]
2995    pub user_msg: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
2996    /// PB_OFFSET + MNM_REQUEST_HANDLER_RESPONSE_CODE
2997    #[prost(string, repeated, tag = "132764")]
2998    pub rq_handler_rp_code: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
2999    /// PB_OFFSET + MNM_RESPONSE_CODE
3000    #[prost(string, repeated, tag = "132766")]
3001    pub rp_code: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
3002    /// PB_OFFSET + MNM_FIELD_PRESENCE_BITS
3003    #[prost(uint32, optional, tag = "153622")]
3004    pub presence_bits: ::core::option::Option<u32>,
3005    /// PB_OFFSET + MNM_FCM_ID
3006    #[prost(string, optional, tag = "154013")]
3007    pub fcm_id: ::core::option::Option<::prost::alloc::string::String>,
3008    /// PB_OFFSET + MNM_IB_ID
3009    #[prost(string, optional, tag = "154014")]
3010    pub ib_id: ::core::option::Option<::prost::alloc::string::String>,
3011    /// PB_OFFSET + MNM_ACCOUNT_ID
3012    #[prost(string, optional, tag = "154008")]
3013    pub account_id: ::core::option::Option<::prost::alloc::string::String>,
3014    /// PB_OFFSET + MNM_PRODUCT_CODE
3015    #[prost(string, optional, tag = "100749")]
3016    pub product_code: ::core::option::Option<::prost::alloc::string::String>,
3017    /// PB_OFFSET + MNM_LOSS_LIMIT
3018    #[prost(double, optional, tag = "154019")]
3019    pub loss_limit: ::core::option::Option<f64>,
3020    /// PB_OFFSET +    MNM_COMMISSION_FILL_RATE
3021    #[prost(double, optional, tag = "156969")]
3022    pub commission_fill_rate: ::core::option::Option<f64>,
3023    /// PB_OFFSET + MNM_BUY_MARGIN_RATE
3024    #[prost(double, optional, tag = "157003")]
3025    pub buy_margin_rate: ::core::option::Option<f64>,
3026    /// PB_OFFSET + MNM_SELL_MARGIN_RATE
3027    #[prost(double, optional, tag = "157004")]
3028    pub sell_margin_rate: ::core::option::Option<f64>,
3029    /// PB_OFFSET + MNM_BUY_LIMIT
3030    #[prost(int32, optional, tag = "154009")]
3031    pub buy_limit: ::core::option::Option<i32>,
3032    /// PB_OFFSET + MNM_MAX_LIMIT_QUAN
3033    #[prost(int32, optional, tag = "110105")]
3034    pub max_order_quantity: ::core::option::Option<i32>,
3035    /// PB_OFFSET + MNM_SELL_LIMIT
3036    #[prost(int32, optional, tag = "154035")]
3037    pub sell_limit: ::core::option::Option<i32>,
3038}
3039/// Nested message and enum types in `ResponseProductRmsInfo`.
3040pub mod response_product_rms_info {
3041    /// below enum is just for reference only, not used in this message
3042    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
3043    #[repr(i32)]
3044    pub enum PresenceBits {
3045        BuyLimit = 1,
3046        SellLimit = 2,
3047        LossLimit = 4,
3048        MaxOrderQuantity = 8,
3049        BuyMarginRate = 16,
3050        SellMarginRate = 32,
3051        CommissionFillRate = 64,
3052    }
3053    impl PresenceBits {
3054        /// String value of the enum field names used in the ProtoBuf definition.
3055        ///
3056        /// The values are not transformed in any way and thus are considered stable
3057        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
3058        pub fn as_str_name(&self) -> &'static str {
3059            match self {
3060                Self::BuyLimit => "BUY_LIMIT",
3061                Self::SellLimit => "SELL_LIMIT",
3062                Self::LossLimit => "LOSS_LIMIT",
3063                Self::MaxOrderQuantity => "MAX_ORDER_QUANTITY",
3064                Self::BuyMarginRate => "BUY_MARGIN_RATE",
3065                Self::SellMarginRate => "SELL_MARGIN_RATE",
3066                Self::CommissionFillRate => "COMMISSION_FILL_RATE",
3067            }
3068        }
3069        /// Creates an enum from field names used in the ProtoBuf definition.
3070        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
3071            match value {
3072                "BUY_LIMIT" => Some(Self::BuyLimit),
3073                "SELL_LIMIT" => Some(Self::SellLimit),
3074                "LOSS_LIMIT" => Some(Self::LossLimit),
3075                "MAX_ORDER_QUANTITY" => Some(Self::MaxOrderQuantity),
3076                "BUY_MARGIN_RATE" => Some(Self::BuyMarginRate),
3077                "SELL_MARGIN_RATE" => Some(Self::SellMarginRate),
3078                "COMMISSION_FILL_RATE" => Some(Self::CommissionFillRate),
3079                _ => None,
3080            }
3081        }
3082    }
3083}
3084/// PB_OFFSET = 100000, is the offset added for each MNM field id
3085#[derive(Clone, PartialEq, ::prost::Message)]
3086pub struct RequestSubscribeForOrderUpdates {
3087    /// PB_OFFSET + MNM_TEMPLATE_ID
3088    #[prost(int32, required, tag = "154467")]
3089    pub template_id: i32,
3090    /// PB_OFFSET + MNM_USER_MSG
3091    #[prost(string, repeated, tag = "132760")]
3092    pub user_msg: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
3093    /// PB_OFFSET + MNM_FCM_ID
3094    #[prost(string, optional, tag = "154013")]
3095    pub fcm_id: ::core::option::Option<::prost::alloc::string::String>,
3096    /// PB_OFFSET + MNM_IB_ID
3097    #[prost(string, optional, tag = "154014")]
3098    pub ib_id: ::core::option::Option<::prost::alloc::string::String>,
3099    /// PB_OFFSET + MNM_ACCOUNT_ID
3100    #[prost(string, optional, tag = "154008")]
3101    pub account_id: ::core::option::Option<::prost::alloc::string::String>,
3102}
3103/// PB_OFFSET = 100000, is the offset added for each MNM field id
3104#[derive(Clone, PartialEq, ::prost::Message)]
3105pub struct ResponseSubscribeForOrderUpdates {
3106    /// PB_OFFSET + MNM_TEMPLATE_ID
3107    #[prost(int32, required, tag = "154467")]
3108    pub template_id: i32,
3109    /// PB_OFFSET + MNM_USER_MSG
3110    #[prost(string, repeated, tag = "132760")]
3111    pub user_msg: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
3112    /// PB_OFFSET + MNM_RESPONSE_CODE
3113    #[prost(string, repeated, tag = "132766")]
3114    pub rp_code: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
3115}
3116/// PB_OFFSET = 100000, is the offset added for each MNM field id
3117#[derive(Clone, PartialEq, ::prost::Message)]
3118pub struct RequestTradeRoutes {
3119    /// PB_OFFSET + MNM_TEMPLATE_ID
3120    #[prost(int32, required, tag = "154467")]
3121    pub template_id: i32,
3122    /// PB_OFFSET + MNM_USER_MSG
3123    #[prost(string, repeated, tag = "132760")]
3124    pub user_msg: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
3125    /// PB_OFFSET + MNM_SUBSCRIBE_FLAG
3126    #[prost(bool, optional, tag = "154352")]
3127    pub subscribe_for_updates: ::core::option::Option<bool>,
3128}
3129/// PB_OFFSET = 100000, is the offset added for each MNM field id
3130#[derive(Clone, PartialEq, ::prost::Message)]
3131pub struct ResponseTradeRoutes {
3132    /// PB_OFFSET + MNM_TEMPLATE_ID
3133    #[prost(int32, required, tag = "154467")]
3134    pub template_id: i32,
3135    /// PB_OFFSET + MNM_USER_MSG
3136    #[prost(string, repeated, tag = "132760")]
3137    pub user_msg: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
3138    /// PB_OFFSET + MNM_REQUEST_HANDLER_RESPONSE_CODE
3139    #[prost(string, repeated, tag = "132764")]
3140    pub rq_handler_rp_code: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
3141    /// PB_OFFSET + MNM_RESPONSE_CODE
3142    #[prost(string, repeated, tag = "132766")]
3143    pub rp_code: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
3144    /// PB_OFFSET + MNM_FCM_ID
3145    #[prost(string, optional, tag = "154013")]
3146    pub fcm_id: ::core::option::Option<::prost::alloc::string::String>,
3147    /// PB_OFFSET + MNM_IB_ID
3148    #[prost(string, optional, tag = "154014")]
3149    pub ib_id: ::core::option::Option<::prost::alloc::string::String>,
3150    /// PB_OFFSET + MNM_EXCHANGE
3151    #[prost(string, optional, tag = "110101")]
3152    pub exchange: ::core::option::Option<::prost::alloc::string::String>,
3153    /// PB_OFFSET + MNM_TRADE_ROUTE
3154    #[prost(string, optional, tag = "112016")]
3155    pub trade_route: ::core::option::Option<::prost::alloc::string::String>,
3156    /// PB_OFFSET + MNM_SERVICE_STATE
3157    #[prost(string, optional, tag = "131407")]
3158    pub status: ::core::option::Option<::prost::alloc::string::String>,
3159    /// PB_OFFSET + MNM_DEFAULT_ROUTE
3160    #[prost(bool, optional, tag = "154689")]
3161    pub is_default: ::core::option::Option<bool>,
3162}
3163#[derive(Clone, PartialEq, ::prost::Message)]
3164pub struct RequestNewOrder {
3165    #[prost(int32, required, tag = "154467")]
3166    pub template_id: i32,
3167    #[prost(string, repeated, tag = "132760")]
3168    pub user_msg: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
3169    #[prost(string, optional, tag = "154119")]
3170    pub user_tag: ::core::option::Option<::prost::alloc::string::String>,
3171    #[prost(string, optional, tag = "154629")]
3172    pub window_name: ::core::option::Option<::prost::alloc::string::String>,
3173    #[prost(string, optional, tag = "154013")]
3174    pub fcm_id: ::core::option::Option<::prost::alloc::string::String>,
3175    #[prost(string, optional, tag = "154014")]
3176    pub ib_id: ::core::option::Option<::prost::alloc::string::String>,
3177    #[prost(string, optional, tag = "154008")]
3178    pub account_id: ::core::option::Option<::prost::alloc::string::String>,
3179    #[prost(string, optional, tag = "110100")]
3180    pub symbol: ::core::option::Option<::prost::alloc::string::String>,
3181    #[prost(string, optional, tag = "110101")]
3182    pub exchange: ::core::option::Option<::prost::alloc::string::String>,
3183    #[prost(int32, optional, tag = "112004")]
3184    pub quantity: ::core::option::Option<i32>,
3185    #[prost(double, optional, tag = "110306")]
3186    pub price: ::core::option::Option<f64>,
3187    #[prost(double, optional, tag = "149247")]
3188    pub trigger_price: ::core::option::Option<f64>,
3189    #[prost(
3190        enumeration = "request_new_order::TransactionType",
3191        optional,
3192        tag = "112003"
3193    )]
3194    pub transaction_type: ::core::option::Option<i32>,
3195    #[prost(enumeration = "request_new_order::Duration", optional, tag = "112005")]
3196    pub duration: ::core::option::Option<i32>,
3197    #[prost(enumeration = "request_new_order::PriceType", optional, tag = "112008")]
3198    pub price_type: ::core::option::Option<i32>,
3199    #[prost(string, optional, tag = "112016")]
3200    pub trade_route: ::core::option::Option<::prost::alloc::string::String>,
3201    #[prost(
3202        enumeration = "request_new_order::OrderPlacement",
3203        optional,
3204        tag = "154710"
3205    )]
3206    pub manual_or_auto: ::core::option::Option<i32>,
3207    #[prost(bool, optional, tag = "157063")]
3208    pub trailing_stop: ::core::option::Option<bool>,
3209    #[prost(int32, optional, tag = "157064")]
3210    pub trail_by_ticks: ::core::option::Option<i32>,
3211    #[prost(int32, optional, tag = "157065")]
3212    pub trail_by_price_id: ::core::option::Option<i32>,
3213    #[prost(int32, optional, tag = "154487")]
3214    pub release_at_ssboe: ::core::option::Option<i32>,
3215    #[prost(int32, optional, tag = "154549")]
3216    pub release_at_usecs: ::core::option::Option<i32>,
3217    #[prost(int32, optional, tag = "157085")]
3218    pub cancel_at_ssboe: ::core::option::Option<i32>,
3219    #[prost(int32, optional, tag = "157086")]
3220    pub cancel_at_usecs: ::core::option::Option<i32>,
3221    #[prost(int32, optional, tag = "154488")]
3222    pub cancel_after_secs: ::core::option::Option<i32>,
3223    #[prost(string, optional, tag = "154451")]
3224    pub if_touched_symbol: ::core::option::Option<::prost::alloc::string::String>,
3225    #[prost(string, optional, tag = "154452")]
3226    pub if_touched_exchange: ::core::option::Option<::prost::alloc::string::String>,
3227    #[prost(enumeration = "request_new_order::Condition", optional, tag = "154453")]
3228    pub if_touched_condition: ::core::option::Option<i32>,
3229    #[prost(
3230        enumeration = "request_new_order::PriceField",
3231        optional,
3232        tag = "154454"
3233    )]
3234    pub if_touched_price_field: ::core::option::Option<i32>,
3235    #[prost(double, optional, tag = "153632")]
3236    pub if_touched_price: ::core::option::Option<f64>,
3237}
3238/// Nested message and enum types in `RequestNewOrder`.
3239pub mod request_new_order {
3240    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
3241    #[repr(i32)]
3242    pub enum TransactionType {
3243        Buy = 1,
3244        Sell = 2,
3245    }
3246    impl TransactionType {
3247        /// String value of the enum field names used in the ProtoBuf definition.
3248        ///
3249        /// The values are not transformed in any way and thus are considered stable
3250        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
3251        pub fn as_str_name(&self) -> &'static str {
3252            match self {
3253                Self::Buy => "BUY",
3254                Self::Sell => "SELL",
3255            }
3256        }
3257        /// Creates an enum from field names used in the ProtoBuf definition.
3258        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
3259            match value {
3260                "BUY" => Some(Self::Buy),
3261                "SELL" => Some(Self::Sell),
3262                _ => None,
3263            }
3264        }
3265    }
3266    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
3267    #[repr(i32)]
3268    pub enum OrderPlacement {
3269        Manual = 1,
3270        Auto = 2,
3271    }
3272    impl OrderPlacement {
3273        /// String value of the enum field names used in the ProtoBuf definition.
3274        ///
3275        /// The values are not transformed in any way and thus are considered stable
3276        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
3277        pub fn as_str_name(&self) -> &'static str {
3278            match self {
3279                Self::Manual => "MANUAL",
3280                Self::Auto => "AUTO",
3281            }
3282        }
3283        /// Creates an enum from field names used in the ProtoBuf definition.
3284        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
3285            match value {
3286                "MANUAL" => Some(Self::Manual),
3287                "AUTO" => Some(Self::Auto),
3288                _ => None,
3289            }
3290        }
3291    }
3292    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
3293    #[repr(i32)]
3294    pub enum Duration {
3295        Day = 1,
3296        Gtc = 2,
3297        Ioc = 3,
3298        Fok = 4,
3299    }
3300    impl Duration {
3301        /// String value of the enum field names used in the ProtoBuf definition.
3302        ///
3303        /// The values are not transformed in any way and thus are considered stable
3304        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
3305        pub fn as_str_name(&self) -> &'static str {
3306            match self {
3307                Self::Day => "DAY",
3308                Self::Gtc => "GTC",
3309                Self::Ioc => "IOC",
3310                Self::Fok => "FOK",
3311            }
3312        }
3313        /// Creates an enum from field names used in the ProtoBuf definition.
3314        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
3315            match value {
3316                "DAY" => Some(Self::Day),
3317                "GTC" => Some(Self::Gtc),
3318                "IOC" => Some(Self::Ioc),
3319                "FOK" => Some(Self::Fok),
3320                _ => None,
3321            }
3322        }
3323    }
3324    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
3325    #[repr(i32)]
3326    pub enum PriceType {
3327        Limit = 1,
3328        Market = 2,
3329        StopLimit = 3,
3330        StopMarket = 4,
3331        MarketIfTouched = 5,
3332        LimitIfTouched = 6,
3333    }
3334    impl PriceType {
3335        /// String value of the enum field names used in the ProtoBuf definition.
3336        ///
3337        /// The values are not transformed in any way and thus are considered stable
3338        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
3339        pub fn as_str_name(&self) -> &'static str {
3340            match self {
3341                Self::Limit => "LIMIT",
3342                Self::Market => "MARKET",
3343                Self::StopLimit => "STOP_LIMIT",
3344                Self::StopMarket => "STOP_MARKET",
3345                Self::MarketIfTouched => "MARKET_IF_TOUCHED",
3346                Self::LimitIfTouched => "LIMIT_IF_TOUCHED",
3347            }
3348        }
3349        /// Creates an enum from field names used in the ProtoBuf definition.
3350        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
3351            match value {
3352                "LIMIT" => Some(Self::Limit),
3353                "MARKET" => Some(Self::Market),
3354                "STOP_LIMIT" => Some(Self::StopLimit),
3355                "STOP_MARKET" => Some(Self::StopMarket),
3356                "MARKET_IF_TOUCHED" => Some(Self::MarketIfTouched),
3357                "LIMIT_IF_TOUCHED" => Some(Self::LimitIfTouched),
3358                _ => None,
3359            }
3360        }
3361    }
3362    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
3363    #[repr(i32)]
3364    pub enum PriceField {
3365        BidPrice = 1,
3366        OfferPrice = 2,
3367        TradePrice = 3,
3368        LeanPrice = 4,
3369    }
3370    impl PriceField {
3371        /// String value of the enum field names used in the ProtoBuf definition.
3372        ///
3373        /// The values are not transformed in any way and thus are considered stable
3374        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
3375        pub fn as_str_name(&self) -> &'static str {
3376            match self {
3377                Self::BidPrice => "BID_PRICE",
3378                Self::OfferPrice => "OFFER_PRICE",
3379                Self::TradePrice => "TRADE_PRICE",
3380                Self::LeanPrice => "LEAN_PRICE",
3381            }
3382        }
3383        /// Creates an enum from field names used in the ProtoBuf definition.
3384        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
3385            match value {
3386                "BID_PRICE" => Some(Self::BidPrice),
3387                "OFFER_PRICE" => Some(Self::OfferPrice),
3388                "TRADE_PRICE" => Some(Self::TradePrice),
3389                "LEAN_PRICE" => Some(Self::LeanPrice),
3390                _ => None,
3391            }
3392        }
3393    }
3394    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
3395    #[repr(i32)]
3396    pub enum Condition {
3397        EqualTo = 1,
3398        NotEqualTo = 2,
3399        GreaterThan = 3,
3400        GreaterThanEqualTo = 4,
3401        LesserThan = 5,
3402        LesserThanEqualTo = 6,
3403    }
3404    impl Condition {
3405        /// String value of the enum field names used in the ProtoBuf definition.
3406        ///
3407        /// The values are not transformed in any way and thus are considered stable
3408        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
3409        pub fn as_str_name(&self) -> &'static str {
3410            match self {
3411                Self::EqualTo => "EQUAL_TO",
3412                Self::NotEqualTo => "NOT_EQUAL_TO",
3413                Self::GreaterThan => "GREATER_THAN",
3414                Self::GreaterThanEqualTo => "GREATER_THAN_EQUAL_TO",
3415                Self::LesserThan => "LESSER_THAN",
3416                Self::LesserThanEqualTo => "LESSER_THAN_EQUAL_TO",
3417            }
3418        }
3419        /// Creates an enum from field names used in the ProtoBuf definition.
3420        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
3421            match value {
3422                "EQUAL_TO" => Some(Self::EqualTo),
3423                "NOT_EQUAL_TO" => Some(Self::NotEqualTo),
3424                "GREATER_THAN" => Some(Self::GreaterThan),
3425                "GREATER_THAN_EQUAL_TO" => Some(Self::GreaterThanEqualTo),
3426                "LESSER_THAN" => Some(Self::LesserThan),
3427                "LESSER_THAN_EQUAL_TO" => Some(Self::LesserThanEqualTo),
3428                _ => None,
3429            }
3430        }
3431    }
3432}
3433/// PB_OFFSET = 100000, is the offset added for each MNM field id
3434#[derive(Clone, PartialEq, ::prost::Message)]
3435pub struct ResponseNewOrder {
3436    /// PB_OFFSET + MNM_TEMPLATE_ID
3437    #[prost(int32, required, tag = "154467")]
3438    pub template_id: i32,
3439    /// PB_OFFSET + MNM_USER_MSG
3440    #[prost(string, repeated, tag = "132760")]
3441    pub user_msg: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
3442    /// PB_OFFSET + MNM_USER_ORIGIN
3443    #[prost(string, optional, tag = "154119")]
3444    pub user_tag: ::core::option::Option<::prost::alloc::string::String>,
3445    /// PB_OFFSET + MNM_REQUEST_HANDLER_RESPONSE_CODE
3446    #[prost(string, repeated, tag = "132764")]
3447    pub rq_handler_rp_code: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
3448    /// PB_OFFSET + MNM_RESPONSE_CODE
3449    #[prost(string, repeated, tag = "132766")]
3450    pub rp_code: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
3451    /// PB_OFFSET + MNM_BASKET_ID
3452    #[prost(string, optional, tag = "110300")]
3453    pub basket_id: ::core::option::Option<::prost::alloc::string::String>,
3454    /// PB_OFFSET + MNM_SECONDS_SINCE_BOE
3455    #[prost(int32, optional, tag = "150100")]
3456    pub ssboe: ::core::option::Option<i32>,
3457    /// PB_OFFSET + MNM_USECS
3458    #[prost(int32, optional, tag = "150101")]
3459    pub usecs: ::core::option::Option<i32>,
3460}
3461#[derive(Clone, PartialEq, ::prost::Message)]
3462pub struct RequestModifyOrder {
3463    #[prost(int32, required, tag = "154467")]
3464    pub template_id: i32,
3465    #[prost(string, repeated, tag = "132760")]
3466    pub user_msg: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
3467    #[prost(string, optional, tag = "154629")]
3468    pub window_name: ::core::option::Option<::prost::alloc::string::String>,
3469    #[prost(string, optional, tag = "154013")]
3470    pub fcm_id: ::core::option::Option<::prost::alloc::string::String>,
3471    #[prost(string, optional, tag = "154014")]
3472    pub ib_id: ::core::option::Option<::prost::alloc::string::String>,
3473    #[prost(string, optional, tag = "154008")]
3474    pub account_id: ::core::option::Option<::prost::alloc::string::String>,
3475    #[prost(string, optional, tag = "110300")]
3476    pub basket_id: ::core::option::Option<::prost::alloc::string::String>,
3477    #[prost(string, optional, tag = "110100")]
3478    pub symbol: ::core::option::Option<::prost::alloc::string::String>,
3479    #[prost(string, optional, tag = "110101")]
3480    pub exchange: ::core::option::Option<::prost::alloc::string::String>,
3481    #[prost(int32, optional, tag = "112004")]
3482    pub quantity: ::core::option::Option<i32>,
3483    #[prost(double, optional, tag = "110306")]
3484    pub price: ::core::option::Option<f64>,
3485    #[prost(double, optional, tag = "149247")]
3486    pub trigger_price: ::core::option::Option<f64>,
3487    #[prost(
3488        enumeration = "request_modify_order::PriceType",
3489        optional,
3490        tag = "112008"
3491    )]
3492    pub price_type: ::core::option::Option<i32>,
3493    #[prost(
3494        enumeration = "request_modify_order::OrderPlacement",
3495        optional,
3496        tag = "154710"
3497    )]
3498    pub manual_or_auto: ::core::option::Option<i32>,
3499    #[prost(bool, optional, tag = "157063")]
3500    pub trailing_stop: ::core::option::Option<bool>,
3501    #[prost(int32, optional, tag = "157064")]
3502    pub trail_by_ticks: ::core::option::Option<i32>,
3503    #[prost(string, optional, tag = "154451")]
3504    pub if_touched_symbol: ::core::option::Option<::prost::alloc::string::String>,
3505    #[prost(string, optional, tag = "154452")]
3506    pub if_touched_exchange: ::core::option::Option<::prost::alloc::string::String>,
3507    #[prost(
3508        enumeration = "request_modify_order::Condition",
3509        optional,
3510        tag = "154453"
3511    )]
3512    pub if_touched_condition: ::core::option::Option<i32>,
3513    #[prost(
3514        enumeration = "request_modify_order::PriceField",
3515        optional,
3516        tag = "154454"
3517    )]
3518    pub if_touched_price_field: ::core::option::Option<i32>,
3519    #[prost(double, optional, tag = "153632")]
3520    pub if_touched_price: ::core::option::Option<f64>,
3521}
3522/// Nested message and enum types in `RequestModifyOrder`.
3523pub mod request_modify_order {
3524    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
3525    #[repr(i32)]
3526    pub enum PriceType {
3527        Limit = 1,
3528        Market = 2,
3529        StopLimit = 3,
3530        StopMarket = 4,
3531        MarketIfTouched = 5,
3532        LimitIfTouched = 6,
3533    }
3534    impl PriceType {
3535        /// String value of the enum field names used in the ProtoBuf definition.
3536        ///
3537        /// The values are not transformed in any way and thus are considered stable
3538        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
3539        pub fn as_str_name(&self) -> &'static str {
3540            match self {
3541                Self::Limit => "LIMIT",
3542                Self::Market => "MARKET",
3543                Self::StopLimit => "STOP_LIMIT",
3544                Self::StopMarket => "STOP_MARKET",
3545                Self::MarketIfTouched => "MARKET_IF_TOUCHED",
3546                Self::LimitIfTouched => "LIMIT_IF_TOUCHED",
3547            }
3548        }
3549        /// Creates an enum from field names used in the ProtoBuf definition.
3550        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
3551            match value {
3552                "LIMIT" => Some(Self::Limit),
3553                "MARKET" => Some(Self::Market),
3554                "STOP_LIMIT" => Some(Self::StopLimit),
3555                "STOP_MARKET" => Some(Self::StopMarket),
3556                "MARKET_IF_TOUCHED" => Some(Self::MarketIfTouched),
3557                "LIMIT_IF_TOUCHED" => Some(Self::LimitIfTouched),
3558                _ => None,
3559            }
3560        }
3561    }
3562    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
3563    #[repr(i32)]
3564    pub enum PriceField {
3565        BidPrice = 1,
3566        OfferPrice = 2,
3567        TradePrice = 3,
3568        LeanPrice = 4,
3569    }
3570    impl PriceField {
3571        /// String value of the enum field names used in the ProtoBuf definition.
3572        ///
3573        /// The values are not transformed in any way and thus are considered stable
3574        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
3575        pub fn as_str_name(&self) -> &'static str {
3576            match self {
3577                Self::BidPrice => "BID_PRICE",
3578                Self::OfferPrice => "OFFER_PRICE",
3579                Self::TradePrice => "TRADE_PRICE",
3580                Self::LeanPrice => "LEAN_PRICE",
3581            }
3582        }
3583        /// Creates an enum from field names used in the ProtoBuf definition.
3584        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
3585            match value {
3586                "BID_PRICE" => Some(Self::BidPrice),
3587                "OFFER_PRICE" => Some(Self::OfferPrice),
3588                "TRADE_PRICE" => Some(Self::TradePrice),
3589                "LEAN_PRICE" => Some(Self::LeanPrice),
3590                _ => None,
3591            }
3592        }
3593    }
3594    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
3595    #[repr(i32)]
3596    pub enum Condition {
3597        EqualTo = 1,
3598        NotEqualTo = 2,
3599        GreaterThan = 3,
3600        GreaterThanEqualTo = 4,
3601        LesserThan = 5,
3602        LesserThanEqualTo = 6,
3603    }
3604    impl Condition {
3605        /// String value of the enum field names used in the ProtoBuf definition.
3606        ///
3607        /// The values are not transformed in any way and thus are considered stable
3608        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
3609        pub fn as_str_name(&self) -> &'static str {
3610            match self {
3611                Self::EqualTo => "EQUAL_TO",
3612                Self::NotEqualTo => "NOT_EQUAL_TO",
3613                Self::GreaterThan => "GREATER_THAN",
3614                Self::GreaterThanEqualTo => "GREATER_THAN_EQUAL_TO",
3615                Self::LesserThan => "LESSER_THAN",
3616                Self::LesserThanEqualTo => "LESSER_THAN_EQUAL_TO",
3617            }
3618        }
3619        /// Creates an enum from field names used in the ProtoBuf definition.
3620        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
3621            match value {
3622                "EQUAL_TO" => Some(Self::EqualTo),
3623                "NOT_EQUAL_TO" => Some(Self::NotEqualTo),
3624                "GREATER_THAN" => Some(Self::GreaterThan),
3625                "GREATER_THAN_EQUAL_TO" => Some(Self::GreaterThanEqualTo),
3626                "LESSER_THAN" => Some(Self::LesserThan),
3627                "LESSER_THAN_EQUAL_TO" => Some(Self::LesserThanEqualTo),
3628                _ => None,
3629            }
3630        }
3631    }
3632    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
3633    #[repr(i32)]
3634    pub enum OrderPlacement {
3635        Manual = 1,
3636        Auto = 2,
3637    }
3638    impl OrderPlacement {
3639        /// String value of the enum field names used in the ProtoBuf definition.
3640        ///
3641        /// The values are not transformed in any way and thus are considered stable
3642        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
3643        pub fn as_str_name(&self) -> &'static str {
3644            match self {
3645                Self::Manual => "MANUAL",
3646                Self::Auto => "AUTO",
3647            }
3648        }
3649        /// Creates an enum from field names used in the ProtoBuf definition.
3650        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
3651            match value {
3652                "MANUAL" => Some(Self::Manual),
3653                "AUTO" => Some(Self::Auto),
3654                _ => None,
3655            }
3656        }
3657    }
3658}
3659/// PB_OFFSET = 100000, is the offset added for each MNM field id
3660#[derive(Clone, PartialEq, ::prost::Message)]
3661pub struct ResponseModifyOrder {
3662    /// PB_OFFSET + MNM_TEMPLATE_ID
3663    #[prost(int32, required, tag = "154467")]
3664    pub template_id: i32,
3665    /// PB_OFFSET + MNM_USER_MSG
3666    #[prost(string, repeated, tag = "132760")]
3667    pub user_msg: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
3668    /// PB_OFFSET + MNM_REQUEST_HANDLER_RESPONSE_CODE
3669    #[prost(string, repeated, tag = "132764")]
3670    pub rq_handler_rp_code: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
3671    /// PB_OFFSET + MNM_RESPONSE_CODE
3672    #[prost(string, repeated, tag = "132766")]
3673    pub rp_code: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
3674    /// PB_OFFSET + MNM_BASKET_ID
3675    #[prost(string, optional, tag = "110300")]
3676    pub basket_id: ::core::option::Option<::prost::alloc::string::String>,
3677    /// PB_OFFSET + MNM_SECONDS_SINCE_BOE
3678    #[prost(int32, optional, tag = "150100")]
3679    pub ssboe: ::core::option::Option<i32>,
3680    /// PB_OFFSET + MNM_USECS
3681    #[prost(int32, optional, tag = "150101")]
3682    pub usecs: ::core::option::Option<i32>,
3683}
3684/// PB_OFFSET = 100000, is the offset added for each MNM field id
3685#[derive(Clone, PartialEq, ::prost::Message)]
3686pub struct RequestModifyOrderReferenceData {
3687    /// PB_OFFSET + MNM_TEMPLATE_ID
3688    #[prost(int32, required, tag = "154467")]
3689    pub template_id: i32,
3690    /// PB_OFFSET + MNM_USER_MSG
3691    #[prost(string, repeated, tag = "132760")]
3692    pub user_msg: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
3693    /// PB_OFFSET + MNM_USER_ORIGIN
3694    #[prost(string, optional, tag = "154119")]
3695    pub user_tag: ::core::option::Option<::prost::alloc::string::String>,
3696    /// PB_OFFSET + MNM_FCM_ID
3697    #[prost(string, optional, tag = "154013")]
3698    pub fcm_id: ::core::option::Option<::prost::alloc::string::String>,
3699    /// PB_OFFSET + MNM_IB_ID
3700    #[prost(string, optional, tag = "154014")]
3701    pub ib_id: ::core::option::Option<::prost::alloc::string::String>,
3702    /// PB_OFFSET + MNM_ACCOUNT_ID
3703    #[prost(string, optional, tag = "154008")]
3704    pub account_id: ::core::option::Option<::prost::alloc::string::String>,
3705    /// PB_OFFSET + MNM_BASKET_ID
3706    #[prost(string, optional, tag = "110300")]
3707    pub basket_id: ::core::option::Option<::prost::alloc::string::String>,
3708}
3709/// PB_OFFSET = 100000, is the offset added for each MNM field id
3710#[derive(Clone, PartialEq, ::prost::Message)]
3711pub struct ResponseModifyOrderReferenceData {
3712    /// PB_OFFSET + MNM_TEMPLATE_ID
3713    #[prost(int32, required, tag = "154467")]
3714    pub template_id: i32,
3715    /// PB_OFFSET + MNM_USER_MSG
3716    #[prost(string, repeated, tag = "132760")]
3717    pub user_msg: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
3718    /// PB_OFFSET + MNM_RESPONSE_CODE
3719    #[prost(string, repeated, tag = "132766")]
3720    pub rp_code: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
3721}
3722#[derive(Clone, PartialEq, ::prost::Message)]
3723pub struct RequestCancelOrder {
3724    #[prost(int32, required, tag = "154467")]
3725    pub template_id: i32,
3726    #[prost(string, repeated, tag = "132760")]
3727    pub user_msg: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
3728    #[prost(string, optional, tag = "154629")]
3729    pub window_name: ::core::option::Option<::prost::alloc::string::String>,
3730    #[prost(string, optional, tag = "154013")]
3731    pub fcm_id: ::core::option::Option<::prost::alloc::string::String>,
3732    #[prost(string, optional, tag = "154014")]
3733    pub ib_id: ::core::option::Option<::prost::alloc::string::String>,
3734    #[prost(string, optional, tag = "154008")]
3735    pub account_id: ::core::option::Option<::prost::alloc::string::String>,
3736    #[prost(string, optional, tag = "110300")]
3737    pub basket_id: ::core::option::Option<::prost::alloc::string::String>,
3738    #[prost(
3739        enumeration = "request_cancel_order::OrderPlacement",
3740        optional,
3741        tag = "154710"
3742    )]
3743    pub manual_or_auto: ::core::option::Option<i32>,
3744}
3745/// Nested message and enum types in `RequestCancelOrder`.
3746pub mod request_cancel_order {
3747    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
3748    #[repr(i32)]
3749    pub enum OrderPlacement {
3750        Manual = 1,
3751        Auto = 2,
3752    }
3753    impl OrderPlacement {
3754        /// String value of the enum field names used in the ProtoBuf definition.
3755        ///
3756        /// The values are not transformed in any way and thus are considered stable
3757        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
3758        pub fn as_str_name(&self) -> &'static str {
3759            match self {
3760                Self::Manual => "MANUAL",
3761                Self::Auto => "AUTO",
3762            }
3763        }
3764        /// Creates an enum from field names used in the ProtoBuf definition.
3765        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
3766            match value {
3767                "MANUAL" => Some(Self::Manual),
3768                "AUTO" => Some(Self::Auto),
3769                _ => None,
3770            }
3771        }
3772    }
3773}
3774/// PB_OFFSET = 100000, is the offset added for each MNM field id
3775#[derive(Clone, PartialEq, ::prost::Message)]
3776pub struct ResponseCancelOrder {
3777    /// PB_OFFSET + MNM_TEMPLATE_ID
3778    #[prost(int32, required, tag = "154467")]
3779    pub template_id: i32,
3780    /// PB_OFFSET + MNM_USER_MSG
3781    #[prost(string, repeated, tag = "132760")]
3782    pub user_msg: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
3783    /// PB_OFFSET + MNM_REQUEST_HANDLER_RESPONSE_CODE
3784    #[prost(string, repeated, tag = "132764")]
3785    pub rq_handler_rp_code: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
3786    /// PB_OFFSET + MNM_RESPONSE_CODE
3787    #[prost(string, repeated, tag = "132766")]
3788    pub rp_code: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
3789    /// PB_OFFSET + MNM_BASKET_ID
3790    #[prost(string, optional, tag = "110300")]
3791    pub basket_id: ::core::option::Option<::prost::alloc::string::String>,
3792    /// PB_OFFSET + MNM_SECONDS_SINCE_BOE
3793    #[prost(int32, optional, tag = "150100")]
3794    pub ssboe: ::core::option::Option<i32>,
3795    /// PB_OFFSET + MNM_USECS
3796    #[prost(int32, optional, tag = "150101")]
3797    pub usecs: ::core::option::Option<i32>,
3798}
3799/// PB_OFFSET = 100000, is the offset added for each MNM field id
3800#[derive(Clone, PartialEq, ::prost::Message)]
3801pub struct RequestCancelAllOrders {
3802    /// PB_OFFSET + MNM_TEMPLATE_ID
3803    #[prost(int32, required, tag = "154467")]
3804    pub template_id: i32,
3805    /// PB_OFFSET + MNM_USER_MSG
3806    #[prost(string, repeated, tag = "132760")]
3807    pub user_msg: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
3808    /// PB_OFFSET + MNM_FCM_ID
3809    #[prost(string, optional, tag = "154013")]
3810    pub fcm_id: ::core::option::Option<::prost::alloc::string::String>,
3811    /// PB_OFFSET + MNM_IB_ID
3812    #[prost(string, optional, tag = "154014")]
3813    pub ib_id: ::core::option::Option<::prost::alloc::string::String>,
3814    /// PB_OFFSET + MNM_ACCOUNT_ID
3815    #[prost(string, optional, tag = "154008")]
3816    pub account_id: ::core::option::Option<::prost::alloc::string::String>,
3817    /// PB_OFFSET + MNM_USER_TYPE
3818    #[prost(
3819        enumeration = "request_cancel_all_orders::UserType",
3820        optional,
3821        tag = "154036"
3822    )]
3823    pub user_type: ::core::option::Option<i32>,
3824    /// PB_OFFSET + MNM_MANUAL_OR_AUTO
3825    #[prost(
3826        enumeration = "request_cancel_all_orders::OrderPlacement",
3827        optional,
3828        tag = "154710"
3829    )]
3830    pub manual_or_auto: ::core::option::Option<i32>,
3831}
3832/// Nested message and enum types in `RequestCancelAllOrders`.
3833pub mod request_cancel_all_orders {
3834    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
3835    #[repr(i32)]
3836    pub enum OrderPlacement {
3837        Manual = 1,
3838        Auto = 2,
3839    }
3840    impl OrderPlacement {
3841        /// String value of the enum field names used in the ProtoBuf definition.
3842        ///
3843        /// The values are not transformed in any way and thus are considered stable
3844        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
3845        pub fn as_str_name(&self) -> &'static str {
3846            match self {
3847                Self::Manual => "MANUAL",
3848                Self::Auto => "AUTO",
3849            }
3850        }
3851        /// Creates an enum from field names used in the ProtoBuf definition.
3852        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
3853            match value {
3854                "MANUAL" => Some(Self::Manual),
3855                "AUTO" => Some(Self::Auto),
3856                _ => None,
3857            }
3858        }
3859    }
3860    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
3861    #[repr(i32)]
3862    pub enum UserType {
3863        Admin = 0,
3864        Fcm = 1,
3865        Ib = 2,
3866        Trader = 3,
3867    }
3868    impl UserType {
3869        /// String value of the enum field names used in the ProtoBuf definition.
3870        ///
3871        /// The values are not transformed in any way and thus are considered stable
3872        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
3873        pub fn as_str_name(&self) -> &'static str {
3874            match self {
3875                Self::Admin => "USER_TYPE_ADMIN",
3876                Self::Fcm => "USER_TYPE_FCM",
3877                Self::Ib => "USER_TYPE_IB",
3878                Self::Trader => "USER_TYPE_TRADER",
3879            }
3880        }
3881        /// Creates an enum from field names used in the ProtoBuf definition.
3882        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
3883            match value {
3884                "USER_TYPE_ADMIN" => Some(Self::Admin),
3885                "USER_TYPE_FCM" => Some(Self::Fcm),
3886                "USER_TYPE_IB" => Some(Self::Ib),
3887                "USER_TYPE_TRADER" => Some(Self::Trader),
3888                _ => None,
3889            }
3890        }
3891    }
3892}
3893/// PB_OFFSET = 100000, is the offset added for each MNM field id
3894#[derive(Clone, PartialEq, ::prost::Message)]
3895pub struct ResponseCancelAllOrders {
3896    /// PB_OFFSET + MNM_TEMPLATE_ID
3897    #[prost(int32, required, tag = "154467")]
3898    pub template_id: i32,
3899    /// PB_OFFSET + MNM_USER_MSG
3900    #[prost(string, repeated, tag = "132760")]
3901    pub user_msg: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
3902    /// PB_OFFSET + MNM_RESPONSE_CODE
3903    #[prost(string, repeated, tag = "132766")]
3904    pub rp_code: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
3905}
3906/// PB_OFFSET = 100000, is the offset added for each MNM field id
3907#[derive(Clone, PartialEq, ::prost::Message)]
3908pub struct RequestShowOrders {
3909    /// PB_OFFSET + MNM_TEMPLATE_ID
3910    #[prost(int32, required, tag = "154467")]
3911    pub template_id: i32,
3912    /// PB_OFFSET + MNM_USER_MSG
3913    #[prost(string, repeated, tag = "132760")]
3914    pub user_msg: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
3915    /// PB_OFFSET + MNM_FCM_ID
3916    #[prost(string, optional, tag = "154013")]
3917    pub fcm_id: ::core::option::Option<::prost::alloc::string::String>,
3918    /// PB_OFFSET + MNM_IB_ID
3919    #[prost(string, optional, tag = "154014")]
3920    pub ib_id: ::core::option::Option<::prost::alloc::string::String>,
3921    /// PB_OFFSET + MNM_ACCOUNT_ID
3922    #[prost(string, optional, tag = "154008")]
3923    pub account_id: ::core::option::Option<::prost::alloc::string::String>,
3924}
3925/// PB_OFFSET = 100000, is the offset added for each MNM field id
3926#[derive(Clone, PartialEq, ::prost::Message)]
3927pub struct ResponseShowOrders {
3928    /// PB_OFFSET + MNM_TEMPLATE_ID
3929    #[prost(int32, required, tag = "154467")]
3930    pub template_id: i32,
3931    /// PB_OFFSET + MNM_USER_MSG
3932    #[prost(string, repeated, tag = "132760")]
3933    pub user_msg: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
3934    /// PB_OFFSET + MNM_RESPONSE_CODE
3935    #[prost(string, repeated, tag = "132766")]
3936    pub rp_code: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
3937}
3938/// PB_OFFSET = 100000, is the offset added for each MNM field id
3939#[derive(Clone, PartialEq, ::prost::Message)]
3940pub struct RequestShowOrderHistory {
3941    /// PB_OFFSET + MNM_TEMPLATE_ID
3942    #[prost(int32, required, tag = "154467")]
3943    pub template_id: i32,
3944    /// PB_OFFSET + MNM_USER_MSG
3945    #[prost(string, repeated, tag = "132760")]
3946    pub user_msg: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
3947    /// PB_OFFSET + MNM_FCM_ID
3948    #[prost(string, optional, tag = "154013")]
3949    pub fcm_id: ::core::option::Option<::prost::alloc::string::String>,
3950    /// PB_OFFSET + MNM_IB_ID
3951    #[prost(string, optional, tag = "154014")]
3952    pub ib_id: ::core::option::Option<::prost::alloc::string::String>,
3953    /// PB_OFFSET + MNM_ACCOUNT_ID
3954    #[prost(string, optional, tag = "154008")]
3955    pub account_id: ::core::option::Option<::prost::alloc::string::String>,
3956    /// PB_OFFSET + MNM_BASKET_ID
3957    #[prost(string, optional, tag = "110300")]
3958    pub basket_id: ::core::option::Option<::prost::alloc::string::String>,
3959}
3960/// PB_OFFSET = 100000, is the offset added for each MNM field id
3961#[derive(Clone, PartialEq, ::prost::Message)]
3962pub struct ResponseShowOrderHistory {
3963    /// PB_OFFSET + MNM_TEMPLATE_ID
3964    #[prost(int32, required, tag = "154467")]
3965    pub template_id: i32,
3966    /// PB_OFFSET + MNM_USER_MSG
3967    #[prost(string, repeated, tag = "132760")]
3968    pub user_msg: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
3969    /// PB_OFFSET + MNM_RESPONSE_CODE
3970    #[prost(string, repeated, tag = "132766")]
3971    pub rp_code: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
3972}
3973/// PB_OFFSET = 100000, is the offset added for each MNM field id
3974#[derive(Clone, PartialEq, ::prost::Message)]
3975pub struct RequestShowOrderHistorySummary {
3976    /// PB_OFFSET + MNM_TEMPLATE_ID
3977    #[prost(int32, required, tag = "154467")]
3978    pub template_id: i32,
3979    /// PB_OFFSET + MNM_USER_MSG
3980    #[prost(string, repeated, tag = "132760")]
3981    pub user_msg: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
3982    /// PB_OFFSET + MNM_FCM_ID
3983    #[prost(string, optional, tag = "154013")]
3984    pub fcm_id: ::core::option::Option<::prost::alloc::string::String>,
3985    /// PB_OFFSET + MNM_IB_ID
3986    #[prost(string, optional, tag = "154014")]
3987    pub ib_id: ::core::option::Option<::prost::alloc::string::String>,
3988    /// PB_OFFSET + MNM_ACCOUNT_ID
3989    #[prost(string, optional, tag = "154008")]
3990    pub account_id: ::core::option::Option<::prost::alloc::string::String>,
3991    /// PB_OFFSET + MNM_DATE
3992    #[prost(string, optional, tag = "110615")]
3993    pub date: ::core::option::Option<::prost::alloc::string::String>,
3994}
3995/// PB_OFFSET = 100000, is the offset added for each MNM field id
3996#[derive(Clone, PartialEq, ::prost::Message)]
3997pub struct ResponseShowOrderHistorySummary {
3998    /// PB_OFFSET + MNM_TEMPLATE_ID
3999    #[prost(int32, required, tag = "154467")]
4000    pub template_id: i32,
4001    /// PB_OFFSET + MNM_USER_MSG
4002    #[prost(string, repeated, tag = "132760")]
4003    pub user_msg: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
4004    /// PB_OFFSET + MNM_RESPONSE_CODE
4005    #[prost(string, repeated, tag = "132766")]
4006    pub rp_code: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
4007}
4008/// PB_OFFSET = 100000, is the offset added for each MNM field id
4009#[derive(Clone, PartialEq, ::prost::Message)]
4010pub struct RequestShowOrderHistoryDetail {
4011    /// PB_OFFSET + MNM_TEMPLATE_ID
4012    #[prost(int32, required, tag = "154467")]
4013    pub template_id: i32,
4014    /// PB_OFFSET + MNM_USER_MSG
4015    #[prost(string, repeated, tag = "132760")]
4016    pub user_msg: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
4017    /// PB_OFFSET + MNM_FCM_ID
4018    #[prost(string, optional, tag = "154013")]
4019    pub fcm_id: ::core::option::Option<::prost::alloc::string::String>,
4020    /// PB_OFFSET + MNM_IB_ID
4021    #[prost(string, optional, tag = "154014")]
4022    pub ib_id: ::core::option::Option<::prost::alloc::string::String>,
4023    /// PB_OFFSET + MNM_ACCOUNT_ID
4024    #[prost(string, optional, tag = "154008")]
4025    pub account_id: ::core::option::Option<::prost::alloc::string::String>,
4026    /// PB_OFFSET + MNM_BASKET_ID
4027    #[prost(string, optional, tag = "110300")]
4028    pub basket_id: ::core::option::Option<::prost::alloc::string::String>,
4029    /// PB_OFFSET + MNM_DATE
4030    #[prost(string, optional, tag = "110615")]
4031    pub date: ::core::option::Option<::prost::alloc::string::String>,
4032}
4033/// PB_OFFSET = 100000, is the offset added for each MNM field id
4034#[derive(Clone, PartialEq, ::prost::Message)]
4035pub struct ResponseShowOrderHistoryDetail {
4036    /// PB_OFFSET + MNM_TEMPLATE_ID
4037    #[prost(int32, required, tag = "154467")]
4038    pub template_id: i32,
4039    /// PB_OFFSET + MNM_USER_MSG
4040    #[prost(string, repeated, tag = "132760")]
4041    pub user_msg: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
4042    /// PB_OFFSET + MNM_RESPONSE_CODE
4043    #[prost(string, repeated, tag = "132766")]
4044    pub rp_code: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
4045}
4046/// PB_OFFSET = 100000 , is the offset added for each MNM field id
4047#[derive(Clone, PartialEq, ::prost::Message)]
4048pub struct RequestShowOrderHistoryDates {
4049    /// PB_OFFSET + MNM_TEMPLATE_ID
4050    #[prost(int32, required, tag = "154467")]
4051    pub template_id: i32,
4052    /// PB_OFFSET + MNM_USER_MSG
4053    #[prost(string, repeated, tag = "132760")]
4054    pub user_msg: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
4055}
4056/// PB_OFFSET = 100000, is the offset added for each MNM field id
4057#[derive(Clone, PartialEq, ::prost::Message)]
4058pub struct ResponseShowOrderHistoryDates {
4059    /// PB_OFFSET + MNM_TEMPLATE_ID
4060    #[prost(int32, required, tag = "154467")]
4061    pub template_id: i32,
4062    /// PB_OFFSET + MNM_USER_MSG
4063    #[prost(string, repeated, tag = "132760")]
4064    pub user_msg: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
4065    /// PB_OFFSET + MNM_REQUEST_HANDLER_RESPONSE_CODE
4066    #[prost(string, repeated, tag = "132764")]
4067    pub rq_handler_rp_code: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
4068    /// PB_OFFSET + MNM_RESPONSE_CODE
4069    #[prost(string, repeated, tag = "132766")]
4070    pub rp_code: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
4071    /// PB_OFFSET + MNM_DATE
4072    #[prost(string, repeated, tag = "110615")]
4073    pub date: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
4074}
4075#[derive(Clone, PartialEq, ::prost::Message)]
4076pub struct RequestOcoOrder {
4077    #[prost(int32, required, tag = "154467")]
4078    pub template_id: i32,
4079    #[prost(string, repeated, tag = "132760")]
4080    pub user_msg: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
4081    #[prost(string, repeated, tag = "154119")]
4082    pub user_tag: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
4083    #[prost(string, repeated, tag = "154629")]
4084    pub window_name: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
4085    #[prost(string, optional, tag = "154013")]
4086    pub fcm_id: ::core::option::Option<::prost::alloc::string::String>,
4087    #[prost(string, optional, tag = "154014")]
4088    pub ib_id: ::core::option::Option<::prost::alloc::string::String>,
4089    #[prost(string, optional, tag = "154008")]
4090    pub account_id: ::core::option::Option<::prost::alloc::string::String>,
4091    #[prost(string, repeated, tag = "110100")]
4092    pub symbol: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
4093    #[prost(string, repeated, tag = "110101")]
4094    pub exchange: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
4095    #[prost(int32, repeated, packed = "false", tag = "112004")]
4096    pub quantity: ::prost::alloc::vec::Vec<i32>,
4097    #[prost(double, repeated, packed = "false", tag = "110306")]
4098    pub price: ::prost::alloc::vec::Vec<f64>,
4099    #[prost(double, repeated, packed = "false", tag = "149247")]
4100    pub trigger_price: ::prost::alloc::vec::Vec<f64>,
4101    #[prost(
4102        enumeration = "request_oco_order::TransactionType",
4103        repeated,
4104        packed = "false",
4105        tag = "112003"
4106    )]
4107    pub transaction_type: ::prost::alloc::vec::Vec<i32>,
4108    #[prost(
4109        enumeration = "request_oco_order::Duration",
4110        repeated,
4111        packed = "false",
4112        tag = "112005"
4113    )]
4114    pub duration: ::prost::alloc::vec::Vec<i32>,
4115    #[prost(
4116        enumeration = "request_oco_order::PriceType",
4117        repeated,
4118        packed = "false",
4119        tag = "112008"
4120    )]
4121    pub price_type: ::prost::alloc::vec::Vec<i32>,
4122    #[prost(string, repeated, tag = "112016")]
4123    pub trade_route: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
4124    #[prost(
4125        enumeration = "request_oco_order::OrderPlacement",
4126        repeated,
4127        packed = "false",
4128        tag = "154710"
4129    )]
4130    pub manual_or_auto: ::prost::alloc::vec::Vec<i32>,
4131    #[prost(bool, repeated, packed = "false", tag = "157063")]
4132    pub trailing_stop: ::prost::alloc::vec::Vec<bool>,
4133    #[prost(int32, repeated, packed = "false", tag = "157064")]
4134    pub trail_by_ticks: ::prost::alloc::vec::Vec<i32>,
4135    #[prost(int32, repeated, packed = "false", tag = "157065")]
4136    pub trail_by_price_id: ::prost::alloc::vec::Vec<i32>,
4137    #[prost(int32, optional, tag = "157085")]
4138    pub cancel_at_ssboe: ::core::option::Option<i32>,
4139    #[prost(int32, optional, tag = "157086")]
4140    pub cancel_at_usecs: ::core::option::Option<i32>,
4141    #[prost(int32, optional, tag = "154488")]
4142    pub cancel_after_secs: ::core::option::Option<i32>,
4143}
4144/// Nested message and enum types in `RequestOCOOrder`.
4145pub mod request_oco_order {
4146    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
4147    #[repr(i32)]
4148    pub enum TransactionType {
4149        Buy = 1,
4150        Sell = 2,
4151    }
4152    impl TransactionType {
4153        /// String value of the enum field names used in the ProtoBuf definition.
4154        ///
4155        /// The values are not transformed in any way and thus are considered stable
4156        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
4157        pub fn as_str_name(&self) -> &'static str {
4158            match self {
4159                Self::Buy => "BUY",
4160                Self::Sell => "SELL",
4161            }
4162        }
4163        /// Creates an enum from field names used in the ProtoBuf definition.
4164        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
4165            match value {
4166                "BUY" => Some(Self::Buy),
4167                "SELL" => Some(Self::Sell),
4168                _ => None,
4169            }
4170        }
4171    }
4172    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
4173    #[repr(i32)]
4174    pub enum Duration {
4175        Day = 1,
4176        Gtc = 2,
4177        Ioc = 3,
4178        Fok = 4,
4179    }
4180    impl Duration {
4181        /// String value of the enum field names used in the ProtoBuf definition.
4182        ///
4183        /// The values are not transformed in any way and thus are considered stable
4184        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
4185        pub fn as_str_name(&self) -> &'static str {
4186            match self {
4187                Self::Day => "DAY",
4188                Self::Gtc => "GTC",
4189                Self::Ioc => "IOC",
4190                Self::Fok => "FOK",
4191            }
4192        }
4193        /// Creates an enum from field names used in the ProtoBuf definition.
4194        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
4195            match value {
4196                "DAY" => Some(Self::Day),
4197                "GTC" => Some(Self::Gtc),
4198                "IOC" => Some(Self::Ioc),
4199                "FOK" => Some(Self::Fok),
4200                _ => None,
4201            }
4202        }
4203    }
4204    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
4205    #[repr(i32)]
4206    pub enum PriceType {
4207        Limit = 1,
4208        Market = 2,
4209        StopLimit = 3,
4210        StopMarket = 4,
4211    }
4212    impl PriceType {
4213        /// String value of the enum field names used in the ProtoBuf definition.
4214        ///
4215        /// The values are not transformed in any way and thus are considered stable
4216        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
4217        pub fn as_str_name(&self) -> &'static str {
4218            match self {
4219                Self::Limit => "LIMIT",
4220                Self::Market => "MARKET",
4221                Self::StopLimit => "STOP_LIMIT",
4222                Self::StopMarket => "STOP_MARKET",
4223            }
4224        }
4225        /// Creates an enum from field names used in the ProtoBuf definition.
4226        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
4227            match value {
4228                "LIMIT" => Some(Self::Limit),
4229                "MARKET" => Some(Self::Market),
4230                "STOP_LIMIT" => Some(Self::StopLimit),
4231                "STOP_MARKET" => Some(Self::StopMarket),
4232                _ => None,
4233            }
4234        }
4235    }
4236    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
4237    #[repr(i32)]
4238    pub enum OrderPlacement {
4239        Manual = 1,
4240        Auto = 2,
4241    }
4242    impl OrderPlacement {
4243        /// String value of the enum field names used in the ProtoBuf definition.
4244        ///
4245        /// The values are not transformed in any way and thus are considered stable
4246        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
4247        pub fn as_str_name(&self) -> &'static str {
4248            match self {
4249                Self::Manual => "MANUAL",
4250                Self::Auto => "AUTO",
4251            }
4252        }
4253        /// Creates an enum from field names used in the ProtoBuf definition.
4254        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
4255            match value {
4256                "MANUAL" => Some(Self::Manual),
4257                "AUTO" => Some(Self::Auto),
4258                _ => None,
4259            }
4260        }
4261    }
4262}
4263/// PB_OFFSET = 100000, is the offset added for each MNM field id
4264#[derive(Clone, PartialEq, ::prost::Message)]
4265pub struct ResponseOcoOrder {
4266    /// PB_OFFSET + MNM_TEMPLATE_ID
4267    #[prost(int32, required, tag = "154467")]
4268    pub template_id: i32,
4269    /// PB_OFFSET + MNM_USER_MSG
4270    #[prost(string, repeated, tag = "132760")]
4271    pub user_msg: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
4272    /// PB_OFFSET + MNM_USER_ORIGIN
4273    #[prost(string, repeated, tag = "154119")]
4274    pub user_tag: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
4275    /// PB_OFFSET + MNM_REQUEST_HANDLER_RESPONSE_CODE
4276    #[prost(string, repeated, tag = "132764")]
4277    pub rq_handler_rp_code: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
4278    /// PB_OFFSET + MNM_RESPONSE_CODE
4279    #[prost(string, repeated, tag = "132766")]
4280    pub rp_code: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
4281    /// PB_OFFSET + MNM_BASKET_ID
4282    #[prost(string, repeated, tag = "110300")]
4283    pub basket_id: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
4284    /// PB_OFFSET + MNM_SECONDS_SINCE_BOE
4285    #[prost(int32, repeated, packed = "false", tag = "150100")]
4286    pub ssboe: ::prost::alloc::vec::Vec<i32>,
4287    /// PB_OFFSET + MNM_USECS
4288    #[prost(int32, repeated, packed = "false", tag = "150101")]
4289    pub usecs: ::prost::alloc::vec::Vec<i32>,
4290}
4291#[derive(Clone, PartialEq, ::prost::Message)]
4292pub struct RequestBracketOrder {
4293    #[prost(int32, required, tag = "154467")]
4294    pub template_id: i32,
4295    #[prost(string, repeated, tag = "132760")]
4296    pub user_msg: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
4297    #[prost(string, optional, tag = "154119")]
4298    pub user_tag: ::core::option::Option<::prost::alloc::string::String>,
4299    #[prost(string, optional, tag = "154629")]
4300    pub window_name: ::core::option::Option<::prost::alloc::string::String>,
4301    #[prost(string, optional, tag = "154013")]
4302    pub fcm_id: ::core::option::Option<::prost::alloc::string::String>,
4303    #[prost(string, optional, tag = "154014")]
4304    pub ib_id: ::core::option::Option<::prost::alloc::string::String>,
4305    #[prost(string, optional, tag = "154008")]
4306    pub account_id: ::core::option::Option<::prost::alloc::string::String>,
4307    #[prost(string, optional, tag = "110100")]
4308    pub symbol: ::core::option::Option<::prost::alloc::string::String>,
4309    #[prost(string, optional, tag = "110101")]
4310    pub exchange: ::core::option::Option<::prost::alloc::string::String>,
4311    #[prost(int32, optional, tag = "112004")]
4312    pub quantity: ::core::option::Option<i32>,
4313    #[prost(double, optional, tag = "110306")]
4314    pub price: ::core::option::Option<f64>,
4315    #[prost(double, optional, tag = "149247")]
4316    pub trigger_price: ::core::option::Option<f64>,
4317    #[prost(
4318        enumeration = "request_bracket_order::TransactionType",
4319        optional,
4320        tag = "112003"
4321    )]
4322    pub transaction_type: ::core::option::Option<i32>,
4323    #[prost(
4324        enumeration = "request_bracket_order::Duration",
4325        optional,
4326        tag = "112005"
4327    )]
4328    pub duration: ::core::option::Option<i32>,
4329    #[prost(
4330        enumeration = "request_bracket_order::PriceType",
4331        optional,
4332        tag = "112008"
4333    )]
4334    pub price_type: ::core::option::Option<i32>,
4335    #[prost(string, optional, tag = "112016")]
4336    pub trade_route: ::core::option::Option<::prost::alloc::string::String>,
4337    #[prost(
4338        enumeration = "request_bracket_order::OrderPlacement",
4339        optional,
4340        tag = "154710"
4341    )]
4342    pub manual_or_auto: ::core::option::Option<i32>,
4343    #[prost(
4344        enumeration = "request_bracket_order::UserType",
4345        optional,
4346        tag = "154036"
4347    )]
4348    pub user_type: ::core::option::Option<i32>,
4349    #[prost(
4350        enumeration = "request_bracket_order::BracketType",
4351        optional,
4352        tag = "157087"
4353    )]
4354    pub bracket_type: ::core::option::Option<i32>,
4355    #[prost(int32, optional, tag = "157170")]
4356    pub break_even_ticks: ::core::option::Option<i32>,
4357    #[prost(int32, optional, tag = "157172")]
4358    pub break_even_trigger_ticks: ::core::option::Option<i32>,
4359    #[prost(int32, repeated, packed = "false", tag = "154457")]
4360    pub target_quantity: ::prost::alloc::vec::Vec<i32>,
4361    #[prost(int32, repeated, packed = "false", tag = "154456")]
4362    pub target_ticks: ::prost::alloc::vec::Vec<i32>,
4363    #[prost(int32, repeated, packed = "false", tag = "154459")]
4364    pub stop_quantity: ::prost::alloc::vec::Vec<i32>,
4365    #[prost(int32, repeated, packed = "false", tag = "154458")]
4366    pub stop_ticks: ::prost::alloc::vec::Vec<i32>,
4367    #[prost(int32, optional, tag = "157124")]
4368    pub trailing_stop_trigger_ticks: ::core::option::Option<i32>,
4369    #[prost(bool, optional, tag = "157062")]
4370    pub trailing_stop_by_last_trade_price: ::core::option::Option<bool>,
4371    #[prost(bool, optional, tag = "157151")]
4372    pub target_market_order_if_touched: ::core::option::Option<bool>,
4373    #[prost(bool, optional, tag = "154857")]
4374    pub stop_market_on_reject: ::core::option::Option<bool>,
4375    #[prost(int32, optional, tag = "157145")]
4376    pub target_market_at_ssboe: ::core::option::Option<i32>,
4377    #[prost(int32, optional, tag = "157146")]
4378    pub target_market_at_usecs: ::core::option::Option<i32>,
4379    #[prost(int32, optional, tag = "157147")]
4380    pub stop_market_at_ssboe: ::core::option::Option<i32>,
4381    #[prost(int32, optional, tag = "157148")]
4382    pub stop_market_at_usecs: ::core::option::Option<i32>,
4383    #[prost(int32, optional, tag = "157149")]
4384    pub target_market_order_after_secs: ::core::option::Option<i32>,
4385    #[prost(int32, optional, tag = "154487")]
4386    pub release_at_ssboe: ::core::option::Option<i32>,
4387    #[prost(int32, optional, tag = "154549")]
4388    pub release_at_usecs: ::core::option::Option<i32>,
4389    #[prost(int32, optional, tag = "157085")]
4390    pub cancel_at_ssboe: ::core::option::Option<i32>,
4391    #[prost(int32, optional, tag = "157086")]
4392    pub cancel_at_usecs: ::core::option::Option<i32>,
4393    #[prost(int32, optional, tag = "154488")]
4394    pub cancel_after_secs: ::core::option::Option<i32>,
4395    #[prost(string, optional, tag = "154451")]
4396    pub if_touched_symbol: ::core::option::Option<::prost::alloc::string::String>,
4397    #[prost(string, optional, tag = "154452")]
4398    pub if_touched_exchange: ::core::option::Option<::prost::alloc::string::String>,
4399    #[prost(
4400        enumeration = "request_bracket_order::Condition",
4401        optional,
4402        tag = "154453"
4403    )]
4404    pub if_touched_condition: ::core::option::Option<i32>,
4405    #[prost(
4406        enumeration = "request_bracket_order::PriceField",
4407        optional,
4408        tag = "154454"
4409    )]
4410    pub if_touched_price_field: ::core::option::Option<i32>,
4411    #[prost(double, optional, tag = "153632")]
4412    pub if_touched_price: ::core::option::Option<f64>,
4413}
4414/// Nested message and enum types in `RequestBracketOrder`.
4415pub mod request_bracket_order {
4416    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
4417    #[repr(i32)]
4418    pub enum UserType {
4419        Admin = 0,
4420        Fcm = 1,
4421        Ib = 2,
4422        Trader = 3,
4423    }
4424    impl UserType {
4425        /// String value of the enum field names used in the ProtoBuf definition.
4426        ///
4427        /// The values are not transformed in any way and thus are considered stable
4428        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
4429        pub fn as_str_name(&self) -> &'static str {
4430            match self {
4431                Self::Admin => "USER_TYPE_ADMIN",
4432                Self::Fcm => "USER_TYPE_FCM",
4433                Self::Ib => "USER_TYPE_IB",
4434                Self::Trader => "USER_TYPE_TRADER",
4435            }
4436        }
4437        /// Creates an enum from field names used in the ProtoBuf definition.
4438        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
4439            match value {
4440                "USER_TYPE_ADMIN" => Some(Self::Admin),
4441                "USER_TYPE_FCM" => Some(Self::Fcm),
4442                "USER_TYPE_IB" => Some(Self::Ib),
4443                "USER_TYPE_TRADER" => Some(Self::Trader),
4444                _ => None,
4445            }
4446        }
4447    }
4448    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
4449    #[repr(i32)]
4450    pub enum BracketType {
4451        StopOnly = 1,
4452        TargetOnly = 2,
4453        TargetAndStop = 3,
4454        StopOnlyStatic = 4,
4455        TargetOnlyStatic = 5,
4456        TargetAndStopStatic = 6,
4457    }
4458    impl BracketType {
4459        /// String value of the enum field names used in the ProtoBuf definition.
4460        ///
4461        /// The values are not transformed in any way and thus are considered stable
4462        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
4463        pub fn as_str_name(&self) -> &'static str {
4464            match self {
4465                Self::StopOnly => "STOP_ONLY",
4466                Self::TargetOnly => "TARGET_ONLY",
4467                Self::TargetAndStop => "TARGET_AND_STOP",
4468                Self::StopOnlyStatic => "STOP_ONLY_STATIC",
4469                Self::TargetOnlyStatic => "TARGET_ONLY_STATIC",
4470                Self::TargetAndStopStatic => "TARGET_AND_STOP_STATIC",
4471            }
4472        }
4473        /// Creates an enum from field names used in the ProtoBuf definition.
4474        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
4475            match value {
4476                "STOP_ONLY" => Some(Self::StopOnly),
4477                "TARGET_ONLY" => Some(Self::TargetOnly),
4478                "TARGET_AND_STOP" => Some(Self::TargetAndStop),
4479                "STOP_ONLY_STATIC" => Some(Self::StopOnlyStatic),
4480                "TARGET_ONLY_STATIC" => Some(Self::TargetOnlyStatic),
4481                "TARGET_AND_STOP_STATIC" => Some(Self::TargetAndStopStatic),
4482                _ => None,
4483            }
4484        }
4485    }
4486    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
4487    #[repr(i32)]
4488    pub enum TransactionType {
4489        Buy = 1,
4490        Sell = 2,
4491    }
4492    impl TransactionType {
4493        /// String value of the enum field names used in the ProtoBuf definition.
4494        ///
4495        /// The values are not transformed in any way and thus are considered stable
4496        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
4497        pub fn as_str_name(&self) -> &'static str {
4498            match self {
4499                Self::Buy => "BUY",
4500                Self::Sell => "SELL",
4501            }
4502        }
4503        /// Creates an enum from field names used in the ProtoBuf definition.
4504        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
4505            match value {
4506                "BUY" => Some(Self::Buy),
4507                "SELL" => Some(Self::Sell),
4508                _ => None,
4509            }
4510        }
4511    }
4512    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
4513    #[repr(i32)]
4514    pub enum Duration {
4515        Day = 1,
4516        Gtc = 2,
4517        Ioc = 3,
4518        Fok = 4,
4519    }
4520    impl Duration {
4521        /// String value of the enum field names used in the ProtoBuf definition.
4522        ///
4523        /// The values are not transformed in any way and thus are considered stable
4524        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
4525        pub fn as_str_name(&self) -> &'static str {
4526            match self {
4527                Self::Day => "DAY",
4528                Self::Gtc => "GTC",
4529                Self::Ioc => "IOC",
4530                Self::Fok => "FOK",
4531            }
4532        }
4533        /// Creates an enum from field names used in the ProtoBuf definition.
4534        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
4535            match value {
4536                "DAY" => Some(Self::Day),
4537                "GTC" => Some(Self::Gtc),
4538                "IOC" => Some(Self::Ioc),
4539                "FOK" => Some(Self::Fok),
4540                _ => None,
4541            }
4542        }
4543    }
4544    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
4545    #[repr(i32)]
4546    pub enum PriceType {
4547        Limit = 1,
4548        Market = 2,
4549        StopLimit = 3,
4550        StopMarket = 4,
4551        MarketIfTouched = 5,
4552        LimitIfTouched = 6,
4553    }
4554    impl PriceType {
4555        /// String value of the enum field names used in the ProtoBuf definition.
4556        ///
4557        /// The values are not transformed in any way and thus are considered stable
4558        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
4559        pub fn as_str_name(&self) -> &'static str {
4560            match self {
4561                Self::Limit => "LIMIT",
4562                Self::Market => "MARKET",
4563                Self::StopLimit => "STOP_LIMIT",
4564                Self::StopMarket => "STOP_MARKET",
4565                Self::MarketIfTouched => "MARKET_IF_TOUCHED",
4566                Self::LimitIfTouched => "LIMIT_IF_TOUCHED",
4567            }
4568        }
4569        /// Creates an enum from field names used in the ProtoBuf definition.
4570        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
4571            match value {
4572                "LIMIT" => Some(Self::Limit),
4573                "MARKET" => Some(Self::Market),
4574                "STOP_LIMIT" => Some(Self::StopLimit),
4575                "STOP_MARKET" => Some(Self::StopMarket),
4576                "MARKET_IF_TOUCHED" => Some(Self::MarketIfTouched),
4577                "LIMIT_IF_TOUCHED" => Some(Self::LimitIfTouched),
4578                _ => None,
4579            }
4580        }
4581    }
4582    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
4583    #[repr(i32)]
4584    pub enum OrderPlacement {
4585        Manual = 1,
4586        Auto = 2,
4587    }
4588    impl OrderPlacement {
4589        /// String value of the enum field names used in the ProtoBuf definition.
4590        ///
4591        /// The values are not transformed in any way and thus are considered stable
4592        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
4593        pub fn as_str_name(&self) -> &'static str {
4594            match self {
4595                Self::Manual => "MANUAL",
4596                Self::Auto => "AUTO",
4597            }
4598        }
4599        /// Creates an enum from field names used in the ProtoBuf definition.
4600        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
4601            match value {
4602                "MANUAL" => Some(Self::Manual),
4603                "AUTO" => Some(Self::Auto),
4604                _ => None,
4605            }
4606        }
4607    }
4608    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
4609    #[repr(i32)]
4610    pub enum PriceField {
4611        BidPrice = 1,
4612        OfferPrice = 2,
4613        TradePrice = 3,
4614        LeanPrice = 4,
4615    }
4616    impl PriceField {
4617        /// String value of the enum field names used in the ProtoBuf definition.
4618        ///
4619        /// The values are not transformed in any way and thus are considered stable
4620        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
4621        pub fn as_str_name(&self) -> &'static str {
4622            match self {
4623                Self::BidPrice => "BID_PRICE",
4624                Self::OfferPrice => "OFFER_PRICE",
4625                Self::TradePrice => "TRADE_PRICE",
4626                Self::LeanPrice => "LEAN_PRICE",
4627            }
4628        }
4629        /// Creates an enum from field names used in the ProtoBuf definition.
4630        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
4631            match value {
4632                "BID_PRICE" => Some(Self::BidPrice),
4633                "OFFER_PRICE" => Some(Self::OfferPrice),
4634                "TRADE_PRICE" => Some(Self::TradePrice),
4635                "LEAN_PRICE" => Some(Self::LeanPrice),
4636                _ => None,
4637            }
4638        }
4639    }
4640    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
4641    #[repr(i32)]
4642    pub enum Condition {
4643        EqualTo = 1,
4644        NotEqualTo = 2,
4645        GreaterThan = 3,
4646        GreaterThanEqualTo = 4,
4647        LesserThan = 5,
4648        LesserThanEqualTo = 6,
4649    }
4650    impl Condition {
4651        /// String value of the enum field names used in the ProtoBuf definition.
4652        ///
4653        /// The values are not transformed in any way and thus are considered stable
4654        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
4655        pub fn as_str_name(&self) -> &'static str {
4656            match self {
4657                Self::EqualTo => "EQUAL_TO",
4658                Self::NotEqualTo => "NOT_EQUAL_TO",
4659                Self::GreaterThan => "GREATER_THAN",
4660                Self::GreaterThanEqualTo => "GREATER_THAN_EQUAL_TO",
4661                Self::LesserThan => "LESSER_THAN",
4662                Self::LesserThanEqualTo => "LESSER_THAN_EQUAL_TO",
4663            }
4664        }
4665        /// Creates an enum from field names used in the ProtoBuf definition.
4666        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
4667            match value {
4668                "EQUAL_TO" => Some(Self::EqualTo),
4669                "NOT_EQUAL_TO" => Some(Self::NotEqualTo),
4670                "GREATER_THAN" => Some(Self::GreaterThan),
4671                "GREATER_THAN_EQUAL_TO" => Some(Self::GreaterThanEqualTo),
4672                "LESSER_THAN" => Some(Self::LesserThan),
4673                "LESSER_THAN_EQUAL_TO" => Some(Self::LesserThanEqualTo),
4674                _ => None,
4675            }
4676        }
4677    }
4678}
4679/// PB_OFFSET = 100000, is the offset added for each MNM field id
4680#[derive(Clone, PartialEq, ::prost::Message)]
4681pub struct ResponseBracketOrder {
4682    /// PB_OFFSET + MNM_TEMPLATE_ID
4683    #[prost(int32, required, tag = "154467")]
4684    pub template_id: i32,
4685    /// PB_OFFSET + MNM_USER_MSG
4686    #[prost(string, repeated, tag = "132760")]
4687    pub user_msg: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
4688    /// PB_OFFSET + MNM_USER_ORIGIN
4689    #[prost(string, optional, tag = "154119")]
4690    pub user_tag: ::core::option::Option<::prost::alloc::string::String>,
4691    /// PB_OFFSET + MNM_REQUEST_HANDLER_RESPONSE_CODE
4692    #[prost(string, repeated, tag = "132764")]
4693    pub rq_handler_rp_code: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
4694    /// PB_OFFSET + MNM_RESPONSE_CODE
4695    #[prost(string, repeated, tag = "132766")]
4696    pub rp_code: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
4697    /// PB_OFFSET + MNM_BASKET_ID
4698    #[prost(string, optional, tag = "110300")]
4699    pub basket_id: ::core::option::Option<::prost::alloc::string::String>,
4700    /// PB_OFFSET + MNM_SECONDS_SINCE_BOE
4701    #[prost(int32, optional, tag = "150100")]
4702    pub ssboe: ::core::option::Option<i32>,
4703    /// PB_OFFSET + MNM_USECS
4704    #[prost(int32, optional, tag = "150101")]
4705    pub usecs: ::core::option::Option<i32>,
4706}
4707/// PB_OFFSET = 100000, is the offset added for each MNM field id
4708#[derive(Clone, PartialEq, ::prost::Message)]
4709pub struct RequestShowBrackets {
4710    /// PB_OFFSET + MNM_TEMPLATE_ID
4711    #[prost(int32, required, tag = "154467")]
4712    pub template_id: i32,
4713    /// PB_OFFSET + MNM_USER_MSG
4714    #[prost(string, repeated, tag = "132760")]
4715    pub user_msg: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
4716    /// PB_OFFSET + MNM_FCM_ID
4717    #[prost(string, optional, tag = "154013")]
4718    pub fcm_id: ::core::option::Option<::prost::alloc::string::String>,
4719    /// PB_OFFSET + MNM_IB_ID
4720    #[prost(string, optional, tag = "154014")]
4721    pub ib_id: ::core::option::Option<::prost::alloc::string::String>,
4722    /// PB_OFFSET + MNM_ACCOUNT_ID
4723    #[prost(string, optional, tag = "154008")]
4724    pub account_id: ::core::option::Option<::prost::alloc::string::String>,
4725}
4726/// PB_OFFSET = 100000, is the offset added for each MNM field id
4727#[derive(Clone, PartialEq, ::prost::Message)]
4728pub struct ResponseShowBrackets {
4729    /// PB_OFFSET + MNM_TEMPLATE_ID
4730    #[prost(int32, required, tag = "154467")]
4731    pub template_id: i32,
4732    /// PB_OFFSET + MNM_USER_MSG
4733    #[prost(string, repeated, tag = "132760")]
4734    pub user_msg: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
4735    /// PB_OFFSET + MNM_REQUEST_HANDLER_RESPONSE_CODE
4736    #[prost(string, repeated, tag = "132764")]
4737    pub rq_handler_rp_code: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
4738    /// PB_OFFSET + MNM_RESPONSE_CODE
4739    #[prost(string, repeated, tag = "132766")]
4740    pub rp_code: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
4741    /// PB_OFFSET + MNM_BASKET_ID
4742    #[prost(string, optional, tag = "110300")]
4743    pub basket_id: ::core::option::Option<::prost::alloc::string::String>,
4744    /// PB_OFFSET + MNM_TARGET_QUANTITY
4745    #[prost(string, optional, tag = "154457")]
4746    pub target_quantity: ::core::option::Option<::prost::alloc::string::String>,
4747    /// PB_OFFSET + MNM_TARGET_QUANTITY_RELEASED
4748    #[prost(string, optional, tag = "154460")]
4749    pub target_quantity_released: ::core::option::Option<::prost::alloc::string::String>,
4750    /// PB_OFFSET + MNM_TARGET_TICKS
4751    #[prost(string, optional, tag = "154456")]
4752    pub target_ticks: ::core::option::Option<::prost::alloc::string::String>,
4753}
4754/// PB_OFFSET = 100000, is the offset added for each MNM field id
4755#[derive(Clone, PartialEq, ::prost::Message)]
4756pub struct RequestShowBracketStops {
4757    /// PB_OFFSET + MNM_TEMPLATE_ID
4758    #[prost(int32, required, tag = "154467")]
4759    pub template_id: i32,
4760    /// PB_OFFSET + MNM_USER_MSG
4761    #[prost(string, repeated, tag = "132760")]
4762    pub user_msg: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
4763    /// PB_OFFSET + MNM_FCM_ID
4764    #[prost(string, optional, tag = "154013")]
4765    pub fcm_id: ::core::option::Option<::prost::alloc::string::String>,
4766    /// PB_OFFSET + MNM_IB_ID
4767    #[prost(string, optional, tag = "154014")]
4768    pub ib_id: ::core::option::Option<::prost::alloc::string::String>,
4769    /// PB_OFFSET + MNM_ACCOUNT_ID
4770    #[prost(string, optional, tag = "154008")]
4771    pub account_id: ::core::option::Option<::prost::alloc::string::String>,
4772}
4773/// PB_OFFSET = 100000, is the offset added for each MNM field id
4774#[derive(Clone, PartialEq, ::prost::Message)]
4775pub struct ResponseShowBracketStops {
4776    /// PB_OFFSET + MNM_TEMPLATE_ID
4777    #[prost(int32, required, tag = "154467")]
4778    pub template_id: i32,
4779    /// PB_OFFSET + MNM_USER_MSG
4780    #[prost(string, repeated, tag = "132760")]
4781    pub user_msg: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
4782    /// PB_OFFSET + MNM_REQUEST_HANDLER_RESPONSE_CODE
4783    #[prost(string, repeated, tag = "132764")]
4784    pub rq_handler_rp_code: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
4785    /// PB_OFFSET + MNM_RESPONSE_CODE
4786    #[prost(string, repeated, tag = "132766")]
4787    pub rp_code: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
4788    /// PB_OFFSET + MNM_BASKET_ID
4789    #[prost(string, optional, tag = "110300")]
4790    pub basket_id: ::core::option::Option<::prost::alloc::string::String>,
4791    /// PB_OFFSET + MNM_STOP_QUANTITY
4792    #[prost(string, optional, tag = "154459")]
4793    pub stop_quantity: ::core::option::Option<::prost::alloc::string::String>,
4794    /// PB_OFFSET + MNM_STOP_QUANTITY_RELEASED
4795    #[prost(string, optional, tag = "154466")]
4796    pub stop_quantity_released: ::core::option::Option<::prost::alloc::string::String>,
4797    /// PB_OFFSET + MNM_STOP_TICKS
4798    #[prost(string, optional, tag = "154458")]
4799    pub stop_ticks: ::core::option::Option<::prost::alloc::string::String>,
4800    /// PB_OFFSET + MNM_BRACKET_TRAILING_FIELD_ID
4801    #[prost(string, optional, tag = "157062")]
4802    pub bracket_trailing_field_id: ::core::option::Option<::prost::alloc::string::String>,
4803    /// PB_OFFSET + MNM_TRAILING_STOP_TRIGGER_TICKS
4804    #[prost(string, optional, tag = "157124")]
4805    pub trailing_stop_trigger_ticks: ::core::option::Option<::prost::alloc::string::String>,
4806}
4807/// PB_OFFSET = 100000, is the offset added for each MNM field id
4808#[derive(Clone, PartialEq, ::prost::Message)]
4809pub struct RequestUpdateTargetBracketLevel {
4810    /// PB_OFFSET + MNM_TEMPLATE_ID
4811    #[prost(int32, required, tag = "154467")]
4812    pub template_id: i32,
4813    /// PB_OFFSET + MNM_USER_MSG
4814    #[prost(string, repeated, tag = "132760")]
4815    pub user_msg: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
4816    /// PB_OFFSET + MNM_FCM_ID
4817    #[prost(string, optional, tag = "154013")]
4818    pub fcm_id: ::core::option::Option<::prost::alloc::string::String>,
4819    /// PB_OFFSET + MNM_IB_ID
4820    #[prost(string, optional, tag = "154014")]
4821    pub ib_id: ::core::option::Option<::prost::alloc::string::String>,
4822    /// PB_OFFSET + MNM_ACCOUNT_ID
4823    #[prost(string, optional, tag = "154008")]
4824    pub account_id: ::core::option::Option<::prost::alloc::string::String>,
4825    /// PB_OFFSET + MNM_BASKET_ID
4826    #[prost(string, optional, tag = "110300")]
4827    pub basket_id: ::core::option::Option<::prost::alloc::string::String>,
4828    /// PB_OFFSET + MNM_LEVEL
4829    #[prost(int32, optional, tag = "154244")]
4830    pub level: ::core::option::Option<i32>,
4831    /// PB_OFFSET + MNM_TARGET_TICKS
4832    #[prost(int32, optional, tag = "154456")]
4833    pub target_ticks: ::core::option::Option<i32>,
4834}
4835/// PB_OFFSET = 100000, is the offset added for each MNM field id
4836#[derive(Clone, PartialEq, ::prost::Message)]
4837pub struct ResponseUpdateTargetBracketLevel {
4838    /// PB_OFFSET + MNM_TEMPLATE_ID
4839    #[prost(int32, required, tag = "154467")]
4840    pub template_id: i32,
4841    /// PB_OFFSET + MNM_USER_MSG
4842    #[prost(string, repeated, tag = "132760")]
4843    pub user_msg: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
4844    /// PB_OFFSET + MNM_RESPONSE_CODE
4845    #[prost(string, repeated, tag = "132766")]
4846    pub rp_code: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
4847}
4848/// PB_OFFSET = 100000, is the offset added for each MNM field id
4849#[derive(Clone, PartialEq, ::prost::Message)]
4850pub struct RequestUpdateStopBracketLevel {
4851    /// PB_OFFSET + MNM_TEMPLATE_ID
4852    #[prost(int32, required, tag = "154467")]
4853    pub template_id: i32,
4854    /// PB_OFFSET + MNM_USER_MSG
4855    #[prost(string, repeated, tag = "132760")]
4856    pub user_msg: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
4857    /// PB_OFFSET + MNM_FCM_ID
4858    #[prost(string, optional, tag = "154013")]
4859    pub fcm_id: ::core::option::Option<::prost::alloc::string::String>,
4860    /// PB_OFFSET + MNM_IB_ID
4861    #[prost(string, optional, tag = "154014")]
4862    pub ib_id: ::core::option::Option<::prost::alloc::string::String>,
4863    /// PB_OFFSET + MNM_ACCOUNT_ID
4864    #[prost(string, optional, tag = "154008")]
4865    pub account_id: ::core::option::Option<::prost::alloc::string::String>,
4866    /// PB_OFFSET + MNM_BASKET_ID
4867    #[prost(string, optional, tag = "110300")]
4868    pub basket_id: ::core::option::Option<::prost::alloc::string::String>,
4869    /// PB_OFFSET + MNM_LEVEL
4870    #[prost(int32, optional, tag = "154244")]
4871    pub level: ::core::option::Option<i32>,
4872    /// PB_OFFSET + MNM_STOP_TICKS
4873    #[prost(int32, optional, tag = "154458")]
4874    pub stop_ticks: ::core::option::Option<i32>,
4875}
4876/// PB_OFFSET = 100000, is the offset added for each MNM field id
4877#[derive(Clone, PartialEq, ::prost::Message)]
4878pub struct ResponseUpdateStopBracketLevel {
4879    /// PB_OFFSET + MNM_TEMPLATE_ID
4880    #[prost(int32, required, tag = "154467")]
4881    pub template_id: i32,
4882    /// PB_OFFSET + MNM_USER_MSG
4883    #[prost(string, repeated, tag = "132760")]
4884    pub user_msg: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
4885    /// PB_OFFSET + MNM_RESPONSE_CODE
4886    #[prost(string, repeated, tag = "132766")]
4887    pub rp_code: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
4888}
4889/// PB_OFFSET = 100000, is the offset added for each MNM field id
4890#[derive(Clone, PartialEq, ::prost::Message)]
4891pub struct RequestSubscribeToBracketUpdates {
4892    /// PB_OFFSET + MNM_TEMPLATE_ID
4893    #[prost(int32, required, tag = "154467")]
4894    pub template_id: i32,
4895    /// PB_OFFSET + MNM_USER_MSG
4896    #[prost(string, repeated, tag = "132760")]
4897    pub user_msg: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
4898    /// PB_OFFSET + MNM_FCM_ID
4899    #[prost(string, optional, tag = "154013")]
4900    pub fcm_id: ::core::option::Option<::prost::alloc::string::String>,
4901    /// PB_OFFSET + MNM_IB_ID
4902    #[prost(string, optional, tag = "154014")]
4903    pub ib_id: ::core::option::Option<::prost::alloc::string::String>,
4904    /// PB_OFFSET + MNM_ACCOUNT_ID
4905    #[prost(string, optional, tag = "154008")]
4906    pub account_id: ::core::option::Option<::prost::alloc::string::String>,
4907}
4908/// PB_OFFSET = 100000, is the offset added for each MNM field id
4909#[derive(Clone, PartialEq, ::prost::Message)]
4910pub struct ResponseSubscribeToBracketUpdates {
4911    /// PB_OFFSET + MNM_TEMPLATE_ID
4912    #[prost(int32, required, tag = "154467")]
4913    pub template_id: i32,
4914    /// PB_OFFSET + MNM_USER_MSG
4915    #[prost(string, repeated, tag = "132760")]
4916    pub user_msg: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
4917    /// PB_OFFSET + MNM_RESPONSE_CODE
4918    #[prost(string, repeated, tag = "132766")]
4919    pub rp_code: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
4920}
4921/// PB_OFFSET = 100000 , is the offset added for each MNM field id
4922#[derive(Clone, PartialEq, ::prost::Message)]
4923pub struct RequestListExchangePermissions {
4924    /// PB_OFFSET + MNM_TEMPLATE_ID
4925    #[prost(int32, required, tag = "154467")]
4926    pub template_id: i32,
4927    /// PB_OFFSET + MNM_USER_MSG
4928    #[prost(string, repeated, tag = "132760")]
4929    pub user_msg: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
4930    /// PB_OFFSET + MNM_USER_TARGET
4931    #[prost(string, optional, tag = "154220")]
4932    pub user: ::core::option::Option<::prost::alloc::string::String>,
4933}
4934/// PB_OFFSET = 100000, is the offset added for each MNM field id
4935#[derive(Clone, PartialEq, ::prost::Message)]
4936pub struct ResponseListExchangePermissions {
4937    /// PB_OFFSET + MNM_TEMPLATE_ID
4938    #[prost(int32, required, tag = "154467")]
4939    pub template_id: i32,
4940    /// PB_OFFSET + MNM_USER_MSG
4941    #[prost(string, repeated, tag = "132760")]
4942    pub user_msg: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
4943    /// PB_OFFSET + MNM_REQUEST_HANDLER_RESPONSE_CODE
4944    #[prost(string, repeated, tag = "132764")]
4945    pub rq_handler_rp_code: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
4946    /// PB_OFFSET + MNM_RESPONSE_CODE
4947    #[prost(string, repeated, tag = "132766")]
4948    pub rp_code: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
4949    /// PB_OFFSET + MNM_EXCHANGE
4950    #[prost(string, optional, tag = "110101")]
4951    pub exchange: ::core::option::Option<::prost::alloc::string::String>,
4952    /// PB_OFFSET + MNM_ENTITLEMENT_FLAG
4953    #[prost(
4954        enumeration = "response_list_exchange_permissions::EntitlementFlag",
4955        optional,
4956        tag = "153400"
4957    )]
4958    pub entitlement_flag: ::core::option::Option<i32>,
4959}
4960/// Nested message and enum types in `ResponseListExchangePermissions`.
4961pub mod response_list_exchange_permissions {
4962    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
4963    #[repr(i32)]
4964    pub enum EntitlementFlag {
4965        Enabled = 1,
4966        Disabled = 2,
4967    }
4968    impl EntitlementFlag {
4969        /// String value of the enum field names used in the ProtoBuf definition.
4970        ///
4971        /// The values are not transformed in any way and thus are considered stable
4972        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
4973        pub fn as_str_name(&self) -> &'static str {
4974            match self {
4975                Self::Enabled => "ENABLED",
4976                Self::Disabled => "DISABLED",
4977            }
4978        }
4979        /// Creates an enum from field names used in the ProtoBuf definition.
4980        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
4981            match value {
4982                "ENABLED" => Some(Self::Enabled),
4983                "DISABLED" => Some(Self::Disabled),
4984                _ => None,
4985            }
4986        }
4987    }
4988}
4989/// PB_OFFSET = 100000 , is the offset added for each MNM field id
4990#[derive(Clone, PartialEq, ::prost::Message)]
4991pub struct RequestLinkOrders {
4992    /// PB_OFFSET + MNM_TEMPLATE_ID
4993    #[prost(int32, required, tag = "154467")]
4994    pub template_id: i32,
4995    /// PB_OFFSET + MNM_USER_MSG
4996    #[prost(string, repeated, tag = "132760")]
4997    pub user_msg: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
4998    /// PB_OFFSET + MNM_FCM_ID
4999    #[prost(string, repeated, tag = "154013")]
5000    pub fcm_id: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
5001    /// PB_OFFSET + MNM_IB_ID
5002    #[prost(string, repeated, tag = "154014")]
5003    pub ib_id: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
5004    /// PB_OFFSET + MNM_ACCOUNT_ID
5005    #[prost(string, repeated, tag = "154008")]
5006    pub account_id: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
5007    /// PB_OFFSET + MNM_BASKET_ID
5008    #[prost(string, repeated, tag = "110300")]
5009    pub basket_id: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
5010}
5011/// PB_OFFSET = 100000 , is the offset added for each MNM field id
5012#[derive(Clone, PartialEq, ::prost::Message)]
5013pub struct ResponseLinkOrders {
5014    /// PB_OFFSET + MNM_TEMPLATE_ID
5015    #[prost(int32, required, tag = "154467")]
5016    pub template_id: i32,
5017    /// PB_OFFSET + MNM_USER_MSG
5018    #[prost(string, repeated, tag = "132760")]
5019    pub user_msg: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
5020    /// PB_OFFSET + MNM_RESPONSE_CODE
5021    #[prost(string, repeated, tag = "132766")]
5022    pub rp_code: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
5023}
5024/// PB_OFFSET = 100000, is the offset added for each MNM field id
5025#[derive(Clone, PartialEq, ::prost::Message)]
5026pub struct RequestEasyToBorrowList {
5027    /// PB_OFFSET + MNM_TEMPLATE_ID
5028    #[prost(int32, required, tag = "154467")]
5029    pub template_id: i32,
5030    /// PB_OFFSET + MNM_USER_MSG
5031    #[prost(string, repeated, tag = "132760")]
5032    pub user_msg: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
5033    /// PB_OFFSET + MNM_REQUEST
5034    #[prost(
5035        enumeration = "request_easy_to_borrow_list::Request",
5036        optional,
5037        tag = "100000"
5038    )]
5039    pub request: ::core::option::Option<i32>,
5040}
5041/// Nested message and enum types in `RequestEasyToBorrowList`.
5042pub mod request_easy_to_borrow_list {
5043    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
5044    #[repr(i32)]
5045    pub enum Request {
5046        Subscribe = 1,
5047        Unsubscribe = 2,
5048    }
5049    impl Request {
5050        /// String value of the enum field names used in the ProtoBuf definition.
5051        ///
5052        /// The values are not transformed in any way and thus are considered stable
5053        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
5054        pub fn as_str_name(&self) -> &'static str {
5055            match self {
5056                Self::Subscribe => "SUBSCRIBE",
5057                Self::Unsubscribe => "UNSUBSCRIBE",
5058            }
5059        }
5060        /// Creates an enum from field names used in the ProtoBuf definition.
5061        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
5062            match value {
5063                "SUBSCRIBE" => Some(Self::Subscribe),
5064                "UNSUBSCRIBE" => Some(Self::Unsubscribe),
5065                _ => None,
5066            }
5067        }
5068    }
5069}
5070/// PB_OFFSET = 100000, is the offset added for each MNM field id
5071#[derive(Clone, PartialEq, ::prost::Message)]
5072pub struct ResponseEasyToBorrowList {
5073    /// PB_OFFSET + MNM_TEMPLATE_ID
5074    #[prost(int32, required, tag = "154467")]
5075    pub template_id: i32,
5076    /// PB_OFFSET + MNM_USER_MSG
5077    #[prost(string, repeated, tag = "132760")]
5078    pub user_msg: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
5079    /// PB_OFFSET + MNM_REQUEST_HANDLER_RESPONSE_CODE
5080    #[prost(string, repeated, tag = "132764")]
5081    pub rq_handler_rp_code: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
5082    /// PB_OFFSET + MNM_RESPONSE_CODE
5083    #[prost(string, repeated, tag = "132766")]
5084    pub rp_code: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
5085    /// PB_OFFSET + MNM_BROKER_DEALER
5086    #[prost(string, optional, tag = "154612")]
5087    pub broker_dealer: ::core::option::Option<::prost::alloc::string::String>,
5088    /// PB_OFFSET + MNM_SYMBOL
5089    #[prost(string, optional, tag = "110100")]
5090    pub symbol: ::core::option::Option<::prost::alloc::string::String>,
5091    /// PB_OFFSET + MNM_SYMBOL_NAME
5092    #[prost(string, optional, tag = "100003")]
5093    pub symbol_name: ::core::option::Option<::prost::alloc::string::String>,
5094    /// PB_OFFSET + MNM_TOTAL_AVAILABLE_QTY
5095    #[prost(int32, optional, tag = "154613")]
5096    pub qty_available: ::core::option::Option<i32>,
5097    /// PB_OFFSET + MNM_TOTAL_USED_QTY
5098    #[prost(int32, optional, tag = "154614")]
5099    pub qty_needed: ::core::option::Option<i32>,
5100    /// PB_OFFSET + MNM_SHORT_LIST_INDICATOR
5101    #[prost(bool, optional, tag = "110353")]
5102    pub borrowable: ::core::option::Option<bool>,
5103}
5104#[derive(Clone, PartialEq, ::prost::Message)]
5105pub struct RequestOrderSessionConfig {
5106    #[prost(int32, required, tag = "154467")]
5107    pub template_id: i32,
5108    #[prost(string, repeated, tag = "132760")]
5109    pub user_msg: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
5110    /// used only when the server has to fetch refdata from the system instead from it's own database.
5111    #[prost(bool, optional, tag = "157750")]
5112    pub should_defer_request: ::core::option::Option<bool>,
5113}
5114#[derive(Clone, PartialEq, ::prost::Message)]
5115pub struct ResponseOrderSessionConfig {
5116    #[prost(int32, required, tag = "154467")]
5117    pub template_id: i32,
5118    #[prost(string, repeated, tag = "132760")]
5119    pub user_msg: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
5120    #[prost(string, repeated, tag = "132766")]
5121    pub rp_code: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
5122}
5123#[derive(Clone, PartialEq, ::prost::Message)]
5124pub struct RequestExitPosition {
5125    #[prost(int32, required, tag = "154467")]
5126    pub template_id: i32,
5127    #[prost(string, repeated, tag = "132760")]
5128    pub user_msg: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
5129    #[prost(string, optional, tag = "154629")]
5130    pub window_name: ::core::option::Option<::prost::alloc::string::String>,
5131    #[prost(string, optional, tag = "154013")]
5132    pub fcm_id: ::core::option::Option<::prost::alloc::string::String>,
5133    #[prost(string, optional, tag = "154014")]
5134    pub ib_id: ::core::option::Option<::prost::alloc::string::String>,
5135    #[prost(string, optional, tag = "154008")]
5136    pub account_id: ::core::option::Option<::prost::alloc::string::String>,
5137    /// optional field, if set, exchange field should also be set.
5138    #[prost(string, optional, tag = "110100")]
5139    pub symbol: ::core::option::Option<::prost::alloc::string::String>,
5140    /// optional field, if set, symbol field should also be set.
5141    #[prost(string, optional, tag = "110101")]
5142    pub exchange: ::core::option::Option<::prost::alloc::string::String>,
5143    /// optional field
5144    #[prost(string, optional, tag = "154698")]
5145    pub trading_algorithm: ::core::option::Option<::prost::alloc::string::String>,
5146    /// required field
5147    #[prost(
5148        enumeration = "request_exit_position::OrderPlacement",
5149        optional,
5150        tag = "154710"
5151    )]
5152    pub manual_or_auto: ::core::option::Option<i32>,
5153}
5154/// Nested message and enum types in `RequestExitPosition`.
5155pub mod request_exit_position {
5156    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
5157    #[repr(i32)]
5158    pub enum OrderPlacement {
5159        Manual = 1,
5160        Auto = 2,
5161    }
5162    impl OrderPlacement {
5163        /// String value of the enum field names used in the ProtoBuf definition.
5164        ///
5165        /// The values are not transformed in any way and thus are considered stable
5166        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
5167        pub fn as_str_name(&self) -> &'static str {
5168            match self {
5169                Self::Manual => "MANUAL",
5170                Self::Auto => "AUTO",
5171            }
5172        }
5173        /// Creates an enum from field names used in the ProtoBuf definition.
5174        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
5175            match value {
5176                "MANUAL" => Some(Self::Manual),
5177                "AUTO" => Some(Self::Auto),
5178                _ => None,
5179            }
5180        }
5181    }
5182}
5183#[derive(Clone, PartialEq, ::prost::Message)]
5184pub struct ResponseExitPosition {
5185    #[prost(int32, required, tag = "154467")]
5186    pub template_id: i32,
5187    #[prost(string, repeated, tag = "132760")]
5188    pub user_msg: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
5189    #[prost(string, repeated, tag = "132764")]
5190    pub rq_handler_rp_code: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
5191    #[prost(string, repeated, tag = "132766")]
5192    pub rp_code: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
5193    #[prost(string, optional, tag = "110100")]
5194    pub symbol: ::core::option::Option<::prost::alloc::string::String>,
5195    #[prost(string, optional, tag = "110101")]
5196    pub exchange: ::core::option::Option<::prost::alloc::string::String>,
5197}
5198#[derive(Clone, PartialEq, ::prost::Message)]
5199pub struct RequestReplayExecutions {
5200    #[prost(int32, required, tag = "154467")]
5201    pub template_id: i32,
5202    #[prost(string, repeated, tag = "132760")]
5203    pub user_msg: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
5204    #[prost(string, optional, tag = "154013")]
5205    pub fcm_id: ::core::option::Option<::prost::alloc::string::String>,
5206    #[prost(string, optional, tag = "154014")]
5207    pub ib_id: ::core::option::Option<::prost::alloc::string::String>,
5208    #[prost(string, optional, tag = "154008")]
5209    pub account_id: ::core::option::Option<::prost::alloc::string::String>,
5210    #[prost(int32, optional, tag = "153002")]
5211    pub start_index: ::core::option::Option<i32>,
5212    #[prost(int32, optional, tag = "153003")]
5213    pub finish_index: ::core::option::Option<i32>,
5214}
5215#[derive(Clone, PartialEq, ::prost::Message)]
5216pub struct ResponseReplayExecutions {
5217    #[prost(int32, required, tag = "154467")]
5218    pub template_id: i32,
5219    #[prost(string, repeated, tag = "132760")]
5220    pub user_msg: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
5221    #[prost(string, repeated, tag = "132766")]
5222    pub rp_code: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
5223}
5224/// PB_OFFSET = 100000, is the offset added for each MNM field id
5225#[derive(Clone, PartialEq, ::prost::Message)]
5226pub struct TradeRoute {
5227    /// PB_OFFSET + MNM_TEMPLATE_ID
5228    #[prost(int32, required, tag = "154467")]
5229    pub template_id: i32,
5230    /// PB_OFFSET + MNM_FCM_ID
5231    #[prost(string, optional, tag = "154013")]
5232    pub fcm_id: ::core::option::Option<::prost::alloc::string::String>,
5233    /// PB_OFFSET + MNM_IB_ID
5234    #[prost(string, optional, tag = "154014")]
5235    pub ib_id: ::core::option::Option<::prost::alloc::string::String>,
5236    /// PB_OFFSET + MNM_EXCHANGE
5237    #[prost(string, optional, tag = "110101")]
5238    pub exchange: ::core::option::Option<::prost::alloc::string::String>,
5239    /// PB_OFFSET + MNM_TRADE_ROUTE
5240    #[prost(string, optional, tag = "112016")]
5241    pub trade_route: ::core::option::Option<::prost::alloc::string::String>,
5242    /// PB_OFFSET + MNM_SERVICE_STATE
5243    #[prost(string, optional, tag = "131407")]
5244    pub status: ::core::option::Option<::prost::alloc::string::String>,
5245    /// PB_OFFSET + MNM_DEFAULT_ROUTE
5246    #[prost(bool, optional, tag = "154689")]
5247    pub is_default: ::core::option::Option<bool>,
5248}
5249/// PB_OFFSET = 100000, is the offset added for each MNM field id
5250#[derive(Clone, PartialEq, ::prost::Message)]
5251pub struct BracketUpdates {
5252    /// PB_OFFSET + MNM_TEMPLATE_ID
5253    #[prost(int32, required, tag = "154467")]
5254    pub template_id: i32,
5255    /// PB_OFFSET + MNM_FCM_ID
5256    #[prost(string, optional, tag = "154013")]
5257    pub fcm_id: ::core::option::Option<::prost::alloc::string::String>,
5258    /// PB_OFFSET + MNM_IB_ID
5259    #[prost(string, optional, tag = "154014")]
5260    pub ib_id: ::core::option::Option<::prost::alloc::string::String>,
5261    /// PB_OFFSET + MNM_ACCOUNT_ID
5262    #[prost(string, optional, tag = "154008")]
5263    pub account_id: ::core::option::Option<::prost::alloc::string::String>,
5264    /// PB_OFFSET + MNM_BASKET_ID
5265    #[prost(string, optional, tag = "110300")]
5266    pub basket_id: ::core::option::Option<::prost::alloc::string::String>,
5267    /// PB_OFFSET + MNM_STOP_TICKS
5268    #[prost(int32, optional, tag = "154458")]
5269    pub stop_ticks: ::core::option::Option<i32>,
5270    /// PB_OFFSET + MNM_STOP_QUANTITY
5271    #[prost(int32, optional, tag = "154459")]
5272    pub stop_quantity: ::core::option::Option<i32>,
5273    /// PB_OFFSET + MNM_STOP_QUANTITY_RELEASED
5274    #[prost(int32, optional, tag = "154466")]
5275    pub stop_quantity_released: ::core::option::Option<i32>,
5276    /// PB_OFFSET + MNM_TARGET_TICKS
5277    #[prost(int32, optional, tag = "154456")]
5278    pub target_ticks: ::core::option::Option<i32>,
5279    /// PB_OFFSET + MNM_TARGET_QUANTITY
5280    #[prost(int32, optional, tag = "154457")]
5281    pub target_quantity: ::core::option::Option<i32>,
5282    /// PB_OFFSET + MNM_TARGET_QUANTITY_RELEASED
5283    #[prost(int32, optional, tag = "154460")]
5284    pub target_quantity_released: ::core::option::Option<i32>,
5285}
5286#[derive(Clone, PartialEq, ::prost::Message)]
5287pub struct RithmicOrderNotification {
5288    #[prost(int32, required, tag = "154467")]
5289    pub template_id: i32,
5290    #[prost(string, optional, tag = "154119")]
5291    pub user_tag: ::core::option::Option<::prost::alloc::string::String>,
5292    #[prost(
5293        enumeration = "rithmic_order_notification::NotifyType",
5294        optional,
5295        tag = "153625"
5296    )]
5297    pub notify_type: ::core::option::Option<i32>,
5298    #[prost(bool, optional, tag = "110121")]
5299    pub is_snapshot: ::core::option::Option<bool>,
5300    #[prost(string, optional, tag = "110303")]
5301    pub status: ::core::option::Option<::prost::alloc::string::String>,
5302    #[prost(string, optional, tag = "110300")]
5303    pub basket_id: ::core::option::Option<::prost::alloc::string::String>,
5304    #[prost(string, optional, tag = "154497")]
5305    pub original_basket_id: ::core::option::Option<::prost::alloc::string::String>,
5306    #[prost(string, optional, tag = "110358")]
5307    pub linked_basket_ids: ::core::option::Option<::prost::alloc::string::String>,
5308    #[prost(string, optional, tag = "154013")]
5309    pub fcm_id: ::core::option::Option<::prost::alloc::string::String>,
5310    #[prost(string, optional, tag = "154014")]
5311    pub ib_id: ::core::option::Option<::prost::alloc::string::String>,
5312    #[prost(string, optional, tag = "131003")]
5313    pub user_id: ::core::option::Option<::prost::alloc::string::String>,
5314    #[prost(string, optional, tag = "154008")]
5315    pub account_id: ::core::option::Option<::prost::alloc::string::String>,
5316    #[prost(string, optional, tag = "110100")]
5317    pub symbol: ::core::option::Option<::prost::alloc::string::String>,
5318    #[prost(string, optional, tag = "110101")]
5319    pub exchange: ::core::option::Option<::prost::alloc::string::String>,
5320    #[prost(string, optional, tag = "112021")]
5321    pub trade_exchange: ::core::option::Option<::prost::alloc::string::String>,
5322    #[prost(string, optional, tag = "112016")]
5323    pub trade_route: ::core::option::Option<::prost::alloc::string::String>,
5324    #[prost(string, optional, tag = "149238")]
5325    pub exchange_order_id: ::core::option::Option<::prost::alloc::string::String>,
5326    #[prost(string, optional, tag = "110116")]
5327    pub instrument_type: ::core::option::Option<::prost::alloc::string::String>,
5328    #[prost(string, optional, tag = "149273")]
5329    pub completion_reason: ::core::option::Option<::prost::alloc::string::String>,
5330    #[prost(int32, optional, tag = "112004")]
5331    pub quantity: ::core::option::Option<i32>,
5332    #[prost(int32, optional, tag = "112027")]
5333    pub quan_release_pending: ::core::option::Option<i32>,
5334    #[prost(double, optional, tag = "110306")]
5335    pub price: ::core::option::Option<f64>,
5336    #[prost(double, optional, tag = "149247")]
5337    pub trigger_price: ::core::option::Option<f64>,
5338    #[prost(
5339        enumeration = "rithmic_order_notification::TransactionType",
5340        optional,
5341        tag = "112003"
5342    )]
5343    pub transaction_type: ::core::option::Option<i32>,
5344    #[prost(
5345        enumeration = "rithmic_order_notification::Duration",
5346        optional,
5347        tag = "112005"
5348    )]
5349    pub duration: ::core::option::Option<i32>,
5350    #[prost(
5351        enumeration = "rithmic_order_notification::PriceType",
5352        optional,
5353        tag = "112008"
5354    )]
5355    pub price_type: ::core::option::Option<i32>,
5356    #[prost(
5357        enumeration = "rithmic_order_notification::PriceType",
5358        optional,
5359        tag = "154770"
5360    )]
5361    pub orig_price_type: ::core::option::Option<i32>,
5362    #[prost(
5363        enumeration = "rithmic_order_notification::OrderPlacement",
5364        optional,
5365        tag = "154710"
5366    )]
5367    pub manual_or_auto: ::core::option::Option<i32>,
5368    #[prost(
5369        enumeration = "rithmic_order_notification::BracketType",
5370        optional,
5371        tag = "157087"
5372    )]
5373    pub bracket_type: ::core::option::Option<i32>,
5374    #[prost(double, optional, tag = "110322")]
5375    pub avg_fill_price: ::core::option::Option<f64>,
5376    #[prost(int32, optional, tag = "154111")]
5377    pub total_fill_size: ::core::option::Option<i32>,
5378    #[prost(int32, optional, tag = "154112")]
5379    pub total_unfilled_size: ::core::option::Option<i32>,
5380    #[prost(int32, optional, tag = "157064")]
5381    pub trail_by_ticks: ::core::option::Option<i32>,
5382    #[prost(int32, optional, tag = "157065")]
5383    pub trail_by_price_id: ::core::option::Option<i32>,
5384    #[prost(string, optional, tag = "112002")]
5385    pub sequence_number: ::core::option::Option<::prost::alloc::string::String>,
5386    #[prost(string, optional, tag = "149263")]
5387    pub orig_sequence_number: ::core::option::Option<::prost::alloc::string::String>,
5388    #[prost(string, optional, tag = "149264")]
5389    pub cor_sequence_number: ::core::option::Option<::prost::alloc::string::String>,
5390    #[prost(string, optional, tag = "154382")]
5391    pub currency: ::core::option::Option<::prost::alloc::string::String>,
5392    #[prost(string, optional, tag = "154172")]
5393    pub country_code: ::core::option::Option<::prost::alloc::string::String>,
5394    #[prost(string, optional, tag = "120008")]
5395    pub text: ::core::option::Option<::prost::alloc::string::String>,
5396    #[prost(string, optional, tag = "120028")]
5397    pub report_text: ::core::option::Option<::prost::alloc::string::String>,
5398    #[prost(string, optional, tag = "154806")]
5399    pub remarks: ::core::option::Option<::prost::alloc::string::String>,
5400    #[prost(string, optional, tag = "154629")]
5401    pub window_name: ::core::option::Option<::prost::alloc::string::String>,
5402    #[prost(string, optional, tag = "154671")]
5403    pub originator_window_name: ::core::option::Option<::prost::alloc::string::String>,
5404    #[prost(int32, optional, tag = "157085")]
5405    pub cancel_at_ssboe: ::core::option::Option<i32>,
5406    #[prost(int32, optional, tag = "157086")]
5407    pub cancel_at_usecs: ::core::option::Option<i32>,
5408    #[prost(int32, optional, tag = "154488")]
5409    pub cancel_after_secs: ::core::option::Option<i32>,
5410    #[prost(int32, optional, tag = "150100")]
5411    pub ssboe: ::core::option::Option<i32>,
5412    #[prost(int32, optional, tag = "150101")]
5413    pub usecs: ::core::option::Option<i32>,
5414}
5415/// Nested message and enum types in `RithmicOrderNotification`.
5416pub mod rithmic_order_notification {
5417    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
5418    #[repr(i32)]
5419    pub enum NotifyType {
5420        OrderRcvdFromClnt = 1,
5421        ModifyRcvdFromClnt = 2,
5422        CancelRcvdFromClnt = 3,
5423        OpenPending = 4,
5424        ModifyPending = 5,
5425        CancelPending = 6,
5426        OrderRcvdByExchGtwy = 7,
5427        ModifyRcvdByExchGtwy = 8,
5428        CancelRcvdByExchGtwy = 9,
5429        OrderSentToExch = 10,
5430        ModifySentToExch = 11,
5431        CancelSentToExch = 12,
5432        Open = 13,
5433        Modified = 14,
5434        Complete = 15,
5435        ModificationFailed = 16,
5436        CancellationFailed = 17,
5437        TriggerPending = 18,
5438        Generic = 19,
5439        LinkOrdersFailed = 20,
5440    }
5441    impl NotifyType {
5442        /// String value of the enum field names used in the ProtoBuf definition.
5443        ///
5444        /// The values are not transformed in any way and thus are considered stable
5445        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
5446        pub fn as_str_name(&self) -> &'static str {
5447            match self {
5448                Self::OrderRcvdFromClnt => "ORDER_RCVD_FROM_CLNT",
5449                Self::ModifyRcvdFromClnt => "MODIFY_RCVD_FROM_CLNT",
5450                Self::CancelRcvdFromClnt => "CANCEL_RCVD_FROM_CLNT",
5451                Self::OpenPending => "OPEN_PENDING",
5452                Self::ModifyPending => "MODIFY_PENDING",
5453                Self::CancelPending => "CANCEL_PENDING",
5454                Self::OrderRcvdByExchGtwy => "ORDER_RCVD_BY_EXCH_GTWY",
5455                Self::ModifyRcvdByExchGtwy => "MODIFY_RCVD_BY_EXCH_GTWY",
5456                Self::CancelRcvdByExchGtwy => "CANCEL_RCVD_BY_EXCH_GTWY",
5457                Self::OrderSentToExch => "ORDER_SENT_TO_EXCH",
5458                Self::ModifySentToExch => "MODIFY_SENT_TO_EXCH",
5459                Self::CancelSentToExch => "CANCEL_SENT_TO_EXCH",
5460                Self::Open => "OPEN",
5461                Self::Modified => "MODIFIED",
5462                Self::Complete => "COMPLETE",
5463                Self::ModificationFailed => "MODIFICATION_FAILED",
5464                Self::CancellationFailed => "CANCELLATION_FAILED",
5465                Self::TriggerPending => "TRIGGER_PENDING",
5466                Self::Generic => "GENERIC",
5467                Self::LinkOrdersFailed => "LINK_ORDERS_FAILED",
5468            }
5469        }
5470        /// Creates an enum from field names used in the ProtoBuf definition.
5471        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
5472            match value {
5473                "ORDER_RCVD_FROM_CLNT" => Some(Self::OrderRcvdFromClnt),
5474                "MODIFY_RCVD_FROM_CLNT" => Some(Self::ModifyRcvdFromClnt),
5475                "CANCEL_RCVD_FROM_CLNT" => Some(Self::CancelRcvdFromClnt),
5476                "OPEN_PENDING" => Some(Self::OpenPending),
5477                "MODIFY_PENDING" => Some(Self::ModifyPending),
5478                "CANCEL_PENDING" => Some(Self::CancelPending),
5479                "ORDER_RCVD_BY_EXCH_GTWY" => Some(Self::OrderRcvdByExchGtwy),
5480                "MODIFY_RCVD_BY_EXCH_GTWY" => Some(Self::ModifyRcvdByExchGtwy),
5481                "CANCEL_RCVD_BY_EXCH_GTWY" => Some(Self::CancelRcvdByExchGtwy),
5482                "ORDER_SENT_TO_EXCH" => Some(Self::OrderSentToExch),
5483                "MODIFY_SENT_TO_EXCH" => Some(Self::ModifySentToExch),
5484                "CANCEL_SENT_TO_EXCH" => Some(Self::CancelSentToExch),
5485                "OPEN" => Some(Self::Open),
5486                "MODIFIED" => Some(Self::Modified),
5487                "COMPLETE" => Some(Self::Complete),
5488                "MODIFICATION_FAILED" => Some(Self::ModificationFailed),
5489                "CANCELLATION_FAILED" => Some(Self::CancellationFailed),
5490                "TRIGGER_PENDING" => Some(Self::TriggerPending),
5491                "GENERIC" => Some(Self::Generic),
5492                "LINK_ORDERS_FAILED" => Some(Self::LinkOrdersFailed),
5493                _ => None,
5494            }
5495        }
5496    }
5497    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
5498    #[repr(i32)]
5499    pub enum TransactionType {
5500        Buy = 1,
5501        Sell = 2,
5502        Ss = 3,
5503    }
5504    impl TransactionType {
5505        /// String value of the enum field names used in the ProtoBuf definition.
5506        ///
5507        /// The values are not transformed in any way and thus are considered stable
5508        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
5509        pub fn as_str_name(&self) -> &'static str {
5510            match self {
5511                Self::Buy => "BUY",
5512                Self::Sell => "SELL",
5513                Self::Ss => "SS",
5514            }
5515        }
5516        /// Creates an enum from field names used in the ProtoBuf definition.
5517        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
5518            match value {
5519                "BUY" => Some(Self::Buy),
5520                "SELL" => Some(Self::Sell),
5521                "SS" => Some(Self::Ss),
5522                _ => None,
5523            }
5524        }
5525    }
5526    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
5527    #[repr(i32)]
5528    pub enum Duration {
5529        Day = 1,
5530        Gtc = 2,
5531        Ioc = 3,
5532        Fok = 4,
5533    }
5534    impl Duration {
5535        /// String value of the enum field names used in the ProtoBuf definition.
5536        ///
5537        /// The values are not transformed in any way and thus are considered stable
5538        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
5539        pub fn as_str_name(&self) -> &'static str {
5540            match self {
5541                Self::Day => "DAY",
5542                Self::Gtc => "GTC",
5543                Self::Ioc => "IOC",
5544                Self::Fok => "FOK",
5545            }
5546        }
5547        /// Creates an enum from field names used in the ProtoBuf definition.
5548        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
5549            match value {
5550                "DAY" => Some(Self::Day),
5551                "GTC" => Some(Self::Gtc),
5552                "IOC" => Some(Self::Ioc),
5553                "FOK" => Some(Self::Fok),
5554                _ => None,
5555            }
5556        }
5557    }
5558    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
5559    #[repr(i32)]
5560    pub enum PriceType {
5561        Limit = 1,
5562        Market = 2,
5563        StopLimit = 3,
5564        StopMarket = 4,
5565    }
5566    impl PriceType {
5567        /// String value of the enum field names used in the ProtoBuf definition.
5568        ///
5569        /// The values are not transformed in any way and thus are considered stable
5570        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
5571        pub fn as_str_name(&self) -> &'static str {
5572            match self {
5573                Self::Limit => "LIMIT",
5574                Self::Market => "MARKET",
5575                Self::StopLimit => "STOP_LIMIT",
5576                Self::StopMarket => "STOP_MARKET",
5577            }
5578        }
5579        /// Creates an enum from field names used in the ProtoBuf definition.
5580        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
5581            match value {
5582                "LIMIT" => Some(Self::Limit),
5583                "MARKET" => Some(Self::Market),
5584                "STOP_LIMIT" => Some(Self::StopLimit),
5585                "STOP_MARKET" => Some(Self::StopMarket),
5586                _ => None,
5587            }
5588        }
5589    }
5590    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
5591    #[repr(i32)]
5592    pub enum BracketType {
5593        StopOnly = 1,
5594        TargetOnly = 2,
5595        TargetAndStop = 3,
5596        StopOnlyStatic = 4,
5597        TargetOnlyStatic = 5,
5598        TargetAndStopStatic = 6,
5599    }
5600    impl BracketType {
5601        /// String value of the enum field names used in the ProtoBuf definition.
5602        ///
5603        /// The values are not transformed in any way and thus are considered stable
5604        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
5605        pub fn as_str_name(&self) -> &'static str {
5606            match self {
5607                Self::StopOnly => "STOP_ONLY",
5608                Self::TargetOnly => "TARGET_ONLY",
5609                Self::TargetAndStop => "TARGET_AND_STOP",
5610                Self::StopOnlyStatic => "STOP_ONLY_STATIC",
5611                Self::TargetOnlyStatic => "TARGET_ONLY_STATIC",
5612                Self::TargetAndStopStatic => "TARGET_AND_STOP_STATIC",
5613            }
5614        }
5615        /// Creates an enum from field names used in the ProtoBuf definition.
5616        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
5617            match value {
5618                "STOP_ONLY" => Some(Self::StopOnly),
5619                "TARGET_ONLY" => Some(Self::TargetOnly),
5620                "TARGET_AND_STOP" => Some(Self::TargetAndStop),
5621                "STOP_ONLY_STATIC" => Some(Self::StopOnlyStatic),
5622                "TARGET_ONLY_STATIC" => Some(Self::TargetOnlyStatic),
5623                "TARGET_AND_STOP_STATIC" => Some(Self::TargetAndStopStatic),
5624                _ => None,
5625            }
5626        }
5627    }
5628    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
5629    #[repr(i32)]
5630    pub enum OrderPlacement {
5631        Manual = 1,
5632        Auto = 2,
5633    }
5634    impl OrderPlacement {
5635        /// String value of the enum field names used in the ProtoBuf definition.
5636        ///
5637        /// The values are not transformed in any way and thus are considered stable
5638        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
5639        pub fn as_str_name(&self) -> &'static str {
5640            match self {
5641                Self::Manual => "MANUAL",
5642                Self::Auto => "AUTO",
5643            }
5644        }
5645        /// Creates an enum from field names used in the ProtoBuf definition.
5646        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
5647            match value {
5648                "MANUAL" => Some(Self::Manual),
5649                "AUTO" => Some(Self::Auto),
5650                _ => None,
5651            }
5652        }
5653    }
5654}
5655#[derive(Clone, PartialEq, ::prost::Message)]
5656pub struct ExchangeOrderNotification {
5657    #[prost(int32, required, tag = "154467")]
5658    pub template_id: i32,
5659    #[prost(string, optional, tag = "154119")]
5660    pub user_tag: ::core::option::Option<::prost::alloc::string::String>,
5661    #[prost(
5662        enumeration = "exchange_order_notification::NotifyType",
5663        optional,
5664        tag = "153625"
5665    )]
5666    pub notify_type: ::core::option::Option<i32>,
5667    #[prost(bool, optional, tag = "110121")]
5668    pub is_snapshot: ::core::option::Option<bool>,
5669    #[prost(bool, optional, tag = "149373")]
5670    pub is_rithmic_internal_msg: ::core::option::Option<bool>,
5671    #[prost(string, optional, tag = "120001")]
5672    pub report_type: ::core::option::Option<::prost::alloc::string::String>,
5673    #[prost(string, optional, tag = "110303")]
5674    pub status: ::core::option::Option<::prost::alloc::string::String>,
5675    #[prost(string, optional, tag = "110300")]
5676    pub basket_id: ::core::option::Option<::prost::alloc::string::String>,
5677    #[prost(string, optional, tag = "154497")]
5678    pub original_basket_id: ::core::option::Option<::prost::alloc::string::String>,
5679    #[prost(string, optional, tag = "110358")]
5680    pub linked_basket_ids: ::core::option::Option<::prost::alloc::string::String>,
5681    #[prost(string, optional, tag = "154013")]
5682    pub fcm_id: ::core::option::Option<::prost::alloc::string::String>,
5683    #[prost(string, optional, tag = "154014")]
5684    pub ib_id: ::core::option::Option<::prost::alloc::string::String>,
5685    #[prost(string, optional, tag = "131003")]
5686    pub user_id: ::core::option::Option<::prost::alloc::string::String>,
5687    #[prost(string, optional, tag = "154008")]
5688    pub account_id: ::core::option::Option<::prost::alloc::string::String>,
5689    #[prost(string, optional, tag = "110100")]
5690    pub symbol: ::core::option::Option<::prost::alloc::string::String>,
5691    #[prost(string, optional, tag = "110101")]
5692    pub exchange: ::core::option::Option<::prost::alloc::string::String>,
5693    #[prost(string, optional, tag = "112021")]
5694    pub trade_exchange: ::core::option::Option<::prost::alloc::string::String>,
5695    #[prost(string, optional, tag = "112016")]
5696    pub trade_route: ::core::option::Option<::prost::alloc::string::String>,
5697    #[prost(string, optional, tag = "149238")]
5698    pub exchange_order_id: ::core::option::Option<::prost::alloc::string::String>,
5699    #[prost(string, optional, tag = "153647")]
5700    pub tp_exchange_order_id: ::core::option::Option<::prost::alloc::string::String>,
5701    #[prost(string, optional, tag = "110116")]
5702    pub instrument_type: ::core::option::Option<::prost::alloc::string::String>,
5703    #[prost(int32, optional, tag = "112004")]
5704    pub quantity: ::core::option::Option<i32>,
5705    #[prost(double, optional, tag = "110306")]
5706    pub price: ::core::option::Option<f64>,
5707    #[prost(double, optional, tag = "149247")]
5708    pub trigger_price: ::core::option::Option<f64>,
5709    #[prost(
5710        enumeration = "exchange_order_notification::TransactionType",
5711        optional,
5712        tag = "112003"
5713    )]
5714    pub transaction_type: ::core::option::Option<i32>,
5715    #[prost(
5716        enumeration = "exchange_order_notification::Duration",
5717        optional,
5718        tag = "112005"
5719    )]
5720    pub duration: ::core::option::Option<i32>,
5721    #[prost(
5722        enumeration = "exchange_order_notification::PriceType",
5723        optional,
5724        tag = "112008"
5725    )]
5726    pub price_type: ::core::option::Option<i32>,
5727    #[prost(
5728        enumeration = "exchange_order_notification::PriceType",
5729        optional,
5730        tag = "154770"
5731    )]
5732    pub orig_price_type: ::core::option::Option<i32>,
5733    #[prost(
5734        enumeration = "exchange_order_notification::OrderPlacement",
5735        optional,
5736        tag = "154710"
5737    )]
5738    pub manual_or_auto: ::core::option::Option<i32>,
5739    #[prost(
5740        enumeration = "exchange_order_notification::BracketType",
5741        optional,
5742        tag = "157087"
5743    )]
5744    pub bracket_type: ::core::option::Option<i32>,
5745    #[prost(int32, optional, tag = "110329")]
5746    pub confirmed_size: ::core::option::Option<i32>,
5747    #[prost(string, optional, tag = "110326")]
5748    pub confirmed_time: ::core::option::Option<::prost::alloc::string::String>,
5749    #[prost(string, optional, tag = "110327")]
5750    pub confirmed_date: ::core::option::Option<::prost::alloc::string::String>,
5751    #[prost(string, optional, tag = "110330")]
5752    pub confirmed_id: ::core::option::Option<::prost::alloc::string::String>,
5753    #[prost(int32, optional, tag = "149267")]
5754    pub modified_size: ::core::option::Option<i32>,
5755    #[prost(string, optional, tag = "149268")]
5756    pub modified_time: ::core::option::Option<::prost::alloc::string::String>,
5757    #[prost(string, optional, tag = "149269")]
5758    pub modified_date: ::core::option::Option<::prost::alloc::string::String>,
5759    #[prost(string, optional, tag = "149244")]
5760    pub modify_id: ::core::option::Option<::prost::alloc::string::String>,
5761    #[prost(int32, optional, tag = "110318")]
5762    pub cancelled_size: ::core::option::Option<i32>,
5763    #[prost(string, optional, tag = "110319")]
5764    pub cancelled_time: ::core::option::Option<::prost::alloc::string::String>,
5765    #[prost(string, optional, tag = "110320")]
5766    pub cancelled_date: ::core::option::Option<::prost::alloc::string::String>,
5767    #[prost(string, optional, tag = "110321")]
5768    pub cancelled_id: ::core::option::Option<::prost::alloc::string::String>,
5769    #[prost(double, optional, tag = "110307")]
5770    pub fill_price: ::core::option::Option<f64>,
5771    #[prost(int32, optional, tag = "110308")]
5772    pub fill_size: ::core::option::Option<i32>,
5773    #[prost(string, optional, tag = "110309")]
5774    pub fill_time: ::core::option::Option<::prost::alloc::string::String>,
5775    #[prost(string, optional, tag = "110310")]
5776    pub fill_date: ::core::option::Option<::prost::alloc::string::String>,
5777    #[prost(string, optional, tag = "110311")]
5778    pub fill_id: ::core::option::Option<::prost::alloc::string::String>,
5779    #[prost(double, optional, tag = "110322")]
5780    pub avg_fill_price: ::core::option::Option<f64>,
5781    #[prost(int32, optional, tag = "154111")]
5782    pub total_fill_size: ::core::option::Option<i32>,
5783    #[prost(int32, optional, tag = "154112")]
5784    pub total_unfilled_size: ::core::option::Option<i32>,
5785    #[prost(string, optional, tag = "149266")]
5786    pub trigger_id: ::core::option::Option<::prost::alloc::string::String>,
5787    #[prost(int32, optional, tag = "157064")]
5788    pub trail_by_ticks: ::core::option::Option<i32>,
5789    #[prost(int32, optional, tag = "157065")]
5790    pub trail_by_price_id: ::core::option::Option<i32>,
5791    #[prost(string, optional, tag = "112002")]
5792    pub sequence_number: ::core::option::Option<::prost::alloc::string::String>,
5793    #[prost(string, optional, tag = "149263")]
5794    pub orig_sequence_number: ::core::option::Option<::prost::alloc::string::String>,
5795    #[prost(string, optional, tag = "149264")]
5796    pub cor_sequence_number: ::core::option::Option<::prost::alloc::string::String>,
5797    #[prost(string, optional, tag = "154382")]
5798    pub currency: ::core::option::Option<::prost::alloc::string::String>,
5799    #[prost(string, optional, tag = "154172")]
5800    pub country_code: ::core::option::Option<::prost::alloc::string::String>,
5801    #[prost(string, optional, tag = "120008")]
5802    pub text: ::core::option::Option<::prost::alloc::string::String>,
5803    #[prost(string, optional, tag = "120028")]
5804    pub report_text: ::core::option::Option<::prost::alloc::string::String>,
5805    #[prost(string, optional, tag = "154806")]
5806    pub remarks: ::core::option::Option<::prost::alloc::string::String>,
5807    #[prost(string, optional, tag = "154629")]
5808    pub window_name: ::core::option::Option<::prost::alloc::string::String>,
5809    #[prost(string, optional, tag = "154671")]
5810    pub originator_window_name: ::core::option::Option<::prost::alloc::string::String>,
5811    #[prost(int32, optional, tag = "157085")]
5812    pub cancel_at_ssboe: ::core::option::Option<i32>,
5813    #[prost(int32, optional, tag = "157086")]
5814    pub cancel_at_usecs: ::core::option::Option<i32>,
5815    #[prost(int32, optional, tag = "154488")]
5816    pub cancel_after_secs: ::core::option::Option<i32>,
5817    #[prost(int32, optional, tag = "150100")]
5818    pub ssboe: ::core::option::Option<i32>,
5819    #[prost(int32, optional, tag = "150101")]
5820    pub usecs: ::core::option::Option<i32>,
5821    #[prost(int32, optional, tag = "150405")]
5822    pub exch_receipt_ssboe: ::core::option::Option<i32>,
5823    #[prost(int32, optional, tag = "150406")]
5824    pub exch_receipt_nsecs: ::core::option::Option<i32>,
5825}
5826/// Nested message and enum types in `ExchangeOrderNotification`.
5827pub mod exchange_order_notification {
5828    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
5829    #[repr(i32)]
5830    pub enum NotifyType {
5831        Status = 1,
5832        Modify = 2,
5833        Cancel = 3,
5834        Trigger = 4,
5835        Fill = 5,
5836        Reject = 6,
5837        NotModified = 7,
5838        NotCancelled = 8,
5839        Generic = 9,
5840    }
5841    impl NotifyType {
5842        /// String value of the enum field names used in the ProtoBuf definition.
5843        ///
5844        /// The values are not transformed in any way and thus are considered stable
5845        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
5846        pub fn as_str_name(&self) -> &'static str {
5847            match self {
5848                Self::Status => "STATUS",
5849                Self::Modify => "MODIFY",
5850                Self::Cancel => "CANCEL",
5851                Self::Trigger => "TRIGGER",
5852                Self::Fill => "FILL",
5853                Self::Reject => "REJECT",
5854                Self::NotModified => "NOT_MODIFIED",
5855                Self::NotCancelled => "NOT_CANCELLED",
5856                Self::Generic => "GENERIC",
5857            }
5858        }
5859        /// Creates an enum from field names used in the ProtoBuf definition.
5860        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
5861            match value {
5862                "STATUS" => Some(Self::Status),
5863                "MODIFY" => Some(Self::Modify),
5864                "CANCEL" => Some(Self::Cancel),
5865                "TRIGGER" => Some(Self::Trigger),
5866                "FILL" => Some(Self::Fill),
5867                "REJECT" => Some(Self::Reject),
5868                "NOT_MODIFIED" => Some(Self::NotModified),
5869                "NOT_CANCELLED" => Some(Self::NotCancelled),
5870                "GENERIC" => Some(Self::Generic),
5871                _ => None,
5872            }
5873        }
5874    }
5875    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
5876    #[repr(i32)]
5877    pub enum TransactionType {
5878        Buy = 1,
5879        Sell = 2,
5880        Ss = 3,
5881    }
5882    impl TransactionType {
5883        /// String value of the enum field names used in the ProtoBuf definition.
5884        ///
5885        /// The values are not transformed in any way and thus are considered stable
5886        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
5887        pub fn as_str_name(&self) -> &'static str {
5888            match self {
5889                Self::Buy => "BUY",
5890                Self::Sell => "SELL",
5891                Self::Ss => "SS",
5892            }
5893        }
5894        /// Creates an enum from field names used in the ProtoBuf definition.
5895        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
5896            match value {
5897                "BUY" => Some(Self::Buy),
5898                "SELL" => Some(Self::Sell),
5899                "SS" => Some(Self::Ss),
5900                _ => None,
5901            }
5902        }
5903    }
5904    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
5905    #[repr(i32)]
5906    pub enum Duration {
5907        Day = 1,
5908        Gtc = 2,
5909        Ioc = 3,
5910        Fok = 4,
5911    }
5912    impl Duration {
5913        /// String value of the enum field names used in the ProtoBuf definition.
5914        ///
5915        /// The values are not transformed in any way and thus are considered stable
5916        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
5917        pub fn as_str_name(&self) -> &'static str {
5918            match self {
5919                Self::Day => "DAY",
5920                Self::Gtc => "GTC",
5921                Self::Ioc => "IOC",
5922                Self::Fok => "FOK",
5923            }
5924        }
5925        /// Creates an enum from field names used in the ProtoBuf definition.
5926        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
5927            match value {
5928                "DAY" => Some(Self::Day),
5929                "GTC" => Some(Self::Gtc),
5930                "IOC" => Some(Self::Ioc),
5931                "FOK" => Some(Self::Fok),
5932                _ => None,
5933            }
5934        }
5935    }
5936    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
5937    #[repr(i32)]
5938    pub enum PriceType {
5939        Limit = 1,
5940        Market = 2,
5941        StopLimit = 3,
5942        StopMarket = 4,
5943    }
5944    impl PriceType {
5945        /// String value of the enum field names used in the ProtoBuf definition.
5946        ///
5947        /// The values are not transformed in any way and thus are considered stable
5948        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
5949        pub fn as_str_name(&self) -> &'static str {
5950            match self {
5951                Self::Limit => "LIMIT",
5952                Self::Market => "MARKET",
5953                Self::StopLimit => "STOP_LIMIT",
5954                Self::StopMarket => "STOP_MARKET",
5955            }
5956        }
5957        /// Creates an enum from field names used in the ProtoBuf definition.
5958        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
5959            match value {
5960                "LIMIT" => Some(Self::Limit),
5961                "MARKET" => Some(Self::Market),
5962                "STOP_LIMIT" => Some(Self::StopLimit),
5963                "STOP_MARKET" => Some(Self::StopMarket),
5964                _ => None,
5965            }
5966        }
5967    }
5968    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
5969    #[repr(i32)]
5970    pub enum BracketType {
5971        StopOnly = 1,
5972        TargetOnly = 2,
5973        TargetAndStop = 3,
5974        StopOnlyStatic = 4,
5975        TargetOnlyStatic = 5,
5976        TargetAndStopStatic = 6,
5977    }
5978    impl BracketType {
5979        /// String value of the enum field names used in the ProtoBuf definition.
5980        ///
5981        /// The values are not transformed in any way and thus are considered stable
5982        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
5983        pub fn as_str_name(&self) -> &'static str {
5984            match self {
5985                Self::StopOnly => "STOP_ONLY",
5986                Self::TargetOnly => "TARGET_ONLY",
5987                Self::TargetAndStop => "TARGET_AND_STOP",
5988                Self::StopOnlyStatic => "STOP_ONLY_STATIC",
5989                Self::TargetOnlyStatic => "TARGET_ONLY_STATIC",
5990                Self::TargetAndStopStatic => "TARGET_AND_STOP_STATIC",
5991            }
5992        }
5993        /// Creates an enum from field names used in the ProtoBuf definition.
5994        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
5995            match value {
5996                "STOP_ONLY" => Some(Self::StopOnly),
5997                "TARGET_ONLY" => Some(Self::TargetOnly),
5998                "TARGET_AND_STOP" => Some(Self::TargetAndStop),
5999                "STOP_ONLY_STATIC" => Some(Self::StopOnlyStatic),
6000                "TARGET_ONLY_STATIC" => Some(Self::TargetOnlyStatic),
6001                "TARGET_AND_STOP_STATIC" => Some(Self::TargetAndStopStatic),
6002                _ => None,
6003            }
6004        }
6005    }
6006    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
6007    #[repr(i32)]
6008    pub enum OrderPlacement {
6009        Manual = 1,
6010        Auto = 2,
6011    }
6012    impl OrderPlacement {
6013        /// String value of the enum field names used in the ProtoBuf definition.
6014        ///
6015        /// The values are not transformed in any way and thus are considered stable
6016        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
6017        pub fn as_str_name(&self) -> &'static str {
6018            match self {
6019                Self::Manual => "MANUAL",
6020                Self::Auto => "AUTO",
6021            }
6022        }
6023        /// Creates an enum from field names used in the ProtoBuf definition.
6024        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
6025            match value {
6026                "MANUAL" => Some(Self::Manual),
6027                "AUTO" => Some(Self::Auto),
6028                _ => None,
6029            }
6030        }
6031    }
6032}
6033/// PB_OFFSET = 100000, is the offset added for each MNM field id
6034#[derive(Clone, PartialEq, ::prost::Message)]
6035pub struct AccountListUpdates {
6036    /// PB_OFFSET + MNM_TEMPLATE_ID
6037    #[prost(int32, required, tag = "154467")]
6038    pub template_id: i32,
6039    /// PB_OFFSET + MNM_FCM_ID
6040    #[prost(string, optional, tag = "154013")]
6041    pub fcm_id: ::core::option::Option<::prost::alloc::string::String>,
6042    /// PB_OFFSET + MNM_IB_ID
6043    #[prost(string, optional, tag = "154014")]
6044    pub ib_id: ::core::option::Option<::prost::alloc::string::String>,
6045    /// PB_OFFSET + MNM_ACCOUNT_ID
6046    #[prost(string, optional, tag = "154008")]
6047    pub account_id: ::core::option::Option<::prost::alloc::string::String>,
6048    /// PB_OFFSET + MNM_AUTO_LIQ_THRESHOLD_CURRENT_VALUE
6049    #[prost(string, optional, tag = "131040")]
6050    pub auto_liq_threshold_current_value: ::core::option::Option<::prost::alloc::string::String>,
6051}
6052/// PB_OFFSET = 100000, is the offset added for each MNM field id
6053#[derive(Clone, PartialEq, ::prost::Message)]
6054pub struct UpdateEasyToBorrowList {
6055    /// PB_OFFSET + MNM_TEMPLATE_ID
6056    #[prost(int32, required, tag = "154467")]
6057    pub template_id: i32,
6058    /// PB_OFFSET + MNM_BROKER_DEALER
6059    #[prost(string, optional, tag = "154612")]
6060    pub broker_dealer: ::core::option::Option<::prost::alloc::string::String>,
6061    /// PB_OFFSET + MNM_SYMBOL
6062    #[prost(string, optional, tag = "110100")]
6063    pub symbol: ::core::option::Option<::prost::alloc::string::String>,
6064    /// PB_OFFSET + MNM_SYMBOL_NAME
6065    #[prost(string, optional, tag = "100003")]
6066    pub symbol_name: ::core::option::Option<::prost::alloc::string::String>,
6067    /// PB_OFFSET + MNM_TOTAL_AVAILABLE_QTY
6068    #[prost(int32, optional, tag = "154613")]
6069    pub qty_available: ::core::option::Option<i32>,
6070    /// PB_OFFSET + MNM_TOTAL_USED_QTY
6071    #[prost(int32, optional, tag = "154614")]
6072    pub qty_needed: ::core::option::Option<i32>,
6073    /// PB_OFFSET + MNM_SHORT_LIST_INDICATOR
6074    #[prost(bool, optional, tag = "110353")]
6075    pub borrowable: ::core::option::Option<bool>,
6076}
6077#[derive(Clone, PartialEq, ::prost::Message)]
6078pub struct AccountRmsUpdates {
6079    #[prost(int32, required, tag = "154467")]
6080    pub template_id: i32,
6081    #[prost(int32, optional, tag = "154211")]
6082    pub update_bits: ::core::option::Option<i32>,
6083    #[prost(string, optional, tag = "154013")]
6084    pub fcm_id: ::core::option::Option<::prost::alloc::string::String>,
6085    #[prost(string, optional, tag = "154014")]
6086    pub ib_id: ::core::option::Option<::prost::alloc::string::String>,
6087    #[prost(string, optional, tag = "154008")]
6088    pub account_id: ::core::option::Option<::prost::alloc::string::String>,
6089    #[prost(string, optional, tag = "131040")]
6090    pub auto_liq_threshold_current_value: ::core::option::Option<::prost::alloc::string::String>,
6091    #[prost(string, optional, tag = "131049")]
6092    pub auto_liq_peak_account_balance: ::core::option::Option<::prost::alloc::string::String>,
6093    #[prost(string, optional, tag = "131050")]
6094    pub auto_liq_peak_account_balance_ssboe: ::core::option::Option<::prost::alloc::string::String>,
6095}
6096/// Nested message and enum types in `AccountRmsUpdates`.
6097pub mod account_rms_updates {
6098    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
6099    #[repr(i32)]
6100    pub enum UpdateBits {
6101        AutoLiqThresholdCurrentValue = 1,
6102    }
6103    impl UpdateBits {
6104        /// String value of the enum field names used in the ProtoBuf definition.
6105        ///
6106        /// The values are not transformed in any way and thus are considered stable
6107        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
6108        pub fn as_str_name(&self) -> &'static str {
6109            match self {
6110                Self::AutoLiqThresholdCurrentValue => "AUTO_LIQ_THRESHOLD_CURRENT_VALUE",
6111            }
6112        }
6113        /// Creates an enum from field names used in the ProtoBuf definition.
6114        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
6115            match value {
6116                "AUTO_LIQ_THRESHOLD_CURRENT_VALUE" => Some(Self::AutoLiqThresholdCurrentValue),
6117                _ => None,
6118            }
6119        }
6120    }
6121}
6122/// PB_OFFSET = 100000, is the offset added for each MNM field id
6123#[derive(Clone, PartialEq, ::prost::Message)]
6124pub struct RequestPnLPositionUpdates {
6125    /// PB_OFFSET + MNM_TEMPLATE_ID
6126    #[prost(int32, required, tag = "154467")]
6127    pub template_id: i32,
6128    /// PB_OFFSET + MNM_USER_MSG
6129    #[prost(string, repeated, tag = "132760")]
6130    pub user_msg: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
6131    /// PB_OFFSET + MNM_REQUEST
6132    #[prost(
6133        enumeration = "request_pn_l_position_updates::Request",
6134        optional,
6135        tag = "100000"
6136    )]
6137    pub request: ::core::option::Option<i32>,
6138    /// PB_OFFSET + MNM_FCM_ID
6139    #[prost(string, optional, tag = "154013")]
6140    pub fcm_id: ::core::option::Option<::prost::alloc::string::String>,
6141    /// PB_OFFSET + MNM_IB_ID
6142    #[prost(string, optional, tag = "154014")]
6143    pub ib_id: ::core::option::Option<::prost::alloc::string::String>,
6144    /// PB_OFFSET + MNM_ACCOUNT_ID
6145    #[prost(string, optional, tag = "154008")]
6146    pub account_id: ::core::option::Option<::prost::alloc::string::String>,
6147}
6148/// Nested message and enum types in `RequestPnLPositionUpdates`.
6149pub mod request_pn_l_position_updates {
6150    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
6151    #[repr(i32)]
6152    pub enum Request {
6153        Subscribe = 1,
6154        Unsubscribe = 2,
6155    }
6156    impl Request {
6157        /// String value of the enum field names used in the ProtoBuf definition.
6158        ///
6159        /// The values are not transformed in any way and thus are considered stable
6160        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
6161        pub fn as_str_name(&self) -> &'static str {
6162            match self {
6163                Self::Subscribe => "SUBSCRIBE",
6164                Self::Unsubscribe => "UNSUBSCRIBE",
6165            }
6166        }
6167        /// Creates an enum from field names used in the ProtoBuf definition.
6168        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
6169            match value {
6170                "SUBSCRIBE" => Some(Self::Subscribe),
6171                "UNSUBSCRIBE" => Some(Self::Unsubscribe),
6172                _ => None,
6173            }
6174        }
6175    }
6176}
6177/// PB_OFFSET = 100000, is the offset added for each MNM field id
6178#[derive(Clone, PartialEq, ::prost::Message)]
6179pub struct ResponsePnLPositionUpdates {
6180    /// PB_OFFSET + MNM_TEMPLATE_ID
6181    #[prost(int32, required, tag = "154467")]
6182    pub template_id: i32,
6183    /// PB_OFFSET + MNM_USER_MSG
6184    #[prost(string, repeated, tag = "132760")]
6185    pub user_msg: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
6186    /// PB_OFFSET + MNM_RESPONSE_CODE
6187    #[prost(string, repeated, tag = "132766")]
6188    pub rp_code: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
6189}
6190/// PB_OFFSET = 100000, is the offset added for each MNM field id
6191#[derive(Clone, PartialEq, ::prost::Message)]
6192pub struct RequestPnLPositionSnapshot {
6193    /// PB_OFFSET + MNM_TEMPLATE_ID
6194    #[prost(int32, required, tag = "154467")]
6195    pub template_id: i32,
6196    /// PB_OFFSET + MNM_USER_MSG
6197    #[prost(string, repeated, tag = "132760")]
6198    pub user_msg: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
6199    /// PB_OFFSET + MNM_FCM_ID
6200    #[prost(string, optional, tag = "154013")]
6201    pub fcm_id: ::core::option::Option<::prost::alloc::string::String>,
6202    /// PB_OFFSET + MNM_IB_ID
6203    #[prost(string, optional, tag = "154014")]
6204    pub ib_id: ::core::option::Option<::prost::alloc::string::String>,
6205    /// PB_OFFSET + MNM_ACCOUNT_ID
6206    #[prost(string, optional, tag = "154008")]
6207    pub account_id: ::core::option::Option<::prost::alloc::string::String>,
6208}
6209/// PB_OFFSET = 100000, is the offset added for each MNM field id
6210#[derive(Clone, PartialEq, ::prost::Message)]
6211pub struct ResponsePnLPositionSnapshot {
6212    /// PB_OFFSET + MNM_TEMPLATE_ID
6213    #[prost(int32, required, tag = "154467")]
6214    pub template_id: i32,
6215    /// PB_OFFSET + MNM_USER_MSG
6216    #[prost(string, repeated, tag = "132760")]
6217    pub user_msg: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
6218    /// PB_OFFSET + MNM_RESPONSE_CODE
6219    #[prost(string, repeated, tag = "132766")]
6220    pub rp_code: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
6221}
6222#[derive(Clone, PartialEq, ::prost::Message)]
6223pub struct AccountPnLPositionUpdate {
6224    #[prost(int32, required, tag = "154467")]
6225    pub template_id: i32,
6226    #[prost(bool, optional, tag = "110121")]
6227    pub is_snapshot: ::core::option::Option<bool>,
6228    #[prost(string, optional, tag = "154013")]
6229    pub fcm_id: ::core::option::Option<::prost::alloc::string::String>,
6230    #[prost(string, optional, tag = "154014")]
6231    pub ib_id: ::core::option::Option<::prost::alloc::string::String>,
6232    #[prost(string, optional, tag = "154008")]
6233    pub account_id: ::core::option::Option<::prost::alloc::string::String>,
6234    #[prost(int32, optional, tag = "154041")]
6235    pub fill_buy_qty: ::core::option::Option<i32>,
6236    #[prost(int32, optional, tag = "154042")]
6237    pub fill_sell_qty: ::core::option::Option<i32>,
6238    #[prost(int32, optional, tag = "154037")]
6239    pub order_buy_qty: ::core::option::Option<i32>,
6240    #[prost(int32, optional, tag = "154038")]
6241    pub order_sell_qty: ::core::option::Option<i32>,
6242    #[prost(int32, optional, tag = "154260")]
6243    pub buy_qty: ::core::option::Option<i32>,
6244    #[prost(int32, optional, tag = "154261")]
6245    pub sell_qty: ::core::option::Option<i32>,
6246    #[prost(string, optional, tag = "157105")]
6247    pub open_long_options_value: ::core::option::Option<::prost::alloc::string::String>,
6248    #[prost(string, optional, tag = "157106")]
6249    pub open_short_options_value: ::core::option::Option<::prost::alloc::string::String>,
6250    #[prost(string, optional, tag = "157107")]
6251    pub closed_options_value: ::core::option::Option<::prost::alloc::string::String>,
6252    #[prost(string, optional, tag = "157111")]
6253    pub option_cash_reserved: ::core::option::Option<::prost::alloc::string::String>,
6254    #[prost(string, optional, tag = "157113")]
6255    pub rms_account_commission: ::core::option::Option<::prost::alloc::string::String>,
6256    #[prost(string, optional, tag = "156961")]
6257    pub open_position_pnl: ::core::option::Option<::prost::alloc::string::String>,
6258    #[prost(int32, optional, tag = "156962")]
6259    pub open_position_quantity: ::core::option::Option<i32>,
6260    #[prost(string, optional, tag = "156963")]
6261    pub closed_position_pnl: ::core::option::Option<::prost::alloc::string::String>,
6262    #[prost(int32, optional, tag = "156964")]
6263    pub closed_position_quantity: ::core::option::Option<i32>,
6264    #[prost(int32, optional, tag = "156967")]
6265    pub net_quantity: ::core::option::Option<i32>,
6266    #[prost(string, optional, tag = "156991")]
6267    pub excess_buy_margin: ::core::option::Option<::prost::alloc::string::String>,
6268    #[prost(string, optional, tag = "156977")]
6269    pub margin_balance: ::core::option::Option<::prost::alloc::string::String>,
6270    #[prost(string, optional, tag = "156976")]
6271    pub min_margin_balance: ::core::option::Option<::prost::alloc::string::String>,
6272    #[prost(string, optional, tag = "156968")]
6273    pub min_account_balance: ::core::option::Option<::prost::alloc::string::String>,
6274    #[prost(string, optional, tag = "156970")]
6275    pub account_balance: ::core::option::Option<::prost::alloc::string::String>,
6276    #[prost(string, optional, tag = "156971")]
6277    pub cash_on_hand: ::core::option::Option<::prost::alloc::string::String>,
6278    #[prost(string, optional, tag = "157118")]
6279    pub option_closed_pnl: ::core::option::Option<::prost::alloc::string::String>,
6280    #[prost(string, optional, tag = "156965")]
6281    pub percent_maximum_allowable_loss: ::core::option::Option<::prost::alloc::string::String>,
6282    #[prost(string, optional, tag = "157117")]
6283    pub option_open_pnl: ::core::option::Option<::prost::alloc::string::String>,
6284    #[prost(string, optional, tag = "154262")]
6285    pub mtm_account: ::core::option::Option<::prost::alloc::string::String>,
6286    #[prost(string, optional, tag = "157015")]
6287    pub available_buying_power: ::core::option::Option<::prost::alloc::string::String>,
6288    #[prost(string, optional, tag = "157014")]
6289    pub used_buying_power: ::core::option::Option<::prost::alloc::string::String>,
6290    #[prost(string, optional, tag = "157013")]
6291    pub reserved_buying_power: ::core::option::Option<::prost::alloc::string::String>,
6292    #[prost(string, optional, tag = "156992")]
6293    pub excess_sell_margin: ::core::option::Option<::prost::alloc::string::String>,
6294    #[prost(string, optional, tag = "157954")]
6295    pub day_open_pnl: ::core::option::Option<::prost::alloc::string::String>,
6296    #[prost(string, optional, tag = "157955")]
6297    pub day_closed_pnl: ::core::option::Option<::prost::alloc::string::String>,
6298    #[prost(string, optional, tag = "157956")]
6299    pub day_pnl: ::core::option::Option<::prost::alloc::string::String>,
6300    #[prost(string, optional, tag = "157957")]
6301    pub day_open_pnl_offset: ::core::option::Option<::prost::alloc::string::String>,
6302    #[prost(string, optional, tag = "157958")]
6303    pub day_closed_pnl_offset: ::core::option::Option<::prost::alloc::string::String>,
6304    #[prost(int32, optional, tag = "150100")]
6305    pub ssboe: ::core::option::Option<i32>,
6306    #[prost(int32, optional, tag = "150101")]
6307    pub usecs: ::core::option::Option<i32>,
6308}
6309#[derive(Clone, PartialEq, ::prost::Message)]
6310pub struct InstrumentPnLPositionUpdate {
6311    #[prost(int32, required, tag = "154467")]
6312    pub template_id: i32,
6313    #[prost(bool, optional, tag = "110121")]
6314    pub is_snapshot: ::core::option::Option<bool>,
6315    #[prost(string, optional, tag = "154013")]
6316    pub fcm_id: ::core::option::Option<::prost::alloc::string::String>,
6317    #[prost(string, optional, tag = "154014")]
6318    pub ib_id: ::core::option::Option<::prost::alloc::string::String>,
6319    #[prost(string, optional, tag = "154008")]
6320    pub account_id: ::core::option::Option<::prost::alloc::string::String>,
6321    #[prost(string, optional, tag = "110100")]
6322    pub symbol: ::core::option::Option<::prost::alloc::string::String>,
6323    #[prost(string, optional, tag = "110101")]
6324    pub exchange: ::core::option::Option<::prost::alloc::string::String>,
6325    #[prost(string, optional, tag = "100749")]
6326    pub product_code: ::core::option::Option<::prost::alloc::string::String>,
6327    #[prost(string, optional, tag = "110116")]
6328    pub instrument_type: ::core::option::Option<::prost::alloc::string::String>,
6329    #[prost(int32, optional, tag = "154041")]
6330    pub fill_buy_qty: ::core::option::Option<i32>,
6331    #[prost(int32, optional, tag = "154042")]
6332    pub fill_sell_qty: ::core::option::Option<i32>,
6333    #[prost(int32, optional, tag = "154037")]
6334    pub order_buy_qty: ::core::option::Option<i32>,
6335    #[prost(int32, optional, tag = "154038")]
6336    pub order_sell_qty: ::core::option::Option<i32>,
6337    #[prost(int32, optional, tag = "154260")]
6338    pub buy_qty: ::core::option::Option<i32>,
6339    #[prost(int32, optional, tag = "154261")]
6340    pub sell_qty: ::core::option::Option<i32>,
6341    #[prost(double, optional, tag = "154434")]
6342    pub avg_open_fill_price: ::core::option::Option<f64>,
6343    #[prost(double, optional, tag = "157954")]
6344    pub day_open_pnl: ::core::option::Option<f64>,
6345    #[prost(double, optional, tag = "157955")]
6346    pub day_closed_pnl: ::core::option::Option<f64>,
6347    #[prost(double, optional, tag = "157956")]
6348    pub day_pnl: ::core::option::Option<f64>,
6349    #[prost(double, optional, tag = "157957")]
6350    pub day_open_pnl_offset: ::core::option::Option<f64>,
6351    #[prost(double, optional, tag = "157958")]
6352    pub day_closed_pnl_offset: ::core::option::Option<f64>,
6353    #[prost(string, optional, tag = "154263")]
6354    pub mtm_security: ::core::option::Option<::prost::alloc::string::String>,
6355    #[prost(string, optional, tag = "157105")]
6356    pub open_long_options_value: ::core::option::Option<::prost::alloc::string::String>,
6357    #[prost(string, optional, tag = "157106")]
6358    pub open_short_options_value: ::core::option::Option<::prost::alloc::string::String>,
6359    #[prost(string, optional, tag = "157107")]
6360    pub closed_options_value: ::core::option::Option<::prost::alloc::string::String>,
6361    #[prost(string, optional, tag = "157111")]
6362    pub option_cash_reserved: ::core::option::Option<::prost::alloc::string::String>,
6363    #[prost(string, optional, tag = "156961")]
6364    pub open_position_pnl: ::core::option::Option<::prost::alloc::string::String>,
6365    #[prost(int32, optional, tag = "156962")]
6366    pub open_position_quantity: ::core::option::Option<i32>,
6367    #[prost(string, optional, tag = "156963")]
6368    pub closed_position_pnl: ::core::option::Option<::prost::alloc::string::String>,
6369    #[prost(int32, optional, tag = "156964")]
6370    pub closed_position_quantity: ::core::option::Option<i32>,
6371    #[prost(int32, optional, tag = "156967")]
6372    pub net_quantity: ::core::option::Option<i32>,
6373    #[prost(int32, optional, tag = "150100")]
6374    pub ssboe: ::core::option::Option<i32>,
6375    #[prost(int32, optional, tag = "150101")]
6376    pub usecs: ::core::option::Option<i32>,
6377}
6378#[derive(Clone, PartialEq, ::prost::Message)]
6379pub struct RequestTickBarReplay {
6380    #[prost(int32, required, tag = "154467")]
6381    pub template_id: i32,
6382    #[prost(string, repeated, tag = "132760")]
6383    pub user_msg: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
6384    #[prost(string, optional, tag = "110100")]
6385    pub symbol: ::core::option::Option<::prost::alloc::string::String>,
6386    #[prost(string, optional, tag = "110101")]
6387    pub exchange: ::core::option::Option<::prost::alloc::string::String>,
6388    #[prost(
6389        enumeration = "request_tick_bar_replay::BarType",
6390        optional,
6391        tag = "119200"
6392    )]
6393    pub bar_type: ::core::option::Option<i32>,
6394    #[prost(
6395        enumeration = "request_tick_bar_replay::BarSubType",
6396        optional,
6397        tag = "119208"
6398    )]
6399    pub bar_sub_type: ::core::option::Option<i32>,
6400    #[prost(string, optional, tag = "148162")]
6401    pub bar_type_specifier: ::core::option::Option<::prost::alloc::string::String>,
6402    #[prost(int32, optional, tag = "153002")]
6403    pub start_index: ::core::option::Option<i32>,
6404    #[prost(int32, optional, tag = "153003")]
6405    pub finish_index: ::core::option::Option<i32>,
6406    #[prost(int32, optional, tag = "154020")]
6407    pub user_max_count: ::core::option::Option<i32>,
6408    #[prost(int32, optional, tag = "119209")]
6409    pub custom_session_open_ssm: ::core::option::Option<i32>,
6410    #[prost(int32, optional, tag = "119210")]
6411    pub custom_session_close_ssm: ::core::option::Option<i32>,
6412    #[prost(
6413        enumeration = "request_tick_bar_replay::Direction",
6414        optional,
6415        tag = "149253"
6416    )]
6417    pub direction: ::core::option::Option<i32>,
6418    #[prost(
6419        enumeration = "request_tick_bar_replay::TimeOrder",
6420        optional,
6421        tag = "149307"
6422    )]
6423    pub time_order: ::core::option::Option<i32>,
6424    #[prost(bool, optional, tag = "153642")]
6425    pub resume_bars: ::core::option::Option<bool>,
6426}
6427/// Nested message and enum types in `RequestTickBarReplay`.
6428pub mod request_tick_bar_replay {
6429    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
6430    #[repr(i32)]
6431    pub enum BarType {
6432        TickBar = 1,
6433        RangeBar = 2,
6434        VolumeBar = 3,
6435    }
6436    impl BarType {
6437        /// String value of the enum field names used in the ProtoBuf definition.
6438        ///
6439        /// The values are not transformed in any way and thus are considered stable
6440        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
6441        pub fn as_str_name(&self) -> &'static str {
6442            match self {
6443                Self::TickBar => "TICK_BAR",
6444                Self::RangeBar => "RANGE_BAR",
6445                Self::VolumeBar => "VOLUME_BAR",
6446            }
6447        }
6448        /// Creates an enum from field names used in the ProtoBuf definition.
6449        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
6450            match value {
6451                "TICK_BAR" => Some(Self::TickBar),
6452                "RANGE_BAR" => Some(Self::RangeBar),
6453                "VOLUME_BAR" => Some(Self::VolumeBar),
6454                _ => None,
6455            }
6456        }
6457    }
6458    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
6459    #[repr(i32)]
6460    pub enum BarSubType {
6461        Regular = 1,
6462        Custom = 2,
6463    }
6464    impl BarSubType {
6465        /// String value of the enum field names used in the ProtoBuf definition.
6466        ///
6467        /// The values are not transformed in any way and thus are considered stable
6468        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
6469        pub fn as_str_name(&self) -> &'static str {
6470            match self {
6471                Self::Regular => "REGULAR",
6472                Self::Custom => "CUSTOM",
6473            }
6474        }
6475        /// Creates an enum from field names used in the ProtoBuf definition.
6476        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
6477            match value {
6478                "REGULAR" => Some(Self::Regular),
6479                "CUSTOM" => Some(Self::Custom),
6480                _ => None,
6481            }
6482        }
6483    }
6484    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
6485    #[repr(i32)]
6486    pub enum Direction {
6487        First = 1,
6488        Last = 2,
6489    }
6490    impl Direction {
6491        /// String value of the enum field names used in the ProtoBuf definition.
6492        ///
6493        /// The values are not transformed in any way and thus are considered stable
6494        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
6495        pub fn as_str_name(&self) -> &'static str {
6496            match self {
6497                Self::First => "FIRST",
6498                Self::Last => "LAST",
6499            }
6500        }
6501        /// Creates an enum from field names used in the ProtoBuf definition.
6502        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
6503            match value {
6504                "FIRST" => Some(Self::First),
6505                "LAST" => Some(Self::Last),
6506                _ => None,
6507            }
6508        }
6509    }
6510    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
6511    #[repr(i32)]
6512    pub enum TimeOrder {
6513        Forwards = 1,
6514        Backwards = 2,
6515    }
6516    impl TimeOrder {
6517        /// String value of the enum field names used in the ProtoBuf definition.
6518        ///
6519        /// The values are not transformed in any way and thus are considered stable
6520        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
6521        pub fn as_str_name(&self) -> &'static str {
6522            match self {
6523                Self::Forwards => "FORWARDS",
6524                Self::Backwards => "BACKWARDS",
6525            }
6526        }
6527        /// Creates an enum from field names used in the ProtoBuf definition.
6528        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
6529            match value {
6530                "FORWARDS" => Some(Self::Forwards),
6531                "BACKWARDS" => Some(Self::Backwards),
6532                _ => None,
6533            }
6534        }
6535    }
6536}
6537#[derive(Clone, PartialEq, ::prost::Message)]
6538pub struct ResponseTickBarReplay {
6539    #[prost(int32, required, tag = "154467")]
6540    pub template_id: i32,
6541    #[prost(string, optional, tag = "132758")]
6542    pub request_key: ::core::option::Option<::prost::alloc::string::String>,
6543    #[prost(string, repeated, tag = "132760")]
6544    pub user_msg: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
6545    #[prost(string, repeated, tag = "132764")]
6546    pub rq_handler_rp_code: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
6547    #[prost(string, repeated, tag = "132766")]
6548    pub rp_code: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
6549    #[prost(string, optional, tag = "110100")]
6550    pub symbol: ::core::option::Option<::prost::alloc::string::String>,
6551    #[prost(string, optional, tag = "110101")]
6552    pub exchange: ::core::option::Option<::prost::alloc::string::String>,
6553    #[prost(
6554        enumeration = "response_tick_bar_replay::BarType",
6555        optional,
6556        tag = "119200"
6557    )]
6558    pub r#type: ::core::option::Option<i32>,
6559    #[prost(
6560        enumeration = "response_tick_bar_replay::BarSubType",
6561        optional,
6562        tag = "119208"
6563    )]
6564    pub sub_type: ::core::option::Option<i32>,
6565    #[prost(string, optional, tag = "148162")]
6566    pub type_specifier: ::core::option::Option<::prost::alloc::string::String>,
6567    #[prost(uint64, optional, tag = "119204")]
6568    pub num_trades: ::core::option::Option<u64>,
6569    #[prost(uint64, optional, tag = "119205")]
6570    pub volume: ::core::option::Option<u64>,
6571    #[prost(uint64, optional, tag = "119213")]
6572    pub bid_volume: ::core::option::Option<u64>,
6573    #[prost(uint64, optional, tag = "119214")]
6574    pub ask_volume: ::core::option::Option<u64>,
6575    #[prost(double, optional, tag = "100019")]
6576    pub open_price: ::core::option::Option<f64>,
6577    #[prost(double, optional, tag = "100021")]
6578    pub close_price: ::core::option::Option<f64>,
6579    #[prost(double, optional, tag = "100012")]
6580    pub high_price: ::core::option::Option<f64>,
6581    #[prost(double, optional, tag = "100013")]
6582    pub low_price: ::core::option::Option<f64>,
6583    #[prost(int32, optional, tag = "119209")]
6584    pub custom_session_open_ssm: ::core::option::Option<i32>,
6585    #[prost(int32, repeated, packed = "false", tag = "119202")]
6586    pub data_bar_ssboe: ::prost::alloc::vec::Vec<i32>,
6587    #[prost(int32, repeated, packed = "false", tag = "119203")]
6588    pub data_bar_usecs: ::prost::alloc::vec::Vec<i32>,
6589}
6590/// Nested message and enum types in `ResponseTickBarReplay`.
6591pub mod response_tick_bar_replay {
6592    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
6593    #[repr(i32)]
6594    pub enum BarType {
6595        TickBar = 1,
6596        RangeBar = 2,
6597        VolumeBar = 3,
6598    }
6599    impl BarType {
6600        /// String value of the enum field names used in the ProtoBuf definition.
6601        ///
6602        /// The values are not transformed in any way and thus are considered stable
6603        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
6604        pub fn as_str_name(&self) -> &'static str {
6605            match self {
6606                Self::TickBar => "TICK_BAR",
6607                Self::RangeBar => "RANGE_BAR",
6608                Self::VolumeBar => "VOLUME_BAR",
6609            }
6610        }
6611        /// Creates an enum from field names used in the ProtoBuf definition.
6612        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
6613            match value {
6614                "TICK_BAR" => Some(Self::TickBar),
6615                "RANGE_BAR" => Some(Self::RangeBar),
6616                "VOLUME_BAR" => Some(Self::VolumeBar),
6617                _ => None,
6618            }
6619        }
6620    }
6621    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
6622    #[repr(i32)]
6623    pub enum BarSubType {
6624        Regular = 1,
6625        Custom = 2,
6626    }
6627    impl BarSubType {
6628        /// String value of the enum field names used in the ProtoBuf definition.
6629        ///
6630        /// The values are not transformed in any way and thus are considered stable
6631        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
6632        pub fn as_str_name(&self) -> &'static str {
6633            match self {
6634                Self::Regular => "REGULAR",
6635                Self::Custom => "CUSTOM",
6636            }
6637        }
6638        /// Creates an enum from field names used in the ProtoBuf definition.
6639        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
6640            match value {
6641                "REGULAR" => Some(Self::Regular),
6642                "CUSTOM" => Some(Self::Custom),
6643                _ => None,
6644            }
6645        }
6646    }
6647}
6648/// PB_OFFSET = 100000, is the offset added for each MNM field id
6649#[derive(Clone, PartialEq, ::prost::Message)]
6650pub struct RequestTickBarUpdate {
6651    /// PB_OFFSET + MNM_TEMPLATE_ID
6652    #[prost(int32, required, tag = "154467")]
6653    pub template_id: i32,
6654    /// PB_OFFSET + MNM_USER_MSG
6655    #[prost(string, repeated, tag = "132760")]
6656    pub user_msg: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
6657    /// PB_OFFSET + MNM_SYMBOL
6658    #[prost(string, optional, tag = "110100")]
6659    pub symbol: ::core::option::Option<::prost::alloc::string::String>,
6660    /// PB_OFFSET + MNM_EXCHANGE
6661    #[prost(string, optional, tag = "110101")]
6662    pub exchange: ::core::option::Option<::prost::alloc::string::String>,
6663    /// PB_OFFSET + MNM_REQUEST
6664    #[prost(
6665        enumeration = "request_tick_bar_update::Request",
6666        optional,
6667        tag = "100000"
6668    )]
6669    pub request: ::core::option::Option<i32>,
6670    /// PB_OFFSET + MNM_DATA_BAR_TYPE
6671    #[prost(
6672        enumeration = "request_tick_bar_update::BarType",
6673        optional,
6674        tag = "119200"
6675    )]
6676    pub bar_type: ::core::option::Option<i32>,
6677    /// PB_OFFSET + MNM_DATA_BAR_SUB_TYPE
6678    #[prost(
6679        enumeration = "request_tick_bar_update::BarSubType",
6680        optional,
6681        tag = "119208"
6682    )]
6683    pub bar_sub_type: ::core::option::Option<i32>,
6684    /// PB_OFFSET + MNM_CATEGORY_SPECIFIC_INFO
6685    #[prost(string, optional, tag = "148162")]
6686    pub bar_type_specifier: ::core::option::Option<::prost::alloc::string::String>,
6687    /// PB_OFFSET + MNM_CUSTOM_SESSION_OPEN_SSM
6688    #[prost(int32, optional, tag = "119209")]
6689    pub custom_session_open_ssm: ::core::option::Option<i32>,
6690    /// PB_OFFSET + MNM_CUSTOM_SESSION_CLOSE_SSM
6691    #[prost(int32, optional, tag = "119210")]
6692    pub custom_session_close_ssm: ::core::option::Option<i32>,
6693}
6694/// Nested message and enum types in `RequestTickBarUpdate`.
6695pub mod request_tick_bar_update {
6696    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
6697    #[repr(i32)]
6698    pub enum BarType {
6699        TickBar = 1,
6700        RangeBar = 2,
6701        VolumeBar = 3,
6702    }
6703    impl BarType {
6704        /// String value of the enum field names used in the ProtoBuf definition.
6705        ///
6706        /// The values are not transformed in any way and thus are considered stable
6707        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
6708        pub fn as_str_name(&self) -> &'static str {
6709            match self {
6710                Self::TickBar => "TICK_BAR",
6711                Self::RangeBar => "RANGE_BAR",
6712                Self::VolumeBar => "VOLUME_BAR",
6713            }
6714        }
6715        /// Creates an enum from field names used in the ProtoBuf definition.
6716        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
6717            match value {
6718                "TICK_BAR" => Some(Self::TickBar),
6719                "RANGE_BAR" => Some(Self::RangeBar),
6720                "VOLUME_BAR" => Some(Self::VolumeBar),
6721                _ => None,
6722            }
6723        }
6724    }
6725    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
6726    #[repr(i32)]
6727    pub enum BarSubType {
6728        Regular = 1,
6729        Custom = 2,
6730    }
6731    impl BarSubType {
6732        /// String value of the enum field names used in the ProtoBuf definition.
6733        ///
6734        /// The values are not transformed in any way and thus are considered stable
6735        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
6736        pub fn as_str_name(&self) -> &'static str {
6737            match self {
6738                Self::Regular => "REGULAR",
6739                Self::Custom => "CUSTOM",
6740            }
6741        }
6742        /// Creates an enum from field names used in the ProtoBuf definition.
6743        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
6744            match value {
6745                "REGULAR" => Some(Self::Regular),
6746                "CUSTOM" => Some(Self::Custom),
6747                _ => None,
6748            }
6749        }
6750    }
6751    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
6752    #[repr(i32)]
6753    pub enum Request {
6754        Subscribe = 1,
6755        Unsubscribe = 2,
6756    }
6757    impl Request {
6758        /// String value of the enum field names used in the ProtoBuf definition.
6759        ///
6760        /// The values are not transformed in any way and thus are considered stable
6761        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
6762        pub fn as_str_name(&self) -> &'static str {
6763            match self {
6764                Self::Subscribe => "SUBSCRIBE",
6765                Self::Unsubscribe => "UNSUBSCRIBE",
6766            }
6767        }
6768        /// Creates an enum from field names used in the ProtoBuf definition.
6769        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
6770            match value {
6771                "SUBSCRIBE" => Some(Self::Subscribe),
6772                "UNSUBSCRIBE" => Some(Self::Unsubscribe),
6773                _ => None,
6774            }
6775        }
6776    }
6777}
6778/// PB_OFFSET = 100000, is the offset added for each MNM field id
6779#[derive(Clone, PartialEq, ::prost::Message)]
6780pub struct ResponseTickBarUpdate {
6781    /// PB_OFFSET + MNM_TEMPLATE_ID
6782    #[prost(int32, required, tag = "154467")]
6783    pub template_id: i32,
6784    /// PB_OFFSET + MNM_USER_MSG
6785    #[prost(string, repeated, tag = "132760")]
6786    pub user_msg: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
6787    /// PB_OFFSET + MNM_RESPONSE_CODE
6788    #[prost(string, repeated, tag = "132766")]
6789    pub rp_code: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
6790}
6791#[derive(Clone, PartialEq, ::prost::Message)]
6792pub struct RequestTimeBarReplay {
6793    #[prost(int32, required, tag = "154467")]
6794    pub template_id: i32,
6795    #[prost(string, repeated, tag = "132760")]
6796    pub user_msg: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
6797    #[prost(string, optional, tag = "110100")]
6798    pub symbol: ::core::option::Option<::prost::alloc::string::String>,
6799    #[prost(string, optional, tag = "110101")]
6800    pub exchange: ::core::option::Option<::prost::alloc::string::String>,
6801    #[prost(
6802        enumeration = "request_time_bar_replay::BarType",
6803        optional,
6804        tag = "119200"
6805    )]
6806    pub bar_type: ::core::option::Option<i32>,
6807    #[prost(int32, optional, tag = "119112")]
6808    pub bar_type_period: ::core::option::Option<i32>,
6809    #[prost(int32, optional, tag = "153002")]
6810    pub start_index: ::core::option::Option<i32>,
6811    #[prost(int32, optional, tag = "153003")]
6812    pub finish_index: ::core::option::Option<i32>,
6813    #[prost(int32, optional, tag = "154020")]
6814    pub user_max_count: ::core::option::Option<i32>,
6815    #[prost(
6816        enumeration = "request_time_bar_replay::Direction",
6817        optional,
6818        tag = "149253"
6819    )]
6820    pub direction: ::core::option::Option<i32>,
6821    #[prost(
6822        enumeration = "request_time_bar_replay::TimeOrder",
6823        optional,
6824        tag = "149307"
6825    )]
6826    pub time_order: ::core::option::Option<i32>,
6827    #[prost(bool, optional, tag = "153642")]
6828    pub resume_bars: ::core::option::Option<bool>,
6829}
6830/// Nested message and enum types in `RequestTimeBarReplay`.
6831pub mod request_time_bar_replay {
6832    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
6833    #[repr(i32)]
6834    pub enum BarType {
6835        SecondBar = 1,
6836        MinuteBar = 2,
6837        DailyBar = 3,
6838        WeeklyBar = 4,
6839    }
6840    impl BarType {
6841        /// String value of the enum field names used in the ProtoBuf definition.
6842        ///
6843        /// The values are not transformed in any way and thus are considered stable
6844        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
6845        pub fn as_str_name(&self) -> &'static str {
6846            match self {
6847                Self::SecondBar => "SECOND_BAR",
6848                Self::MinuteBar => "MINUTE_BAR",
6849                Self::DailyBar => "DAILY_BAR",
6850                Self::WeeklyBar => "WEEKLY_BAR",
6851            }
6852        }
6853        /// Creates an enum from field names used in the ProtoBuf definition.
6854        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
6855            match value {
6856                "SECOND_BAR" => Some(Self::SecondBar),
6857                "MINUTE_BAR" => Some(Self::MinuteBar),
6858                "DAILY_BAR" => Some(Self::DailyBar),
6859                "WEEKLY_BAR" => Some(Self::WeeklyBar),
6860                _ => None,
6861            }
6862        }
6863    }
6864    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
6865    #[repr(i32)]
6866    pub enum Direction {
6867        First = 1,
6868        Last = 2,
6869    }
6870    impl Direction {
6871        /// String value of the enum field names used in the ProtoBuf definition.
6872        ///
6873        /// The values are not transformed in any way and thus are considered stable
6874        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
6875        pub fn as_str_name(&self) -> &'static str {
6876            match self {
6877                Self::First => "FIRST",
6878                Self::Last => "LAST",
6879            }
6880        }
6881        /// Creates an enum from field names used in the ProtoBuf definition.
6882        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
6883            match value {
6884                "FIRST" => Some(Self::First),
6885                "LAST" => Some(Self::Last),
6886                _ => None,
6887            }
6888        }
6889    }
6890    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
6891    #[repr(i32)]
6892    pub enum TimeOrder {
6893        Forwards = 1,
6894        Backwards = 2,
6895    }
6896    impl TimeOrder {
6897        /// String value of the enum field names used in the ProtoBuf definition.
6898        ///
6899        /// The values are not transformed in any way and thus are considered stable
6900        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
6901        pub fn as_str_name(&self) -> &'static str {
6902            match self {
6903                Self::Forwards => "FORWARDS",
6904                Self::Backwards => "BACKWARDS",
6905            }
6906        }
6907        /// Creates an enum from field names used in the ProtoBuf definition.
6908        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
6909            match value {
6910                "FORWARDS" => Some(Self::Forwards),
6911                "BACKWARDS" => Some(Self::Backwards),
6912                _ => None,
6913            }
6914        }
6915    }
6916}
6917#[derive(Clone, PartialEq, ::prost::Message)]
6918pub struct ResponseTimeBarReplay {
6919    #[prost(int32, required, tag = "154467")]
6920    pub template_id: i32,
6921    #[prost(string, optional, tag = "132758")]
6922    pub request_key: ::core::option::Option<::prost::alloc::string::String>,
6923    #[prost(string, repeated, tag = "132760")]
6924    pub user_msg: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
6925    #[prost(string, repeated, tag = "132764")]
6926    pub rq_handler_rp_code: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
6927    #[prost(string, repeated, tag = "132766")]
6928    pub rp_code: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
6929    #[prost(string, optional, tag = "110100")]
6930    pub symbol: ::core::option::Option<::prost::alloc::string::String>,
6931    #[prost(string, optional, tag = "110101")]
6932    pub exchange: ::core::option::Option<::prost::alloc::string::String>,
6933    #[prost(
6934        enumeration = "response_time_bar_replay::BarType",
6935        optional,
6936        tag = "119200"
6937    )]
6938    pub r#type: ::core::option::Option<i32>,
6939    #[prost(string, optional, tag = "119112")]
6940    pub period: ::core::option::Option<::prost::alloc::string::String>,
6941    #[prost(int32, optional, tag = "119100")]
6942    pub marker: ::core::option::Option<i32>,
6943    #[prost(uint64, optional, tag = "119109")]
6944    pub num_trades: ::core::option::Option<u64>,
6945    #[prost(uint64, optional, tag = "119110")]
6946    pub volume: ::core::option::Option<u64>,
6947    #[prost(uint64, optional, tag = "119117")]
6948    pub bid_volume: ::core::option::Option<u64>,
6949    #[prost(uint64, optional, tag = "119118")]
6950    pub ask_volume: ::core::option::Option<u64>,
6951    #[prost(double, optional, tag = "100019")]
6952    pub open_price: ::core::option::Option<f64>,
6953    #[prost(double, optional, tag = "100021")]
6954    pub close_price: ::core::option::Option<f64>,
6955    #[prost(double, optional, tag = "100012")]
6956    pub high_price: ::core::option::Option<f64>,
6957    #[prost(double, optional, tag = "100013")]
6958    pub low_price: ::core::option::Option<f64>,
6959    #[prost(double, optional, tag = "100070")]
6960    pub settlement_price: ::core::option::Option<f64>,
6961    #[prost(bool, optional, tag = "149138")]
6962    pub has_settlement_price: ::core::option::Option<bool>,
6963    #[prost(bool, optional, tag = "154571")]
6964    pub must_clear_settlement_price: ::core::option::Option<bool>,
6965}
6966/// Nested message and enum types in `ResponseTimeBarReplay`.
6967pub mod response_time_bar_replay {
6968    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
6969    #[repr(i32)]
6970    pub enum BarType {
6971        SecondBar = 1,
6972        MinuteBar = 2,
6973        DailyBar = 3,
6974        WeeklyBar = 4,
6975    }
6976    impl BarType {
6977        /// String value of the enum field names used in the ProtoBuf definition.
6978        ///
6979        /// The values are not transformed in any way and thus are considered stable
6980        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
6981        pub fn as_str_name(&self) -> &'static str {
6982            match self {
6983                Self::SecondBar => "SECOND_BAR",
6984                Self::MinuteBar => "MINUTE_BAR",
6985                Self::DailyBar => "DAILY_BAR",
6986                Self::WeeklyBar => "WEEKLY_BAR",
6987            }
6988        }
6989        /// Creates an enum from field names used in the ProtoBuf definition.
6990        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
6991            match value {
6992                "SECOND_BAR" => Some(Self::SecondBar),
6993                "MINUTE_BAR" => Some(Self::MinuteBar),
6994                "DAILY_BAR" => Some(Self::DailyBar),
6995                "WEEKLY_BAR" => Some(Self::WeeklyBar),
6996                _ => None,
6997            }
6998        }
6999    }
7000}
7001/// PB_OFFSET = 100000, is the offset added for each MNM field id
7002#[derive(Clone, PartialEq, ::prost::Message)]
7003pub struct RequestTimeBarUpdate {
7004    /// PB_OFFSET + MNM_TEMPLATE_ID
7005    #[prost(int32, required, tag = "154467")]
7006    pub template_id: i32,
7007    /// PB_OFFSET + MNM_USER_MSG
7008    #[prost(string, repeated, tag = "132760")]
7009    pub user_msg: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
7010    /// PB_OFFSET + MNM_SYMBOL
7011    #[prost(string, optional, tag = "110100")]
7012    pub symbol: ::core::option::Option<::prost::alloc::string::String>,
7013    /// PB_OFFSET + MNM_EXCHANGE
7014    #[prost(string, optional, tag = "110101")]
7015    pub exchange: ::core::option::Option<::prost::alloc::string::String>,
7016    /// PB_OFFSET + MNM_REQUEST
7017    #[prost(
7018        enumeration = "request_time_bar_update::Request",
7019        optional,
7020        tag = "100000"
7021    )]
7022    pub request: ::core::option::Option<i32>,
7023    /// PB_OFFSET + MNM_DATA_BAR_TYPE
7024    #[prost(
7025        enumeration = "request_time_bar_update::BarType",
7026        optional,
7027        tag = "119200"
7028    )]
7029    pub bar_type: ::core::option::Option<i32>,
7030    /// PB_OFFSET + MNM_TIME_BAR_PERIOD
7031    #[prost(int32, optional, tag = "119112")]
7032    pub bar_type_period: ::core::option::Option<i32>,
7033}
7034/// Nested message and enum types in `RequestTimeBarUpdate`.
7035pub mod request_time_bar_update {
7036    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
7037    #[repr(i32)]
7038    pub enum BarType {
7039        SecondBar = 1,
7040        MinuteBar = 2,
7041        DailyBar = 3,
7042        WeeklyBar = 4,
7043    }
7044    impl BarType {
7045        /// String value of the enum field names used in the ProtoBuf definition.
7046        ///
7047        /// The values are not transformed in any way and thus are considered stable
7048        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
7049        pub fn as_str_name(&self) -> &'static str {
7050            match self {
7051                Self::SecondBar => "SECOND_BAR",
7052                Self::MinuteBar => "MINUTE_BAR",
7053                Self::DailyBar => "DAILY_BAR",
7054                Self::WeeklyBar => "WEEKLY_BAR",
7055            }
7056        }
7057        /// Creates an enum from field names used in the ProtoBuf definition.
7058        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
7059            match value {
7060                "SECOND_BAR" => Some(Self::SecondBar),
7061                "MINUTE_BAR" => Some(Self::MinuteBar),
7062                "DAILY_BAR" => Some(Self::DailyBar),
7063                "WEEKLY_BAR" => Some(Self::WeeklyBar),
7064                _ => None,
7065            }
7066        }
7067    }
7068    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
7069    #[repr(i32)]
7070    pub enum Request {
7071        Subscribe = 1,
7072        Unsubscribe = 2,
7073    }
7074    impl Request {
7075        /// String value of the enum field names used in the ProtoBuf definition.
7076        ///
7077        /// The values are not transformed in any way and thus are considered stable
7078        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
7079        pub fn as_str_name(&self) -> &'static str {
7080            match self {
7081                Self::Subscribe => "SUBSCRIBE",
7082                Self::Unsubscribe => "UNSUBSCRIBE",
7083            }
7084        }
7085        /// Creates an enum from field names used in the ProtoBuf definition.
7086        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
7087            match value {
7088                "SUBSCRIBE" => Some(Self::Subscribe),
7089                "UNSUBSCRIBE" => Some(Self::Unsubscribe),
7090                _ => None,
7091            }
7092        }
7093    }
7094}
7095/// PB_OFFSET = 100000, is the offset added for each MNM field id
7096#[derive(Clone, PartialEq, ::prost::Message)]
7097pub struct ResponseTimeBarUpdate {
7098    /// PB_OFFSET + MNM_TEMPLATE_ID
7099    #[prost(int32, required, tag = "154467")]
7100    pub template_id: i32,
7101    /// PB_OFFSET + MNM_USER_MSG
7102    #[prost(string, repeated, tag = "132760")]
7103    pub user_msg: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
7104    /// PB_OFFSET + MNM_RESPONSE_CODE
7105    #[prost(string, repeated, tag = "132766")]
7106    pub rp_code: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
7107}
7108#[derive(Clone, PartialEq, ::prost::Message)]
7109pub struct RequestVolumeProfileMinuteBars {
7110    #[prost(int32, required, tag = "154467")]
7111    pub template_id: i32,
7112    #[prost(string, repeated, tag = "132760")]
7113    pub user_msg: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
7114    #[prost(string, optional, tag = "110100")]
7115    pub symbol: ::core::option::Option<::prost::alloc::string::String>,
7116    #[prost(string, optional, tag = "110101")]
7117    pub exchange: ::core::option::Option<::prost::alloc::string::String>,
7118    #[prost(int32, optional, tag = "119215")]
7119    pub bar_type_period: ::core::option::Option<i32>,
7120    #[prost(int32, optional, tag = "153002")]
7121    pub start_index: ::core::option::Option<i32>,
7122    #[prost(int32, optional, tag = "153003")]
7123    pub finish_index: ::core::option::Option<i32>,
7124    #[prost(int32, optional, tag = "154020")]
7125    pub user_max_count: ::core::option::Option<i32>,
7126    #[prost(bool, optional, tag = "153642")]
7127    pub resume_bars: ::core::option::Option<bool>,
7128}
7129#[derive(Clone, PartialEq, ::prost::Message)]
7130pub struct ResponseVolumeProfileMinuteBars {
7131    #[prost(int32, required, tag = "154467")]
7132    pub template_id: i32,
7133    #[prost(string, optional, tag = "132758")]
7134    pub request_key: ::core::option::Option<::prost::alloc::string::String>,
7135    #[prost(string, repeated, tag = "132760")]
7136    pub user_msg: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
7137    #[prost(string, repeated, tag = "132764")]
7138    pub rq_handler_rp_code: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
7139    #[prost(string, repeated, tag = "132766")]
7140    pub rp_code: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
7141    #[prost(string, optional, tag = "110100")]
7142    pub symbol: ::core::option::Option<::prost::alloc::string::String>,
7143    #[prost(string, optional, tag = "110101")]
7144    pub exchange: ::core::option::Option<::prost::alloc::string::String>,
7145    #[prost(string, optional, tag = "119215")]
7146    pub period: ::core::option::Option<::prost::alloc::string::String>,
7147    #[prost(int32, optional, tag = "119100")]
7148    pub marker: ::core::option::Option<i32>,
7149    #[prost(uint64, optional, tag = "119204")]
7150    pub num_trades: ::core::option::Option<u64>,
7151    #[prost(uint64, optional, tag = "119205")]
7152    pub volume: ::core::option::Option<u64>,
7153    #[prost(uint64, optional, tag = "119213")]
7154    pub bid_volume: ::core::option::Option<u64>,
7155    #[prost(uint64, optional, tag = "119214")]
7156    pub ask_volume: ::core::option::Option<u64>,
7157    #[prost(double, optional, tag = "100019")]
7158    pub open_price: ::core::option::Option<f64>,
7159    #[prost(double, optional, tag = "100021")]
7160    pub close_price: ::core::option::Option<f64>,
7161    #[prost(double, optional, tag = "100012")]
7162    pub high_price: ::core::option::Option<f64>,
7163    #[prost(double, optional, tag = "100013")]
7164    pub low_price: ::core::option::Option<f64>,
7165    #[prost(double, repeated, packed = "false", tag = "119216")]
7166    pub profile_price: ::prost::alloc::vec::Vec<f64>,
7167    #[prost(int32, repeated, packed = "false", tag = "119217")]
7168    pub profile_no_aggressor_volume: ::prost::alloc::vec::Vec<i32>,
7169    #[prost(int32, repeated, packed = "false", tag = "119218")]
7170    pub profile_bid_volume: ::prost::alloc::vec::Vec<i32>,
7171    #[prost(int32, repeated, packed = "false", tag = "119219")]
7172    pub profile_ask_volume: ::prost::alloc::vec::Vec<i32>,
7173    #[prost(int32, repeated, packed = "false", tag = "119220")]
7174    pub profile_no_aggressor_trades: ::prost::alloc::vec::Vec<i32>,
7175    #[prost(int32, repeated, packed = "false", tag = "119221")]
7176    pub profile_bid_aggressor_trades: ::prost::alloc::vec::Vec<i32>,
7177    #[prost(int32, repeated, packed = "false", tag = "119222")]
7178    pub profile_ask_aggressor_trades: ::prost::alloc::vec::Vec<i32>,
7179}
7180#[derive(Clone, PartialEq, ::prost::Message)]
7181pub struct RequestResumeBars {
7182    #[prost(int32, required, tag = "154467")]
7183    pub template_id: i32,
7184    #[prost(string, repeated, tag = "132760")]
7185    pub user_msg: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
7186    #[prost(string, optional, tag = "132758")]
7187    pub request_key: ::core::option::Option<::prost::alloc::string::String>,
7188}
7189#[derive(Clone, PartialEq, ::prost::Message)]
7190pub struct ResponseResumeBars {
7191    #[prost(int32, required, tag = "154467")]
7192    pub template_id: i32,
7193    #[prost(string, repeated, tag = "132760")]
7194    pub user_msg: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
7195    #[prost(string, repeated, tag = "132766")]
7196    pub rp_code: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
7197}
7198/// PB_OFFSET = 100000, is the offset added for each MNM field id
7199#[derive(Clone, PartialEq, ::prost::Message)]
7200pub struct TickBar {
7201    /// PB_OFFSET + MNM_TEMPLATE_ID
7202    #[prost(int32, required, tag = "154467")]
7203    pub template_id: i32,
7204    /// PB_OFFSET + MNM_SYMBOL
7205    #[prost(string, optional, tag = "110100")]
7206    pub symbol: ::core::option::Option<::prost::alloc::string::String>,
7207    /// PB_OFFSET + MNM_EXCHANGE
7208    #[prost(string, optional, tag = "110101")]
7209    pub exchange: ::core::option::Option<::prost::alloc::string::String>,
7210    /// PB_OFFSET + MNM_DATA_BAR_TYPE
7211    #[prost(enumeration = "tick_bar::BarType", optional, tag = "119200")]
7212    pub r#type: ::core::option::Option<i32>,
7213    /// PB_OFFSET + MNM_DATA_BAR_SUB_TYPE
7214    #[prost(enumeration = "tick_bar::BarSubType", optional, tag = "119208")]
7215    pub sub_type: ::core::option::Option<i32>,
7216    /// PB_OFFSET + MNM_CATEGORY_SPECIFIC_INFO
7217    #[prost(string, optional, tag = "148162")]
7218    pub type_specifier: ::core::option::Option<::prost::alloc::string::String>,
7219    /// PB_OFFSET + MNM_DATA_BAR_NUM_TRADES
7220    #[prost(uint64, optional, tag = "119204")]
7221    pub num_trades: ::core::option::Option<u64>,
7222    /// PB_OFFSET + MNM_DATA_BAR_TRADE_VOLUME
7223    #[prost(uint64, optional, tag = "119205")]
7224    pub volume: ::core::option::Option<u64>,
7225    /// PB_OFFSET + MNM_DATA_BAR_BID_VOLUME
7226    #[prost(uint64, optional, tag = "119213")]
7227    pub bid_volume: ::core::option::Option<u64>,
7228    /// PB_OFFSET + MNM_DATA_BAR_ASK_VOLUME
7229    #[prost(uint64, optional, tag = "119214")]
7230    pub ask_volume: ::core::option::Option<u64>,
7231    /// PB_OFFSET + MNM_OPEN_PRICE
7232    #[prost(double, optional, tag = "100019")]
7233    pub open_price: ::core::option::Option<f64>,
7234    /// PB_OFFSET + MNM_CLOSE_TRADE_PRICE
7235    #[prost(double, optional, tag = "100021")]
7236    pub close_price: ::core::option::Option<f64>,
7237    /// PB_OFFSET + MNM_HIGH_PRICE
7238    #[prost(double, optional, tag = "100012")]
7239    pub high_price: ::core::option::Option<f64>,
7240    /// PB_OFFSET + MNM_LOW_PRICE
7241    #[prost(double, optional, tag = "100013")]
7242    pub low_price: ::core::option::Option<f64>,
7243    /// PB_OFFSET + MNM_CUSTOM_SESSION_OPEN_SSM
7244    #[prost(int32, optional, tag = "119209")]
7245    pub custom_session_open_ssm: ::core::option::Option<i32>,
7246    /// PB_OFFSET + MNM_DATA_BAR_SSBOE
7247    #[prost(int32, repeated, packed = "false", tag = "119202")]
7248    pub data_bar_ssboe: ::prost::alloc::vec::Vec<i32>,
7249    /// PB_OFFSTE + MNM_DATA_BAR_USECS
7250    #[prost(int32, repeated, packed = "false", tag = "119203")]
7251    pub data_bar_usecs: ::prost::alloc::vec::Vec<i32>,
7252}
7253/// Nested message and enum types in `TickBar`.
7254pub mod tick_bar {
7255    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
7256    #[repr(i32)]
7257    pub enum BarType {
7258        TickBar = 1,
7259        RangeBar = 2,
7260        VolumeBar = 3,
7261    }
7262    impl BarType {
7263        /// String value of the enum field names used in the ProtoBuf definition.
7264        ///
7265        /// The values are not transformed in any way and thus are considered stable
7266        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
7267        pub fn as_str_name(&self) -> &'static str {
7268            match self {
7269                Self::TickBar => "TICK_BAR",
7270                Self::RangeBar => "RANGE_BAR",
7271                Self::VolumeBar => "VOLUME_BAR",
7272            }
7273        }
7274        /// Creates an enum from field names used in the ProtoBuf definition.
7275        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
7276            match value {
7277                "TICK_BAR" => Some(Self::TickBar),
7278                "RANGE_BAR" => Some(Self::RangeBar),
7279                "VOLUME_BAR" => Some(Self::VolumeBar),
7280                _ => None,
7281            }
7282        }
7283    }
7284    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
7285    #[repr(i32)]
7286    pub enum BarSubType {
7287        Regular = 1,
7288        Custom = 2,
7289    }
7290    impl BarSubType {
7291        /// String value of the enum field names used in the ProtoBuf definition.
7292        ///
7293        /// The values are not transformed in any way and thus are considered stable
7294        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
7295        pub fn as_str_name(&self) -> &'static str {
7296            match self {
7297                Self::Regular => "REGULAR",
7298                Self::Custom => "CUSTOM",
7299            }
7300        }
7301        /// Creates an enum from field names used in the ProtoBuf definition.
7302        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
7303            match value {
7304                "REGULAR" => Some(Self::Regular),
7305                "CUSTOM" => Some(Self::Custom),
7306                _ => None,
7307            }
7308        }
7309    }
7310}
7311/// PB_OFFSET = 100000, is the offset added for each MNM field id
7312#[derive(Clone, PartialEq, ::prost::Message)]
7313pub struct TimeBar {
7314    /// PB_OFFSET + MNM_TEMPLATE_ID
7315    #[prost(int32, required, tag = "154467")]
7316    pub template_id: i32,
7317    /// PB_OFFSET + MNM_SYMBOL
7318    #[prost(string, optional, tag = "110100")]
7319    pub symbol: ::core::option::Option<::prost::alloc::string::String>,
7320    /// PB_OFFSET + MNM_EXCHANGE
7321    #[prost(string, optional, tag = "110101")]
7322    pub exchange: ::core::option::Option<::prost::alloc::string::String>,
7323    /// PB_OFFSET + MNM_DATA_BAR_TYPE
7324    #[prost(enumeration = "time_bar::BarType", optional, tag = "119200")]
7325    pub r#type: ::core::option::Option<i32>,
7326    /// PB_OFFSET + MNM_TIME_BAR_PERIOD
7327    #[prost(string, optional, tag = "119112")]
7328    pub period: ::core::option::Option<::prost::alloc::string::String>,
7329    /// PB_OFFSET + MNM_TIME_BAR_MARKER
7330    #[prost(int32, optional, tag = "119100")]
7331    pub marker: ::core::option::Option<i32>,
7332    /// PB_OFFSET + MNM_TIME_BAR_NUM_TRADES
7333    #[prost(uint64, optional, tag = "119109")]
7334    pub num_trades: ::core::option::Option<u64>,
7335    /// PB_OFFSET + MNM_TIME_BAR_TRADE_VOLUME
7336    #[prost(uint64, optional, tag = "119110")]
7337    pub volume: ::core::option::Option<u64>,
7338    /// PB_OFFSET + MNM_TIME_BAR_BID_VOLUME
7339    #[prost(uint64, optional, tag = "119117")]
7340    pub bid_volume: ::core::option::Option<u64>,
7341    /// PB_OFFSET + MNM_TIME_BAR_ASK_VOLUME
7342    #[prost(uint64, optional, tag = "119118")]
7343    pub ask_volume: ::core::option::Option<u64>,
7344    /// PB_OFFSET + MNM_OPEN_PRICE
7345    #[prost(double, optional, tag = "100019")]
7346    pub open_price: ::core::option::Option<f64>,
7347    /// PB_OFFSET + MNM_CLOSE_TRADE_PRICE
7348    #[prost(double, optional, tag = "100021")]
7349    pub close_price: ::core::option::Option<f64>,
7350    /// PB_OFFSET + MNM_HIGH_PRICE
7351    #[prost(double, optional, tag = "100012")]
7352    pub high_price: ::core::option::Option<f64>,
7353    /// PB_OFFSET + MNM_LOW_PRICE
7354    #[prost(double, optional, tag = "100013")]
7355    pub low_price: ::core::option::Option<f64>,
7356    /// PB_OFFSET + MNM_SETTLEMENT_PRICE
7357    #[prost(double, optional, tag = "100070")]
7358    pub settlement_price: ::core::option::Option<f64>,
7359    /// PB_OFFSET + MNM_PRICING_INDICATOR
7360    #[prost(bool, optional, tag = "149138")]
7361    pub has_settlement_price: ::core::option::Option<bool>,
7362    /// PB_OFFSET + MNM_DISPLAY_INDICATOR
7363    #[prost(bool, optional, tag = "154571")]
7364    pub must_clear_settlement_price: ::core::option::Option<bool>,
7365}
7366/// Nested message and enum types in `TimeBar`.
7367pub mod time_bar {
7368    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
7369    #[repr(i32)]
7370    pub enum BarType {
7371        SecondBar = 1,
7372        MinuteBar = 2,
7373        DailyBar = 3,
7374        WeeklyBar = 4,
7375    }
7376    impl BarType {
7377        /// String value of the enum field names used in the ProtoBuf definition.
7378        ///
7379        /// The values are not transformed in any way and thus are considered stable
7380        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
7381        pub fn as_str_name(&self) -> &'static str {
7382            match self {
7383                Self::SecondBar => "SECOND_BAR",
7384                Self::MinuteBar => "MINUTE_BAR",
7385                Self::DailyBar => "DAILY_BAR",
7386                Self::WeeklyBar => "WEEKLY_BAR",
7387            }
7388        }
7389        /// Creates an enum from field names used in the ProtoBuf definition.
7390        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
7391            match value {
7392                "SECOND_BAR" => Some(Self::SecondBar),
7393                "MINUTE_BAR" => Some(Self::MinuteBar),
7394                "DAILY_BAR" => Some(Self::DailyBar),
7395                "WEEKLY_BAR" => Some(Self::WeeklyBar),
7396                _ => None,
7397            }
7398        }
7399    }
7400}
7401#[derive(Clone, PartialEq, ::prost::Message)]
7402pub struct RequestListUnacceptedAgreements {
7403    #[prost(int32, required, tag = "154467")]
7404    pub template_id: i32,
7405    #[prost(string, repeated, tag = "132760")]
7406    pub user_msg: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
7407}
7408#[derive(Clone, PartialEq, ::prost::Message)]
7409pub struct ResponseListUnacceptedAgreements {
7410    #[prost(int32, required, tag = "154467")]
7411    pub template_id: i32,
7412    #[prost(string, repeated, tag = "132760")]
7413    pub user_msg: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
7414    #[prost(string, repeated, tag = "132764")]
7415    pub rq_handler_rp_code: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
7416    #[prost(string, repeated, tag = "132766")]
7417    pub rp_code: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
7418    #[prost(string, optional, tag = "154013")]
7419    pub fcm_id: ::core::option::Option<::prost::alloc::string::String>,
7420    #[prost(string, optional, tag = "154014")]
7421    pub ib_id: ::core::option::Option<::prost::alloc::string::String>,
7422    #[prost(string, optional, tag = "153406")]
7423    pub agreement_title: ::core::option::Option<::prost::alloc::string::String>,
7424    #[prost(string, optional, tag = "153407")]
7425    pub agreement_id: ::core::option::Option<::prost::alloc::string::String>,
7426    #[prost(string, optional, tag = "153430")]
7427    pub agreement_acceptance_request: ::core::option::Option<::prost::alloc::string::String>,
7428}
7429#[derive(Clone, PartialEq, ::prost::Message)]
7430pub struct RequestListAcceptedAgreements {
7431    #[prost(int32, required, tag = "154467")]
7432    pub template_id: i32,
7433    #[prost(string, repeated, tag = "132760")]
7434    pub user_msg: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
7435}
7436#[derive(Clone, PartialEq, ::prost::Message)]
7437pub struct ResponseListAcceptedAgreements {
7438    #[prost(int32, required, tag = "154467")]
7439    pub template_id: i32,
7440    #[prost(string, repeated, tag = "132760")]
7441    pub user_msg: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
7442    #[prost(string, repeated, tag = "132764")]
7443    pub rq_handler_rp_code: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
7444    #[prost(string, repeated, tag = "132766")]
7445    pub rp_code: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
7446    #[prost(string, optional, tag = "154013")]
7447    pub fcm_id: ::core::option::Option<::prost::alloc::string::String>,
7448    #[prost(string, optional, tag = "154014")]
7449    pub ib_id: ::core::option::Option<::prost::alloc::string::String>,
7450    #[prost(int32, optional, tag = "153427")]
7451    pub agreement_acceptance_ssboe: ::core::option::Option<i32>,
7452    #[prost(string, optional, tag = "153426")]
7453    pub agreement_acceptance_status: ::core::option::Option<::prost::alloc::string::String>,
7454    #[prost(string, optional, tag = "153430")]
7455    pub agreement_acceptance_request: ::core::option::Option<::prost::alloc::string::String>,
7456    #[prost(string, optional, tag = "153406")]
7457    pub agreement_title: ::core::option::Option<::prost::alloc::string::String>,
7458    #[prost(string, optional, tag = "153407")]
7459    pub agreement_id: ::core::option::Option<::prost::alloc::string::String>,
7460}
7461#[derive(Clone, PartialEq, ::prost::Message)]
7462pub struct RequestAcceptAgreement {
7463    #[prost(int32, required, tag = "154467")]
7464    pub template_id: i32,
7465    #[prost(string, repeated, tag = "132760")]
7466    pub user_msg: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
7467    #[prost(string, optional, tag = "153407")]
7468    pub agreement_id: ::core::option::Option<::prost::alloc::string::String>,
7469    /// Professional or Non-Professional
7470    #[prost(string, optional, tag = "153431")]
7471    pub market_data_usage_capacity: ::core::option::Option<::prost::alloc::string::String>,
7472}
7473#[derive(Clone, PartialEq, ::prost::Message)]
7474pub struct ResponseAcceptAgreement {
7475    #[prost(int32, required, tag = "154467")]
7476    pub template_id: i32,
7477    #[prost(string, repeated, tag = "132760")]
7478    pub user_msg: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
7479    #[prost(string, repeated, tag = "132766")]
7480    pub rp_code: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
7481}
7482#[derive(Clone, PartialEq, ::prost::Message)]
7483pub struct RequestSetRithmicMrktDataSelfCertStatus {
7484    #[prost(int32, required, tag = "154467")]
7485    pub template_id: i32,
7486    #[prost(string, repeated, tag = "132760")]
7487    pub user_msg: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
7488    #[prost(string, optional, tag = "153407")]
7489    pub agreement_id: ::core::option::Option<::prost::alloc::string::String>,
7490    #[prost(string, optional, tag = "153431")]
7491    pub market_data_usage_capacity: ::core::option::Option<::prost::alloc::string::String>,
7492}
7493#[derive(Clone, PartialEq, ::prost::Message)]
7494pub struct ResponseSetRithmicMrktDataSelfCertStatus {
7495    #[prost(int32, required, tag = "154467")]
7496    pub template_id: i32,
7497    #[prost(string, repeated, tag = "132760")]
7498    pub user_msg: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
7499    #[prost(string, repeated, tag = "132766")]
7500    pub rp_code: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
7501}
7502#[derive(Clone, PartialEq, ::prost::Message)]
7503pub struct RequestShowAgreement {
7504    #[prost(int32, required, tag = "154467")]
7505    pub template_id: i32,
7506    #[prost(string, repeated, tag = "132760")]
7507    pub user_msg: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
7508    #[prost(string, optional, tag = "153407")]
7509    pub agreement_id: ::core::option::Option<::prost::alloc::string::String>,
7510}
7511#[derive(Clone, PartialEq, ::prost::Message)]
7512pub struct ResponseShowAgreement {
7513    #[prost(int32, required, tag = "154467")]
7514    pub template_id: i32,
7515    #[prost(string, repeated, tag = "132760")]
7516    pub user_msg: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
7517    #[prost(string, repeated, tag = "132764")]
7518    pub rq_handler_rp_code: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
7519    #[prost(string, repeated, tag = "132766")]
7520    pub rp_code: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
7521    #[prost(string, optional, tag = "153406")]
7522    pub agreement_title: ::core::option::Option<::prost::alloc::string::String>,
7523    #[prost(string, optional, tag = "153407")]
7524    pub agreement_id: ::core::option::Option<::prost::alloc::string::String>,
7525    #[prost(bytes = "vec", optional, tag = "153405")]
7526    pub agreement: ::core::option::Option<::prost::alloc::vec::Vec<u8>>,
7527    #[prost(bytes = "vec", optional, tag = "153432")]
7528    pub agreement_html: ::core::option::Option<::prost::alloc::vec::Vec<u8>>,
7529    #[prost(string, optional, tag = "153410")]
7530    pub agreement_mandatory_flag: ::core::option::Option<::prost::alloc::string::String>,
7531    #[prost(string, optional, tag = "153415")]
7532    pub agreement_status: ::core::option::Option<::prost::alloc::string::String>,
7533    #[prost(string, optional, tag = "153430")]
7534    pub agreement_acceptance_request: ::core::option::Option<::prost::alloc::string::String>,
7535}
rithmic_rs/rti.rs

rithmic_rs/
rti.rs
