1#[allow(clippy::derive_partial_eq_without_eq)]
5#[derive(Clone, PartialEq, ::prost::Message)]
6pub struct EtfLp {
7    #[prost(string, tag="1")]
9    pub symbol: ::prost::alloc::string::String,
10    #[prost(string, tag="2")]
12    pub fund_code: ::prost::alloc::string::String,
13    #[prost(int64, tag="4")]
15    pub bid_offset: i64,
16    #[prost(int64, tag="5")]
18    pub ask_offset: i64,
19    #[prost(int64, tag="6")]
21    pub basis: i64,
22    #[prost(int64, tag="7")]
24    pub quantity: i64,
25    #[prost(uint32, tag="8")]
27    pub depth: u32,
28    #[prost(int64, tag="9")]
30    pub tick_size: i64,
31}
32#[allow(clippy::derive_partial_eq_without_eq)]
36#[derive(Clone, PartialEq, ::prost::Message)]
37pub struct EtfLpStatus {
38    #[prost(enumeration="EtfLpState", tag="1")]
40    pub state: i32,
41    #[prost(int64, tag="2")]
43    pub start_time: i64,
44    #[prost(message, optional, tag="3")]
46    pub order_stats: ::core::option::Option<OrderStats>,
47    #[prost(message, optional, tag="4")]
49    pub order_limit: ::core::option::Option<OrderLimitStatus>,
50    #[prost(message, optional, tag="5")]
52    pub pricing: ::core::option::Option<LpPricing>,
53}
54#[allow(clippy::derive_partial_eq_without_eq)]
56#[derive(Clone, Copy, PartialEq, ::prost::Message)]
57pub struct OrderStats {
58    #[prost(uint64, tag="1")]
60    pub total_orders_sent: u64,
61    #[prost(uint64, tag="2")]
63    pub orders_accepted: u64,
64    #[prost(uint64, tag="3")]
66    pub orders_rejected: u64,
67    #[prost(uint64, tag="4")]
69    pub orders_filled: u64,
70    #[prost(int64, tag="5")]
72    pub total_filled_quantity: i64,
73    #[prost(int64, tag="6")]
75    pub daily_filled_quantity: i64,
76}
77#[allow(clippy::derive_partial_eq_without_eq)]
79#[derive(Clone, PartialEq, ::prost::Message)]
80pub struct OrderLimitStatus {
81    #[prost(int64, tag="1")]
83    pub daily_filled_quantity: i64,
84    #[prost(int64, tag="2")]
86    pub daily_cumulative_limit: i64,
87    #[prost(message, repeated, tag="3")]
89    pub time_frame_status: ::prost::alloc::vec::Vec<TimeFrameStatus>,
90    #[prost(double, tag="4")]
92    pub daily_usage_percent: f64,
93}
94#[allow(clippy::derive_partial_eq_without_eq)]
96#[derive(Clone, Copy, PartialEq, ::prost::Message)]
97pub struct TimeFrameStatus {
98    #[prost(uint64, tag="1")]
100    pub window_seconds: u64,
101    #[prost(uint32, tag="2")]
103    pub current_count: u32,
104    #[prost(uint32, tag="3")]
106    pub max_orders: u32,
107    #[prost(double, tag="4")]
109    pub usage_percent: f64,
110}
111#[allow(clippy::derive_partial_eq_without_eq)]
113#[derive(Clone, PartialEq, ::prost::Message)]
114pub struct LpPricing {
115    #[prost(string, tag="1")]
117    pub etf_price: ::prost::alloc::string::String,
118    #[prost(string, tag="2")]
120    pub future_price: ::prost::alloc::string::String,
121    #[prost(string, tag="3")]
123    pub etf_nav: ::prost::alloc::string::String,
124}
125#[allow(clippy::derive_partial_eq_without_eq)]
128#[derive(Clone, PartialEq, ::prost::Message)]
129pub struct GetEtfLpRequest {
130    #[prost(string, tag="1")]
131    pub etf: ::prost::alloc::string::String,
132    #[prost(string, tag="2")]
133    pub fund: ::prost::alloc::string::String,
134}
135#[allow(clippy::derive_partial_eq_without_eq)]
137#[derive(Clone, PartialEq, ::prost::Message)]
138pub struct ListEtfLpsRequest {
139    #[prost(uint32, optional, tag="1")]
141    pub page_size: ::core::option::Option<u32>,
142    #[prost(string, optional, tag="2")]
144    pub page_token: ::core::option::Option<::prost::alloc::string::String>,
145    #[prost(string, tag="3")]
155    pub filter: ::prost::alloc::string::String,
156}
157#[allow(clippy::derive_partial_eq_without_eq)]
158#[derive(Clone, PartialEq, ::prost::Message)]
159pub struct ListEtfLpsResponse {
160    #[prost(message, repeated, tag="1")]
162    pub etf_lps: ::prost::alloc::vec::Vec<EtfLp>,
163    #[prost(string, tag="2")]
165    pub next_page_token: ::prost::alloc::string::String,
166}
167#[allow(clippy::derive_partial_eq_without_eq)]
169#[derive(Clone, PartialEq, ::prost::Message)]
170pub struct UpdateEtfLpRequest {
171    #[prost(message, optional, tag="1")]
172    pub lp: ::core::option::Option<EtfLp>,
173    #[prost(message, optional, tag="2")]
174    pub update_mask: ::core::option::Option<super::super::super::google::protobuf::FieldMask>,
175}
176#[allow(clippy::derive_partial_eq_without_eq)]
178#[derive(Clone, PartialEq, ::prost::Message)]
179pub struct GetEtfLpStatusRequest {
180    #[prost(string, tag="1")]
181    pub etf: ::prost::alloc::string::String,
182    #[prost(string, tag="2")]
183    pub fund: ::prost::alloc::string::String,
184}
185#[allow(clippy::derive_partial_eq_without_eq)]
187#[derive(Clone, PartialEq, ::prost::Message)]
188pub struct StreamEtfLpStatusRequest {
189    #[prost(string, tag="1")]
190    pub etf: ::prost::alloc::string::String,
191    #[prost(string, tag="2")]
192    pub fund: ::prost::alloc::string::String,
193    #[prost(uint32, optional, tag="3")]
195    pub update_interval_seconds: ::core::option::Option<u32>,
196}
197#[allow(clippy::derive_partial_eq_without_eq)]
199#[derive(Clone, PartialEq, ::prost::Message)]
200pub struct StartEtfLpRequest {
201    #[prost(string, tag="1")]
202    pub etf: ::prost::alloc::string::String,
203    #[prost(string, tag="2")]
204    pub fund: ::prost::alloc::string::String,
205}
206#[allow(clippy::derive_partial_eq_without_eq)]
208#[derive(Clone, PartialEq, ::prost::Message)]
209pub struct StartEtfLpResponse {
210    #[prost(message, optional, tag="1")]
212    pub status: ::core::option::Option<EtfLpStatus>,
213    #[prost(string, tag="2")]
215    pub message: ::prost::alloc::string::String,
216}
217#[allow(clippy::derive_partial_eq_without_eq)]
219#[derive(Clone, PartialEq, ::prost::Message)]
220pub struct StopEtfLpRequest {
221    #[prost(string, tag="1")]
222    pub etf: ::prost::alloc::string::String,
223    #[prost(string, tag="2")]
224    pub fund: ::prost::alloc::string::String,
225}
226#[allow(clippy::derive_partial_eq_without_eq)]
228#[derive(Clone, PartialEq, ::prost::Message)]
229pub struct StopEtfLpResponse {
230    #[prost(message, optional, tag="1")]
232    pub status: ::core::option::Option<EtfLpStatus>,
233    #[prost(string, tag="2")]
235    pub message: ::prost::alloc::string::String,
236}
237#[allow(clippy::derive_partial_eq_without_eq)]
239#[derive(Clone, PartialEq, ::prost::Message)]
240pub struct StreamEtfErrorsRequest {
241    #[prost(string, tag="1")]
242    pub etf: ::prost::alloc::string::String,
243    #[prost(string, tag="2")]
244    pub fund: ::prost::alloc::string::String,
245}
246#[allow(clippy::derive_partial_eq_without_eq)]
248#[derive(Clone, PartialEq, ::prost::Message)]
249pub struct EtfLpError {
250    #[prost(string, tag="1")]
252    pub symbol: ::prost::alloc::string::String,
253    #[prost(enumeration="ThreadType", tag="2")]
255    pub thread_type: i32,
256    #[prost(enumeration="ErrorType", tag="3")]
258    pub error_type: i32,
259    #[prost(string, tag="4")]
261    pub error_message: ::prost::alloc::string::String,
262    #[prost(message, optional, tag="5")]
264    pub timestamp: ::core::option::Option<super::super::super::google::protobuf::Timestamp>,
265    #[prost(enumeration="ErrorLevel", tag="6")]
267    pub error_level: i32,
268}
269#[allow(clippy::derive_partial_eq_without_eq)]
271#[derive(Clone, PartialEq, ::prost::Message)]
272pub struct GetUserOrderBookRequest {
273    #[prost(string, tag="1")]
274    pub etf: ::prost::alloc::string::String,
275    #[prost(string, tag="2")]
276    pub fund: ::prost::alloc::string::String,
277}
278#[allow(clippy::derive_partial_eq_without_eq)]
280#[derive(Clone, PartialEq, ::prost::Message)]
281pub struct UserOrderbookData {
282    #[prost(string, repeated, tag="1")]
284    pub bid_prices: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
285    #[prost(string, repeated, tag="2")]
287    pub ask_prices: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
288    #[prost(int64, repeated, tag="3")]
290    pub bid_quantities: ::prost::alloc::vec::Vec<i64>,
291    #[prost(int64, repeated, tag="4")]
293    pub ask_quantities: ::prost::alloc::vec::Vec<i64>,
294}
295#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
297#[repr(i32)]
298pub enum ReplicationMethod {
299    Unspecified = 0,
300    Physical = 1,
301    Synthetic = 2,
302    FuturesBased = 3,
303}
304impl ReplicationMethod {
305    pub fn as_str_name(&self) -> &'static str {
310        match self {
311            ReplicationMethod::Unspecified => "REPLICATION_METHOD_UNSPECIFIED",
312            ReplicationMethod::Physical => "REPLICATION_METHOD_PHYSICAL",
313            ReplicationMethod::Synthetic => "REPLICATION_METHOD_SYNTHETIC",
314            ReplicationMethod::FuturesBased => "REPLICATION_METHOD_FUTURES_BASED",
315        }
316    }
317    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
319        match value {
320            "REPLICATION_METHOD_UNSPECIFIED" => Some(Self::Unspecified),
321            "REPLICATION_METHOD_PHYSICAL" => Some(Self::Physical),
322            "REPLICATION_METHOD_SYNTHETIC" => Some(Self::Synthetic),
323            "REPLICATION_METHOD_FUTURES_BASED" => Some(Self::FuturesBased),
324            _ => None,
325        }
326    }
327}
328#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
330#[repr(i32)]
331pub enum EtfLpState {
332    Unspecified = 0,
333    Idle = 1,
334    Running = 2,
335    Stopping = 3,
336    Error = 4,
337}
338impl EtfLpState {
339    pub fn as_str_name(&self) -> &'static str {
344        match self {
345            EtfLpState::Unspecified => "ETF_LP_STATE_UNSPECIFIED",
346            EtfLpState::Idle => "ETF_LP_STATE_IDLE",
347            EtfLpState::Running => "ETF_LP_STATE_RUNNING",
348            EtfLpState::Stopping => "ETF_LP_STATE_STOPPING",
349            EtfLpState::Error => "ETF_LP_STATE_ERROR",
350        }
351    }
352    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
354        match value {
355            "ETF_LP_STATE_UNSPECIFIED" => Some(Self::Unspecified),
356            "ETF_LP_STATE_IDLE" => Some(Self::Idle),
357            "ETF_LP_STATE_RUNNING" => Some(Self::Running),
358            "ETF_LP_STATE_STOPPING" => Some(Self::Stopping),
359            "ETF_LP_STATE_ERROR" => Some(Self::Error),
360            _ => None,
361        }
362    }
363}
364#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
366#[repr(i32)]
367pub enum ThreadType {
368    Unspecified = 0,
369    Quote = 1,
370    Hedge = 2,
371}
372impl ThreadType {
373    pub fn as_str_name(&self) -> &'static str {
378        match self {
379            ThreadType::Unspecified => "THREAD_TYPE_UNSPECIFIED",
380            ThreadType::Quote => "THREAD_TYPE_QUOTE",
381            ThreadType::Hedge => "THREAD_TYPE_HEDGE",
382        }
383    }
384    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
386        match value {
387            "THREAD_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
388            "THREAD_TYPE_QUOTE" => Some(Self::Quote),
389            "THREAD_TYPE_HEDGE" => Some(Self::Hedge),
390            _ => None,
391        }
392    }
393}
394#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
396#[repr(i32)]
397pub enum ErrorType {
398    Unspecified = 0,
399    Initialization = 1,
401    PriceUpdate = 2,
403    OrderSubmit = 3,
405    OrderProcessing = 4,
407    NavCalculation = 5,
409    OrderBookUpdate = 6,
411    OrderLimitExceeded = 7,
413    FundLimitExceeded = 8,
415    SystemError = 9,
417    MarketSession = 10,
419    FundUpdate = 11,
421}
422impl ErrorType {
423    pub fn as_str_name(&self) -> &'static str {
428        match self {
429            ErrorType::Unspecified => "ERROR_TYPE_UNSPECIFIED",
430            ErrorType::Initialization => "ERROR_TYPE_INITIALIZATION",
431            ErrorType::PriceUpdate => "ERROR_TYPE_PRICE_UPDATE",
432            ErrorType::OrderSubmit => "ERROR_TYPE_ORDER_SUBMIT",
433            ErrorType::OrderProcessing => "ERROR_TYPE_ORDER_PROCESSING",
434            ErrorType::NavCalculation => "ERROR_TYPE_NAV_CALCULATION",
435            ErrorType::OrderBookUpdate => "ERROR_TYPE_ORDER_BOOK_UPDATE",
436            ErrorType::OrderLimitExceeded => "ERROR_TYPE_ORDER_LIMIT_EXCEEDED",
437            ErrorType::FundLimitExceeded => "ERROR_TYPE_FUND_LIMIT_EXCEEDED",
438            ErrorType::SystemError => "ERROR_TYPE_SYSTEM_ERROR",
439            ErrorType::MarketSession => "ERROR_TYPE_MARKET_SESSION",
440            ErrorType::FundUpdate => "ERROR_TYPE_FUND_UPDATE",
441        }
442    }
443    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
445        match value {
446            "ERROR_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
447            "ERROR_TYPE_INITIALIZATION" => Some(Self::Initialization),
448            "ERROR_TYPE_PRICE_UPDATE" => Some(Self::PriceUpdate),
449            "ERROR_TYPE_ORDER_SUBMIT" => Some(Self::OrderSubmit),
450            "ERROR_TYPE_ORDER_PROCESSING" => Some(Self::OrderProcessing),
451            "ERROR_TYPE_NAV_CALCULATION" => Some(Self::NavCalculation),
452            "ERROR_TYPE_ORDER_BOOK_UPDATE" => Some(Self::OrderBookUpdate),
453            "ERROR_TYPE_ORDER_LIMIT_EXCEEDED" => Some(Self::OrderLimitExceeded),
454            "ERROR_TYPE_FUND_LIMIT_EXCEEDED" => Some(Self::FundLimitExceeded),
455            "ERROR_TYPE_SYSTEM_ERROR" => Some(Self::SystemError),
456            "ERROR_TYPE_MARKET_SESSION" => Some(Self::MarketSession),
457            "ERROR_TYPE_FUND_UPDATE" => Some(Self::FundUpdate),
458            _ => None,
459        }
460    }
461}
462#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
464#[repr(i32)]
465pub enum ErrorLevel {
466    Unspecified = 0,
467    Debug = 1,
469    Info = 2,
471    Warning = 3,
473    Error = 4,
475    Critical = 5,
477}
478impl ErrorLevel {
479    pub fn as_str_name(&self) -> &'static str {
484        match self {
485            ErrorLevel::Unspecified => "ERROR_LEVEL_UNSPECIFIED",
486            ErrorLevel::Debug => "ERROR_LEVEL_DEBUG",
487            ErrorLevel::Info => "ERROR_LEVEL_INFO",
488            ErrorLevel::Warning => "ERROR_LEVEL_WARNING",
489            ErrorLevel::Error => "ERROR_LEVEL_ERROR",
490            ErrorLevel::Critical => "ERROR_LEVEL_CRITICAL",
491        }
492    }
493    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
495        match value {
496            "ERROR_LEVEL_UNSPECIFIED" => Some(Self::Unspecified),
497            "ERROR_LEVEL_DEBUG" => Some(Self::Debug),
498            "ERROR_LEVEL_INFO" => Some(Self::Info),
499            "ERROR_LEVEL_WARNING" => Some(Self::Warning),
500            "ERROR_LEVEL_ERROR" => Some(Self::Error),
501            "ERROR_LEVEL_CRITICAL" => Some(Self::Critical),
502            _ => None,
503        }
504    }
505}
506include!("kdo.v1.lp.tonic.rs");
507include!("kdo.v1.lp.serde.rs");
508