1#[allow(unused_imports)]
4use super::*;
5#[allow(unused_imports)]
6use crate::ids::*;
7#[allow(unused_imports)]
8use crate::timestamp::Timestamp;
9#[allow(unused_imports)]
10use rust_decimal::Decimal;
11#[allow(unused_imports)]
12use serde::{Deserialize, Serialize};
13
14#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
17#[serde(rename_all = "camelCase")]
18pub struct Account {
19 #[serde(rename = "id", default, skip_serializing_if = "Option::is_none")]
21 pub id: Option<AccountID>,
22 #[serde(rename = "alias", default, skip_serializing_if = "Option::is_none")]
24 pub alias: Option<String>,
25 #[serde(rename = "currency", default, skip_serializing_if = "Option::is_none")]
27 pub currency: Option<Currency>,
28 #[serde(
30 rename = "createdByUserID",
31 default,
32 skip_serializing_if = "Option::is_none"
33 )]
34 pub created_by_user_id: Option<i64>,
35 #[serde(
37 rename = "createdTime",
38 default,
39 skip_serializing_if = "Option::is_none"
40 )]
41 pub created_time: Option<Timestamp>,
42 #[serde(
45 rename = "guaranteedStopLossOrderParameters",
46 default,
47 skip_serializing_if = "Option::is_none"
48 )]
49 pub guaranteed_stop_loss_order_parameters: Option<GuaranteedStopLossOrderParameters>,
50 #[serde(
52 rename = "guaranteedStopLossOrderMode",
53 default,
54 skip_serializing_if = "Option::is_none"
55 )]
56 pub guaranteed_stop_loss_order_mode: Option<GuaranteedStopLossOrderMode>,
57 #[serde(
61 rename = "guaranteedStopLossOrderMutability",
62 default,
63 skip_serializing_if = "Option::is_none"
64 )]
65 pub guaranteed_stop_loss_order_mutability: Option<GuaranteedStopLossOrderMutability>,
66 #[serde(
68 rename = "resettablePLTime",
69 default,
70 skip_serializing_if = "Option::is_none"
71 )]
72 pub resettable_pl_time: Option<Timestamp>,
73 #[serde(
77 rename = "marginRate",
78 default,
79 skip_serializing_if = "Option::is_none"
80 )]
81 #[serde(deserialize_with = "crate::decimal_wire::optional_number_or_string")]
82 pub margin_rate: Option<Decimal>,
83 #[serde(
85 rename = "openTradeCount",
86 default,
87 skip_serializing_if = "Option::is_none"
88 )]
89 pub open_trade_count: Option<i64>,
90 #[serde(
92 rename = "openPositionCount",
93 default,
94 skip_serializing_if = "Option::is_none"
95 )]
96 pub open_position_count: Option<i64>,
97 #[serde(
99 rename = "pendingOrderCount",
100 default,
101 skip_serializing_if = "Option::is_none"
102 )]
103 pub pending_order_count: Option<i64>,
104 #[serde(
106 rename = "hedgingEnabled",
107 default,
108 skip_serializing_if = "Option::is_none"
109 )]
110 pub hedging_enabled: Option<bool>,
111 #[serde(
113 rename = "unrealizedPL",
114 default,
115 skip_serializing_if = "Option::is_none"
116 )]
117 #[serde(deserialize_with = "crate::decimal_wire::optional_number_or_string")]
118 pub unrealized_pl: Option<Decimal>,
119 #[serde(rename = "NAV", default, skip_serializing_if = "Option::is_none")]
121 #[serde(deserialize_with = "crate::decimal_wire::optional_number_or_string")]
122 pub nav: Option<Decimal>,
123 #[serde(
125 rename = "marginUsed",
126 default,
127 skip_serializing_if = "Option::is_none"
128 )]
129 #[serde(deserialize_with = "crate::decimal_wire::optional_number_or_string")]
130 pub margin_used: Option<Decimal>,
131 #[serde(
133 rename = "marginAvailable",
134 default,
135 skip_serializing_if = "Option::is_none"
136 )]
137 #[serde(deserialize_with = "crate::decimal_wire::optional_number_or_string")]
138 pub margin_available: Option<Decimal>,
139 #[serde(
141 rename = "positionValue",
142 default,
143 skip_serializing_if = "Option::is_none"
144 )]
145 #[serde(deserialize_with = "crate::decimal_wire::optional_number_or_string")]
146 pub position_value: Option<Decimal>,
147 #[serde(
149 rename = "marginCloseoutUnrealizedPL",
150 default,
151 skip_serializing_if = "Option::is_none"
152 )]
153 #[serde(deserialize_with = "crate::decimal_wire::optional_number_or_string")]
154 pub margin_closeout_unrealized_pl: Option<Decimal>,
155 #[serde(
157 rename = "marginCloseoutNAV",
158 default,
159 skip_serializing_if = "Option::is_none"
160 )]
161 #[serde(deserialize_with = "crate::decimal_wire::optional_number_or_string")]
162 pub margin_closeout_nav: Option<Decimal>,
163 #[serde(
165 rename = "marginCloseoutMarginUsed",
166 default,
167 skip_serializing_if = "Option::is_none"
168 )]
169 #[serde(deserialize_with = "crate::decimal_wire::optional_number_or_string")]
170 pub margin_closeout_margin_used: Option<Decimal>,
171 #[serde(
174 rename = "marginCloseoutPercent",
175 default,
176 skip_serializing_if = "Option::is_none"
177 )]
178 #[serde(deserialize_with = "crate::decimal_wire::optional_number_or_string")]
179 pub margin_closeout_percent: Option<Decimal>,
180 #[serde(
183 rename = "marginCloseoutPositionValue",
184 default,
185 skip_serializing_if = "Option::is_none"
186 )]
187 #[serde(deserialize_with = "crate::decimal_wire::optional_number_or_string")]
188 pub margin_closeout_position_value: Option<Decimal>,
189 #[serde(
192 rename = "withdrawalLimit",
193 default,
194 skip_serializing_if = "Option::is_none"
195 )]
196 #[serde(deserialize_with = "crate::decimal_wire::optional_number_or_string")]
197 pub withdrawal_limit: Option<Decimal>,
198 #[serde(
200 rename = "marginCallMarginUsed",
201 default,
202 skip_serializing_if = "Option::is_none"
203 )]
204 #[serde(deserialize_with = "crate::decimal_wire::optional_number_or_string")]
205 pub margin_call_margin_used: Option<Decimal>,
206 #[serde(
209 rename = "marginCallPercent",
210 default,
211 skip_serializing_if = "Option::is_none"
212 )]
213 #[serde(deserialize_with = "crate::decimal_wire::optional_number_or_string")]
214 pub margin_call_percent: Option<Decimal>,
215 #[serde(rename = "balance", default, skip_serializing_if = "Option::is_none")]
217 #[serde(deserialize_with = "crate::decimal_wire::optional_number_or_string")]
218 pub balance: Option<Decimal>,
219 #[serde(rename = "pl", default, skip_serializing_if = "Option::is_none")]
221 #[serde(deserialize_with = "crate::decimal_wire::optional_number_or_string")]
222 pub pl: Option<Decimal>,
223 #[serde(
225 rename = "resettablePL",
226 default,
227 skip_serializing_if = "Option::is_none"
228 )]
229 #[serde(deserialize_with = "crate::decimal_wire::optional_number_or_string")]
230 pub resettable_pl: Option<Decimal>,
231 #[serde(rename = "financing", default, skip_serializing_if = "Option::is_none")]
233 #[serde(deserialize_with = "crate::decimal_wire::optional_number_or_string")]
234 pub financing: Option<Decimal>,
235 #[serde(
237 rename = "commission",
238 default,
239 skip_serializing_if = "Option::is_none"
240 )]
241 #[serde(deserialize_with = "crate::decimal_wire::optional_number_or_string")]
242 pub commission: Option<Decimal>,
243 #[serde(
246 rename = "dividendAdjustment",
247 default,
248 skip_serializing_if = "Option::is_none"
249 )]
250 #[serde(deserialize_with = "crate::decimal_wire::optional_number_or_string")]
251 pub dividend_adjustment: Option<Decimal>,
252 #[serde(
255 rename = "guaranteedExecutionFees",
256 default,
257 skip_serializing_if = "Option::is_none"
258 )]
259 #[serde(deserialize_with = "crate::decimal_wire::optional_number_or_string")]
260 pub guaranteed_execution_fees: Option<Decimal>,
261 #[serde(
264 rename = "marginCallEnterTime",
265 default,
266 skip_serializing_if = "Option::is_none"
267 )]
268 pub margin_call_enter_time: Option<Timestamp>,
269 #[serde(
271 rename = "marginCallExtensionCount",
272 default,
273 skip_serializing_if = "Option::is_none"
274 )]
275 pub margin_call_extension_count: Option<i64>,
276 #[serde(
278 rename = "lastMarginCallExtensionTime",
279 default,
280 skip_serializing_if = "Option::is_none"
281 )]
282 pub last_margin_call_extension_time: Option<Timestamp>,
283 #[serde(
288 rename = "lastOrderFillTimestamp",
289 default,
290 skip_serializing_if = "Option::is_none"
291 )]
292 pub last_order_fill_timestamp: Option<Timestamp>,
293 #[serde(
295 rename = "lastTransactionID",
296 default,
297 skip_serializing_if = "Option::is_none"
298 )]
299 pub last_transaction_id: Option<TransactionID>,
300 #[serde(rename = "trades", default, skip_serializing_if = "Option::is_none")]
302 pub trades: Option<Vec<TradeSummary>>,
303 #[serde(rename = "positions", default, skip_serializing_if = "Option::is_none")]
305 pub positions: Option<Vec<Position>>,
306 #[serde(rename = "orders", default, skip_serializing_if = "Option::is_none")]
308 pub orders: Option<Vec<Order>>,
309}
310
311#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
316#[serde(rename_all = "camelCase")]
317pub struct AccountChangesState {
318 #[serde(
320 rename = "unrealizedPL",
321 default,
322 skip_serializing_if = "Option::is_none"
323 )]
324 #[serde(deserialize_with = "crate::decimal_wire::optional_number_or_string")]
325 pub unrealized_pl: Option<Decimal>,
326 #[serde(rename = "NAV", default, skip_serializing_if = "Option::is_none")]
328 #[serde(deserialize_with = "crate::decimal_wire::optional_number_or_string")]
329 pub nav: Option<Decimal>,
330 #[serde(
332 rename = "marginUsed",
333 default,
334 skip_serializing_if = "Option::is_none"
335 )]
336 #[serde(deserialize_with = "crate::decimal_wire::optional_number_or_string")]
337 pub margin_used: Option<Decimal>,
338 #[serde(
340 rename = "marginAvailable",
341 default,
342 skip_serializing_if = "Option::is_none"
343 )]
344 #[serde(deserialize_with = "crate::decimal_wire::optional_number_or_string")]
345 pub margin_available: Option<Decimal>,
346 #[serde(
348 rename = "positionValue",
349 default,
350 skip_serializing_if = "Option::is_none"
351 )]
352 #[serde(deserialize_with = "crate::decimal_wire::optional_number_or_string")]
353 pub position_value: Option<Decimal>,
354 #[serde(
356 rename = "marginCloseoutUnrealizedPL",
357 default,
358 skip_serializing_if = "Option::is_none"
359 )]
360 #[serde(deserialize_with = "crate::decimal_wire::optional_number_or_string")]
361 pub margin_closeout_unrealized_pl: Option<Decimal>,
362 #[serde(
364 rename = "marginCloseoutNAV",
365 default,
366 skip_serializing_if = "Option::is_none"
367 )]
368 #[serde(deserialize_with = "crate::decimal_wire::optional_number_or_string")]
369 pub margin_closeout_nav: Option<Decimal>,
370 #[serde(
372 rename = "marginCloseoutMarginUsed",
373 default,
374 skip_serializing_if = "Option::is_none"
375 )]
376 #[serde(deserialize_with = "crate::decimal_wire::optional_number_or_string")]
377 pub margin_closeout_margin_used: Option<Decimal>,
378 #[serde(
381 rename = "marginCloseoutPercent",
382 default,
383 skip_serializing_if = "Option::is_none"
384 )]
385 #[serde(deserialize_with = "crate::decimal_wire::optional_number_or_string")]
386 pub margin_closeout_percent: Option<Decimal>,
387 #[serde(
390 rename = "marginCloseoutPositionValue",
391 default,
392 skip_serializing_if = "Option::is_none"
393 )]
394 #[serde(deserialize_with = "crate::decimal_wire::optional_number_or_string")]
395 pub margin_closeout_position_value: Option<Decimal>,
396 #[serde(
399 rename = "withdrawalLimit",
400 default,
401 skip_serializing_if = "Option::is_none"
402 )]
403 #[serde(deserialize_with = "crate::decimal_wire::optional_number_or_string")]
404 pub withdrawal_limit: Option<Decimal>,
405 #[serde(
407 rename = "marginCallMarginUsed",
408 default,
409 skip_serializing_if = "Option::is_none"
410 )]
411 #[serde(deserialize_with = "crate::decimal_wire::optional_number_or_string")]
412 pub margin_call_margin_used: Option<Decimal>,
413 #[serde(
416 rename = "marginCallPercent",
417 default,
418 skip_serializing_if = "Option::is_none"
419 )]
420 #[serde(deserialize_with = "crate::decimal_wire::optional_number_or_string")]
421 pub margin_call_percent: Option<Decimal>,
422 #[serde(rename = "balance", default, skip_serializing_if = "Option::is_none")]
424 #[serde(deserialize_with = "crate::decimal_wire::optional_number_or_string")]
425 pub balance: Option<Decimal>,
426 #[serde(rename = "pl", default, skip_serializing_if = "Option::is_none")]
428 #[serde(deserialize_with = "crate::decimal_wire::optional_number_or_string")]
429 pub pl: Option<Decimal>,
430 #[serde(
432 rename = "resettablePL",
433 default,
434 skip_serializing_if = "Option::is_none"
435 )]
436 #[serde(deserialize_with = "crate::decimal_wire::optional_number_or_string")]
437 pub resettable_pl: Option<Decimal>,
438 #[serde(rename = "financing", default, skip_serializing_if = "Option::is_none")]
440 #[serde(deserialize_with = "crate::decimal_wire::optional_number_or_string")]
441 pub financing: Option<Decimal>,
442 #[serde(
444 rename = "commission",
445 default,
446 skip_serializing_if = "Option::is_none"
447 )]
448 #[serde(deserialize_with = "crate::decimal_wire::optional_number_or_string")]
449 pub commission: Option<Decimal>,
450 #[serde(
453 rename = "dividendAdjustment",
454 default,
455 skip_serializing_if = "Option::is_none"
456 )]
457 #[serde(deserialize_with = "crate::decimal_wire::optional_number_or_string")]
458 pub dividend_adjustment: Option<Decimal>,
459 #[serde(
462 rename = "guaranteedExecutionFees",
463 default,
464 skip_serializing_if = "Option::is_none"
465 )]
466 #[serde(deserialize_with = "crate::decimal_wire::optional_number_or_string")]
467 pub guaranteed_execution_fees: Option<Decimal>,
468 #[serde(
471 rename = "marginCallEnterTime",
472 default,
473 skip_serializing_if = "Option::is_none"
474 )]
475 pub margin_call_enter_time: Option<Timestamp>,
476 #[serde(
478 rename = "marginCallExtensionCount",
479 default,
480 skip_serializing_if = "Option::is_none"
481 )]
482 pub margin_call_extension_count: Option<i64>,
483 #[serde(
485 rename = "lastMarginCallExtensionTime",
486 default,
487 skip_serializing_if = "Option::is_none"
488 )]
489 pub last_margin_call_extension_time: Option<Timestamp>,
490 #[serde(rename = "orders", default, skip_serializing_if = "Option::is_none")]
492 pub orders: Option<Vec<DynamicOrderState>>,
493 #[serde(rename = "trades", default, skip_serializing_if = "Option::is_none")]
495 pub trades: Option<Vec<CalculatedTradeState>>,
496 #[serde(rename = "positions", default, skip_serializing_if = "Option::is_none")]
498 pub positions: Option<Vec<CalculatedPositionState>>,
499}
500
501#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
503#[serde(rename_all = "camelCase")]
504pub struct AccountProperties {
505 #[serde(rename = "id", default, skip_serializing_if = "Option::is_none")]
507 pub id: Option<AccountID>,
508 #[serde(
511 rename = "mt4AccountID",
512 default,
513 skip_serializing_if = "Option::is_none"
514 )]
515 pub mt4_account_id: Option<i64>,
516 #[serde(rename = "tags", default, skip_serializing_if = "Option::is_none")]
518 pub tags: Option<Vec<String>>,
519}
520
521#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
523#[serde(rename_all = "camelCase")]
524pub struct GuaranteedStopLossOrderParameters {
525 #[serde(
527 rename = "mutabilityMarketOpen",
528 default,
529 skip_serializing_if = "Option::is_none"
530 )]
531 pub mutability_market_open: Option<GuaranteedStopLossOrderMutability>,
532 #[serde(
534 rename = "mutabilityMarketHalted",
535 default,
536 skip_serializing_if = "Option::is_none"
537 )]
538 pub mutability_market_halted: Option<GuaranteedStopLossOrderMutability>,
539}
540
541#[derive(Debug, Clone, PartialEq, Eq, Hash)]
543#[non_exhaustive]
544pub enum GuaranteedStopLossOrderMode {
545 Disabled,
547 Allowed,
549 Required,
551 Unknown(String),
553}
554
555impl GuaranteedStopLossOrderMode {
556 pub fn as_str(&self) -> &str {
558 match self {
559 Self::Disabled => "DISABLED",
560 Self::Allowed => "ALLOWED",
561 Self::Required => "REQUIRED",
562 Self::Unknown(value) => value,
563 }
564 }
565}
566
567impl Serialize for GuaranteedStopLossOrderMode {
568 fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
569 serializer.serialize_str(self.as_str())
570 }
571}
572
573impl<'de> Deserialize<'de> for GuaranteedStopLossOrderMode {
574 fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
575 let value = String::deserialize(deserializer)?;
576 Ok(match value.as_str() {
577 "DISABLED" => Self::Disabled,
578 "ALLOWED" => Self::Allowed,
579 "REQUIRED" => Self::Required,
580 _ => Self::Unknown(value),
581 })
582 }
583}
584
585#[derive(Debug, Clone, PartialEq, Eq, Hash)]
588#[non_exhaustive]
589pub enum GuaranteedStopLossOrderMutability {
590 Fixed,
592 Replaceable,
594 Cancelable,
596 PriceWidenOnly,
599 Unknown(String),
601}
602
603impl GuaranteedStopLossOrderMutability {
604 pub fn as_str(&self) -> &str {
606 match self {
607 Self::Fixed => "FIXED",
608 Self::Replaceable => "REPLACEABLE",
609 Self::Cancelable => "CANCELABLE",
610 Self::PriceWidenOnly => "PRICE_WIDEN_ONLY",
611 Self::Unknown(value) => value,
612 }
613 }
614}
615
616impl Serialize for GuaranteedStopLossOrderMutability {
617 fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
618 serializer.serialize_str(self.as_str())
619 }
620}
621
622impl<'de> Deserialize<'de> for GuaranteedStopLossOrderMutability {
623 fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
624 let value = String::deserialize(deserializer)?;
625 Ok(match value.as_str() {
626 "FIXED" => Self::Fixed,
627 "REPLACEABLE" => Self::Replaceable,
628 "CANCELABLE" => Self::Cancelable,
629 "PRICE_WIDEN_ONLY" => Self::PriceWidenOnly,
630 _ => Self::Unknown(value),
631 })
632 }
633}
634
635#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
638#[serde(rename_all = "camelCase")]
639pub struct AccountSummary {
640 #[serde(rename = "id", default, skip_serializing_if = "Option::is_none")]
642 pub id: Option<AccountID>,
643 #[serde(rename = "alias", default, skip_serializing_if = "Option::is_none")]
645 pub alias: Option<String>,
646 #[serde(rename = "currency", default, skip_serializing_if = "Option::is_none")]
648 pub currency: Option<Currency>,
649 #[serde(
651 rename = "createdByUserID",
652 default,
653 skip_serializing_if = "Option::is_none"
654 )]
655 pub created_by_user_id: Option<i64>,
656 #[serde(
658 rename = "createdTime",
659 default,
660 skip_serializing_if = "Option::is_none"
661 )]
662 pub created_time: Option<Timestamp>,
663 #[serde(
666 rename = "guaranteedStopLossOrderParameters",
667 default,
668 skip_serializing_if = "Option::is_none"
669 )]
670 pub guaranteed_stop_loss_order_parameters: Option<GuaranteedStopLossOrderParameters>,
671 #[serde(
673 rename = "guaranteedStopLossOrderMode",
674 default,
675 skip_serializing_if = "Option::is_none"
676 )]
677 pub guaranteed_stop_loss_order_mode: Option<GuaranteedStopLossOrderMode>,
678 #[serde(
682 rename = "guaranteedStopLossOrderMutability",
683 default,
684 skip_serializing_if = "Option::is_none"
685 )]
686 pub guaranteed_stop_loss_order_mutability: Option<GuaranteedStopLossOrderMutability>,
687 #[serde(
689 rename = "resettablePLTime",
690 default,
691 skip_serializing_if = "Option::is_none"
692 )]
693 pub resettable_pl_time: Option<Timestamp>,
694 #[serde(
698 rename = "marginRate",
699 default,
700 skip_serializing_if = "Option::is_none"
701 )]
702 #[serde(deserialize_with = "crate::decimal_wire::optional_number_or_string")]
703 pub margin_rate: Option<Decimal>,
704 #[serde(
706 rename = "openTradeCount",
707 default,
708 skip_serializing_if = "Option::is_none"
709 )]
710 pub open_trade_count: Option<i64>,
711 #[serde(
713 rename = "openPositionCount",
714 default,
715 skip_serializing_if = "Option::is_none"
716 )]
717 pub open_position_count: Option<i64>,
718 #[serde(
720 rename = "pendingOrderCount",
721 default,
722 skip_serializing_if = "Option::is_none"
723 )]
724 pub pending_order_count: Option<i64>,
725 #[serde(
727 rename = "hedgingEnabled",
728 default,
729 skip_serializing_if = "Option::is_none"
730 )]
731 pub hedging_enabled: Option<bool>,
732 #[serde(
734 rename = "unrealizedPL",
735 default,
736 skip_serializing_if = "Option::is_none"
737 )]
738 #[serde(deserialize_with = "crate::decimal_wire::optional_number_or_string")]
739 pub unrealized_pl: Option<Decimal>,
740 #[serde(rename = "NAV", default, skip_serializing_if = "Option::is_none")]
742 #[serde(deserialize_with = "crate::decimal_wire::optional_number_or_string")]
743 pub nav: Option<Decimal>,
744 #[serde(
746 rename = "marginUsed",
747 default,
748 skip_serializing_if = "Option::is_none"
749 )]
750 #[serde(deserialize_with = "crate::decimal_wire::optional_number_or_string")]
751 pub margin_used: Option<Decimal>,
752 #[serde(
754 rename = "marginAvailable",
755 default,
756 skip_serializing_if = "Option::is_none"
757 )]
758 #[serde(deserialize_with = "crate::decimal_wire::optional_number_or_string")]
759 pub margin_available: Option<Decimal>,
760 #[serde(
762 rename = "positionValue",
763 default,
764 skip_serializing_if = "Option::is_none"
765 )]
766 #[serde(deserialize_with = "crate::decimal_wire::optional_number_or_string")]
767 pub position_value: Option<Decimal>,
768 #[serde(
770 rename = "marginCloseoutUnrealizedPL",
771 default,
772 skip_serializing_if = "Option::is_none"
773 )]
774 #[serde(deserialize_with = "crate::decimal_wire::optional_number_or_string")]
775 pub margin_closeout_unrealized_pl: Option<Decimal>,
776 #[serde(
778 rename = "marginCloseoutNAV",
779 default,
780 skip_serializing_if = "Option::is_none"
781 )]
782 #[serde(deserialize_with = "crate::decimal_wire::optional_number_or_string")]
783 pub margin_closeout_nav: Option<Decimal>,
784 #[serde(
786 rename = "marginCloseoutMarginUsed",
787 default,
788 skip_serializing_if = "Option::is_none"
789 )]
790 #[serde(deserialize_with = "crate::decimal_wire::optional_number_or_string")]
791 pub margin_closeout_margin_used: Option<Decimal>,
792 #[serde(
795 rename = "marginCloseoutPercent",
796 default,
797 skip_serializing_if = "Option::is_none"
798 )]
799 #[serde(deserialize_with = "crate::decimal_wire::optional_number_or_string")]
800 pub margin_closeout_percent: Option<Decimal>,
801 #[serde(
804 rename = "marginCloseoutPositionValue",
805 default,
806 skip_serializing_if = "Option::is_none"
807 )]
808 #[serde(deserialize_with = "crate::decimal_wire::optional_number_or_string")]
809 pub margin_closeout_position_value: Option<Decimal>,
810 #[serde(
813 rename = "withdrawalLimit",
814 default,
815 skip_serializing_if = "Option::is_none"
816 )]
817 #[serde(deserialize_with = "crate::decimal_wire::optional_number_or_string")]
818 pub withdrawal_limit: Option<Decimal>,
819 #[serde(
821 rename = "marginCallMarginUsed",
822 default,
823 skip_serializing_if = "Option::is_none"
824 )]
825 #[serde(deserialize_with = "crate::decimal_wire::optional_number_or_string")]
826 pub margin_call_margin_used: Option<Decimal>,
827 #[serde(
830 rename = "marginCallPercent",
831 default,
832 skip_serializing_if = "Option::is_none"
833 )]
834 #[serde(deserialize_with = "crate::decimal_wire::optional_number_or_string")]
835 pub margin_call_percent: Option<Decimal>,
836 #[serde(rename = "balance", default, skip_serializing_if = "Option::is_none")]
838 #[serde(deserialize_with = "crate::decimal_wire::optional_number_or_string")]
839 pub balance: Option<Decimal>,
840 #[serde(rename = "pl", default, skip_serializing_if = "Option::is_none")]
842 #[serde(deserialize_with = "crate::decimal_wire::optional_number_or_string")]
843 pub pl: Option<Decimal>,
844 #[serde(
846 rename = "resettablePL",
847 default,
848 skip_serializing_if = "Option::is_none"
849 )]
850 #[serde(deserialize_with = "crate::decimal_wire::optional_number_or_string")]
851 pub resettable_pl: Option<Decimal>,
852 #[serde(rename = "financing", default, skip_serializing_if = "Option::is_none")]
854 #[serde(deserialize_with = "crate::decimal_wire::optional_number_or_string")]
855 pub financing: Option<Decimal>,
856 #[serde(
858 rename = "commission",
859 default,
860 skip_serializing_if = "Option::is_none"
861 )]
862 #[serde(deserialize_with = "crate::decimal_wire::optional_number_or_string")]
863 pub commission: Option<Decimal>,
864 #[serde(
867 rename = "dividendAdjustment",
868 default,
869 skip_serializing_if = "Option::is_none"
870 )]
871 #[serde(deserialize_with = "crate::decimal_wire::optional_number_or_string")]
872 pub dividend_adjustment: Option<Decimal>,
873 #[serde(
876 rename = "guaranteedExecutionFees",
877 default,
878 skip_serializing_if = "Option::is_none"
879 )]
880 #[serde(deserialize_with = "crate::decimal_wire::optional_number_or_string")]
881 pub guaranteed_execution_fees: Option<Decimal>,
882 #[serde(
885 rename = "marginCallEnterTime",
886 default,
887 skip_serializing_if = "Option::is_none"
888 )]
889 pub margin_call_enter_time: Option<Timestamp>,
890 #[serde(
892 rename = "marginCallExtensionCount",
893 default,
894 skip_serializing_if = "Option::is_none"
895 )]
896 pub margin_call_extension_count: Option<i64>,
897 #[serde(
899 rename = "lastMarginCallExtensionTime",
900 default,
901 skip_serializing_if = "Option::is_none"
902 )]
903 pub last_margin_call_extension_time: Option<Timestamp>,
904 #[serde(
909 rename = "lastOrderFillTimestamp",
910 default,
911 skip_serializing_if = "Option::is_none"
912 )]
913 pub last_order_fill_timestamp: Option<Timestamp>,
914 #[serde(
916 rename = "lastTransactionID",
917 default,
918 skip_serializing_if = "Option::is_none"
919 )]
920 pub last_transaction_id: Option<TransactionID>,
921}
922
923#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
925#[serde(rename_all = "camelCase")]
926pub struct AccumulatedAccountState {
927 #[serde(rename = "balance", default, skip_serializing_if = "Option::is_none")]
929 #[serde(deserialize_with = "crate::decimal_wire::optional_number_or_string")]
930 pub balance: Option<Decimal>,
931 #[serde(rename = "pl", default, skip_serializing_if = "Option::is_none")]
933 #[serde(deserialize_with = "crate::decimal_wire::optional_number_or_string")]
934 pub pl: Option<Decimal>,
935 #[serde(
937 rename = "resettablePL",
938 default,
939 skip_serializing_if = "Option::is_none"
940 )]
941 #[serde(deserialize_with = "crate::decimal_wire::optional_number_or_string")]
942 pub resettable_pl: Option<Decimal>,
943 #[serde(rename = "financing", default, skip_serializing_if = "Option::is_none")]
945 #[serde(deserialize_with = "crate::decimal_wire::optional_number_or_string")]
946 pub financing: Option<Decimal>,
947 #[serde(
949 rename = "commission",
950 default,
951 skip_serializing_if = "Option::is_none"
952 )]
953 #[serde(deserialize_with = "crate::decimal_wire::optional_number_or_string")]
954 pub commission: Option<Decimal>,
955 #[serde(
958 rename = "dividendAdjustment",
959 default,
960 skip_serializing_if = "Option::is_none"
961 )]
962 #[serde(deserialize_with = "crate::decimal_wire::optional_number_or_string")]
963 pub dividend_adjustment: Option<Decimal>,
964 #[serde(
967 rename = "guaranteedExecutionFees",
968 default,
969 skip_serializing_if = "Option::is_none"
970 )]
971 #[serde(deserialize_with = "crate::decimal_wire::optional_number_or_string")]
972 pub guaranteed_execution_fees: Option<Decimal>,
973 #[serde(
976 rename = "marginCallEnterTime",
977 default,
978 skip_serializing_if = "Option::is_none"
979 )]
980 pub margin_call_enter_time: Option<Timestamp>,
981 #[serde(
983 rename = "marginCallExtensionCount",
984 default,
985 skip_serializing_if = "Option::is_none"
986 )]
987 pub margin_call_extension_count: Option<i64>,
988 #[serde(
990 rename = "lastMarginCallExtensionTime",
991 default,
992 skip_serializing_if = "Option::is_none"
993 )]
994 pub last_margin_call_extension_time: Option<Timestamp>,
995}
996
997#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
999#[serde(rename_all = "camelCase")]
1000pub struct CalculatedAccountState {
1001 #[serde(
1003 rename = "unrealizedPL",
1004 default,
1005 skip_serializing_if = "Option::is_none"
1006 )]
1007 #[serde(deserialize_with = "crate::decimal_wire::optional_number_or_string")]
1008 pub unrealized_pl: Option<Decimal>,
1009 #[serde(rename = "NAV", default, skip_serializing_if = "Option::is_none")]
1011 #[serde(deserialize_with = "crate::decimal_wire::optional_number_or_string")]
1012 pub nav: Option<Decimal>,
1013 #[serde(
1015 rename = "marginUsed",
1016 default,
1017 skip_serializing_if = "Option::is_none"
1018 )]
1019 #[serde(deserialize_with = "crate::decimal_wire::optional_number_or_string")]
1020 pub margin_used: Option<Decimal>,
1021 #[serde(
1023 rename = "marginAvailable",
1024 default,
1025 skip_serializing_if = "Option::is_none"
1026 )]
1027 #[serde(deserialize_with = "crate::decimal_wire::optional_number_or_string")]
1028 pub margin_available: Option<Decimal>,
1029 #[serde(
1031 rename = "positionValue",
1032 default,
1033 skip_serializing_if = "Option::is_none"
1034 )]
1035 #[serde(deserialize_with = "crate::decimal_wire::optional_number_or_string")]
1036 pub position_value: Option<Decimal>,
1037 #[serde(
1039 rename = "marginCloseoutUnrealizedPL",
1040 default,
1041 skip_serializing_if = "Option::is_none"
1042 )]
1043 #[serde(deserialize_with = "crate::decimal_wire::optional_number_or_string")]
1044 pub margin_closeout_unrealized_pl: Option<Decimal>,
1045 #[serde(
1047 rename = "marginCloseoutNAV",
1048 default,
1049 skip_serializing_if = "Option::is_none"
1050 )]
1051 #[serde(deserialize_with = "crate::decimal_wire::optional_number_or_string")]
1052 pub margin_closeout_nav: Option<Decimal>,
1053 #[serde(
1055 rename = "marginCloseoutMarginUsed",
1056 default,
1057 skip_serializing_if = "Option::is_none"
1058 )]
1059 #[serde(deserialize_with = "crate::decimal_wire::optional_number_or_string")]
1060 pub margin_closeout_margin_used: Option<Decimal>,
1061 #[serde(
1064 rename = "marginCloseoutPercent",
1065 default,
1066 skip_serializing_if = "Option::is_none"
1067 )]
1068 #[serde(deserialize_with = "crate::decimal_wire::optional_number_or_string")]
1069 pub margin_closeout_percent: Option<Decimal>,
1070 #[serde(
1073 rename = "marginCloseoutPositionValue",
1074 default,
1075 skip_serializing_if = "Option::is_none"
1076 )]
1077 #[serde(deserialize_with = "crate::decimal_wire::optional_number_or_string")]
1078 pub margin_closeout_position_value: Option<Decimal>,
1079 #[serde(
1082 rename = "withdrawalLimit",
1083 default,
1084 skip_serializing_if = "Option::is_none"
1085 )]
1086 #[serde(deserialize_with = "crate::decimal_wire::optional_number_or_string")]
1087 pub withdrawal_limit: Option<Decimal>,
1088 #[serde(
1090 rename = "marginCallMarginUsed",
1091 default,
1092 skip_serializing_if = "Option::is_none"
1093 )]
1094 #[serde(deserialize_with = "crate::decimal_wire::optional_number_or_string")]
1095 pub margin_call_margin_used: Option<Decimal>,
1096 #[serde(
1099 rename = "marginCallPercent",
1100 default,
1101 skip_serializing_if = "Option::is_none"
1102 )]
1103 #[serde(deserialize_with = "crate::decimal_wire::optional_number_or_string")]
1104 pub margin_call_percent: Option<Decimal>,
1105}
1106
1107#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1110#[serde(rename_all = "camelCase")]
1111pub struct AccountChanges {
1112 #[serde(
1114 rename = "ordersCreated",
1115 default,
1116 skip_serializing_if = "Option::is_none"
1117 )]
1118 pub orders_created: Option<Vec<Order>>,
1119 #[serde(
1121 rename = "ordersCancelled",
1122 default,
1123 skip_serializing_if = "Option::is_none"
1124 )]
1125 pub orders_cancelled: Option<Vec<Order>>,
1126 #[serde(
1128 rename = "ordersFilled",
1129 default,
1130 skip_serializing_if = "Option::is_none"
1131 )]
1132 pub orders_filled: Option<Vec<Order>>,
1133 #[serde(
1135 rename = "ordersTriggered",
1136 default,
1137 skip_serializing_if = "Option::is_none"
1138 )]
1139 pub orders_triggered: Option<Vec<Order>>,
1140 #[serde(
1142 rename = "tradesOpened",
1143 default,
1144 skip_serializing_if = "Option::is_none"
1145 )]
1146 pub trades_opened: Option<Vec<TradeSummary>>,
1147 #[serde(
1149 rename = "tradesReduced",
1150 default,
1151 skip_serializing_if = "Option::is_none"
1152 )]
1153 pub trades_reduced: Option<Vec<TradeSummary>>,
1154 #[serde(
1156 rename = "tradesClosed",
1157 default,
1158 skip_serializing_if = "Option::is_none"
1159 )]
1160 pub trades_closed: Option<Vec<TradeSummary>>,
1161 #[serde(rename = "positions", default, skip_serializing_if = "Option::is_none")]
1163 pub positions: Option<Vec<Position>>,
1164 #[serde(
1166 rename = "transactions",
1167 default,
1168 skip_serializing_if = "Option::is_none"
1169 )]
1170 pub transactions: Option<Vec<Transaction>>,
1171}
1172
1173#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1175#[non_exhaustive]
1176pub enum AccountFinancingMode {
1177 NoFinancing,
1179 SecondBySecond,
1182 Daily,
1184 Unknown(String),
1186}
1187
1188impl AccountFinancingMode {
1189 pub fn as_str(&self) -> &str {
1191 match self {
1192 Self::NoFinancing => "NO_FINANCING",
1193 Self::SecondBySecond => "SECOND_BY_SECOND",
1194 Self::Daily => "DAILY",
1195 Self::Unknown(value) => value,
1196 }
1197 }
1198}
1199
1200impl Serialize for AccountFinancingMode {
1201 fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
1202 serializer.serialize_str(self.as_str())
1203 }
1204}
1205
1206impl<'de> Deserialize<'de> for AccountFinancingMode {
1207 fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
1208 let value = String::deserialize(deserializer)?;
1209 Ok(match value.as_str() {
1210 "NO_FINANCING" => Self::NoFinancing,
1211 "SECOND_BY_SECOND" => Self::SecondBySecond,
1212 "DAILY" => Self::Daily,
1213 _ => Self::Unknown(value),
1214 })
1215 }
1216}
1217
1218#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1220#[serde(rename_all = "camelCase")]
1221pub struct UserAttributes {
1222 #[serde(rename = "userID", default, skip_serializing_if = "Option::is_none")]
1224 pub user_id: Option<i64>,
1225 #[serde(rename = "username", default, skip_serializing_if = "Option::is_none")]
1227 pub username: Option<String>,
1228 #[serde(rename = "title", default, skip_serializing_if = "Option::is_none")]
1230 pub title: Option<String>,
1231 #[serde(rename = "name", default, skip_serializing_if = "Option::is_none")]
1233 pub name: Option<String>,
1234 #[serde(rename = "email", default, skip_serializing_if = "Option::is_none")]
1236 pub email: Option<String>,
1237 #[serde(
1239 rename = "divisionAbbreviation",
1240 default,
1241 skip_serializing_if = "Option::is_none"
1242 )]
1243 pub division_abbreviation: Option<String>,
1244 #[serde(
1246 rename = "languageAbbreviation",
1247 default,
1248 skip_serializing_if = "Option::is_none"
1249 )]
1250 pub language_abbreviation: Option<String>,
1251 #[serde(
1253 rename = "homeCurrency",
1254 default,
1255 skip_serializing_if = "Option::is_none"
1256 )]
1257 pub home_currency: Option<Currency>,
1258}
1259
1260#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1262#[non_exhaustive]
1263pub enum PositionAggregationMode {
1264 AbsoluteSum,
1267 MaximalSide,
1270 NetSum,
1273 Unknown(String),
1275}
1276
1277impl PositionAggregationMode {
1278 pub fn as_str(&self) -> &str {
1280 match self {
1281 Self::AbsoluteSum => "ABSOLUTE_SUM",
1282 Self::MaximalSide => "MAXIMAL_SIDE",
1283 Self::NetSum => "NET_SUM",
1284 Self::Unknown(value) => value,
1285 }
1286 }
1287}
1288
1289impl Serialize for PositionAggregationMode {
1290 fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
1291 serializer.serialize_str(self.as_str())
1292 }
1293}
1294
1295impl<'de> Deserialize<'de> for PositionAggregationMode {
1296 fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
1297 let value = String::deserialize(deserializer)?;
1298 Ok(match value.as_str() {
1299 "ABSOLUTE_SUM" => Self::AbsoluteSum,
1300 "MAXIMAL_SIDE" => Self::MaximalSide,
1301 "NET_SUM" => Self::NetSum,
1302 _ => Self::Unknown(value),
1303 })
1304 }
1305}