1use std::fmt::Debug;
19
20use jiff::Timestamp;
21use nautilus_core::serialization::decimal;
22use rust_decimal::Decimal;
23use serde::{Deserialize, Deserializer, Serialize, Serializer};
24use strum::EnumIter;
25
26use crate::common::enums::{
27 ApiUsageTier, CollateralReturnType, ExchangeInstance, FeeType, MarketResult, MarketStatus,
28 MarketType, OrderType, PriceLevelStructure, SettlementBoundsType, UsageGrantSource,
29};
30
31#[derive(Debug, Clone, Copy, PartialEq, Eq)]
33pub struct FixedPoint(pub Decimal);
34
35#[derive(Debug, Clone, Copy, PartialEq, Eq)]
37pub struct DecimalNumber(pub Decimal);
38
39impl Serialize for DecimalNumber {
40 fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
41 let raw = serde_json::value::RawValue::from_string(self.0.to_string())
42 .map_err(serde::ser::Error::custom)?;
43 raw.serialize(serializer)
44 }
45}
46
47impl<'de> Deserialize<'de> for DecimalNumber {
48 fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
49 let raw = Box::<serde_json::value::RawValue>::deserialize(deserializer)?;
50 decimal::parse(raw.get())
51 .map(Self)
52 .map_err(|_| serde::de::Error::custom("invalid exact decimal number"))
53 }
54}
55
56impl Serialize for FixedPoint {
57 fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
58 serializer.serialize_str(&self.0.to_string())
59 }
60}
61
62impl<'de> Deserialize<'de> for FixedPoint {
63 fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
64 let value = String::deserialize(deserializer)?;
65 let digits = value.strip_prefix('-').unwrap_or(&value);
66 let valid = !digits.is_empty()
67 && digits.bytes().all(|c| c.is_ascii_digit() || c == b'.')
68 && !digits.starts_with('.')
69 && !digits.ends_with('.');
70
71 if !valid {
72 return Err(serde::de::Error::custom("invalid fixed-point string"));
73 }
74
75 Decimal::from_str_exact(&value)
76 .map(Self)
77 .map_err(|_| serde::de::Error::custom("fixed-point value exceeds decimal precision"))
78 }
79}
80
81#[derive(Debug, Clone, Default, PartialEq, Eq)]
83pub enum Field<T> {
84 #[default]
85 Missing,
86 Null,
87 Value(T),
88}
89
90impl<T> Field<T> {
91 #[must_use]
93 pub const fn is_missing(&self) -> bool {
94 matches!(self, Self::Missing)
95 }
96}
97
98impl<T: Serialize> Serialize for Field<T> {
99 fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
100 match self {
101 Self::Missing | Self::Null => serializer.serialize_none(),
102 Self::Value(value) => value.serialize(serializer),
103 }
104 }
105}
106
107impl<'de, T: Deserialize<'de>> Deserialize<'de> for Field<T> {
108 fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
109 Option::<T>::deserialize(deserializer).map(|value| value.map_or(Self::Null, Self::Value))
110 }
111}
112
113#[derive(Debug, Clone, Copy, PartialEq, Eq, EnumIter, Serialize, Deserialize)]
115#[serde(rename_all = "lowercase")]
116pub enum BookSide {
117 Bid,
118 Ask,
119}
120
121#[derive(Debug, Clone, Copy, PartialEq, Eq, EnumIter, Serialize, Deserialize)]
123#[serde(rename_all = "lowercase")]
124pub enum OutcomeSide {
125 Yes,
126 No,
127}
128
129#[derive(Debug, Clone, Copy, PartialEq, Eq, EnumIter, Serialize, Deserialize)]
131#[serde(rename_all = "lowercase")]
132pub enum OrderStatus {
133 Resting,
134 Canceled,
135 Executed,
136 #[serde(other)]
137 Unknown,
138}
139
140#[derive(Debug, Clone, Copy, PartialEq, Eq, EnumIter, Serialize, Deserialize)]
142#[serde(rename_all = "snake_case")]
143pub enum SelfTradePrevention {
144 TakerAtCross,
145 Maker,
146}
147
148#[derive(Debug, Clone, Copy, PartialEq, Eq, EnumIter, Serialize, Deserialize)]
150#[serde(rename_all = "snake_case")]
151pub enum TimeInForce {
152 FillOrKill,
153 GoodTillCanceled,
154 ImmediateOrCancel,
155}
156
157#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
159pub struct ExchangeStatus {
160 pub exchange_active: bool,
161 pub trading_active: bool,
162 #[serde(default, skip_serializing_if = "Field::is_missing")]
163 pub intra_exchange_transfers_active: Field<bool>,
164 #[serde(default, skip_serializing_if = "Field::is_missing")]
165 pub exchange_estimated_resume_time: Field<Timestamp>,
166 #[serde(default, skip_serializing_if = "Field::is_missing")]
167 pub exchange_index_statuses: Field<Vec<ExchangeIndexStatus>>,
168}
169
170#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
172pub struct ExchangeIndexStatus {
173 pub exchange_index: i32,
174 pub description: String,
175 pub exchange_active: bool,
176 pub trading_active: bool,
177 pub intra_exchange_transfers_active: bool,
178}
179
180#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
182pub struct PriceRange {
183 pub start: FixedPoint,
184 pub end: FixedPoint,
185 pub step: FixedPoint,
186}
187
188#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
190pub struct Market {
191 pub ticker: String,
192 pub event_ticker: String,
193 pub market_type: MarketType,
194 pub yes_sub_title: String,
195 pub no_sub_title: String,
196 pub created_time: Timestamp,
197 #[serde(default, skip_serializing_if = "Field::is_missing")]
198 pub updated_time: Field<Timestamp>,
199 pub open_time: Timestamp,
200 pub close_time: Timestamp,
201 pub latest_expiration_time: Timestamp,
202 pub settlement_timer_seconds: i64,
203 pub status: MarketStatus,
204 pub yes_bid_dollars: FixedPoint,
205 pub yes_bid_size_fp: FixedPoint,
206 pub yes_ask_dollars: FixedPoint,
207 pub yes_ask_size_fp: FixedPoint,
208 pub no_bid_dollars: FixedPoint,
209 pub no_ask_dollars: FixedPoint,
210 pub last_price_dollars: FixedPoint,
211 pub volume_fp: FixedPoint,
212 pub volume_24h_fp: FixedPoint,
213 pub result: MarketResult,
214 pub can_close_early: bool,
215 pub open_interest_fp: FixedPoint,
216 pub notional_value_dollars: FixedPoint,
217 pub previous_yes_bid_dollars: FixedPoint,
218 pub previous_yes_ask_dollars: FixedPoint,
219 pub previous_price_dollars: FixedPoint,
220 pub settlement_bounds_type: SettlementBoundsType,
221 pub expiration_value: String,
222 pub rules_primary: String,
223 pub rules_secondary: String,
224 pub price_level_structure: PriceLevelStructure,
225 pub price_ranges: Vec<PriceRange>,
226 #[serde(default, skip_serializing_if = "Field::is_missing")]
227 pub exchange_index: Field<i32>,
228 #[serde(default, skip_serializing_if = "Field::is_missing")]
229 pub settlement_value_dollars: Field<FixedPoint>,
230 #[serde(default, skip_serializing_if = "Field::is_missing")]
231 pub settlement_floor_dollars: Field<FixedPoint>,
232 #[serde(default, skip_serializing_if = "Field::is_missing")]
233 pub settlement_ts: Field<Timestamp>,
234 #[serde(default, skip_serializing_if = "Field::is_missing")]
235 pub expected_expiration_time: Field<Timestamp>,
236 #[serde(default, skip_serializing_if = "Field::is_missing")]
237 pub mve_collection_ticker: Field<String>,
238 #[serde(default, skip_serializing_if = "Field::is_missing")]
239 pub mve_selected_legs: Field<Vec<serde_json::Value>>,
240}
241
242#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
244pub struct Event {
245 pub event_ticker: String,
246 pub series_ticker: String,
247 pub sub_title: String,
248 pub title: String,
249 pub collateral_return_type: CollateralReturnType,
250 pub mutually_exclusive: bool,
251 #[serde(deserialize_with = "Option::deserialize")]
252 pub settlement_sources: Option<Vec<SettlementSource>>,
253 #[serde(default, skip_serializing_if = "Field::is_missing")]
254 pub markets: Field<Vec<Market>>,
255 #[serde(default, skip_serializing_if = "Field::is_missing")]
256 pub exchange_index: Field<i32>,
257 #[serde(default, skip_serializing_if = "Field::is_missing")]
258 pub last_updated_ts: Field<Timestamp>,
259 #[serde(default, skip_serializing_if = "Field::is_missing")]
260 pub strike_date: Field<Timestamp>,
261 #[serde(default, skip_serializing_if = "Field::is_missing")]
262 pub strike_period: Field<String>,
263 #[serde(default, skip_serializing_if = "Field::is_missing")]
264 pub fee_type_override: Field<FeeType>,
265 #[serde(default, skip_serializing_if = "Field::is_missing")]
266 pub fee_multiplier_override: Field<DecimalNumber>,
267}
268
269#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
271pub struct SettlementSource {
272 #[serde(default, skip_serializing_if = "Field::is_missing")]
273 pub name: Field<String>,
274 #[serde(default, skip_serializing_if = "Field::is_missing")]
275 pub url: Field<String>,
276}
277
278#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
280pub struct Series {
281 pub ticker: String,
282 pub frequency: String,
283 pub title: String,
284 pub category: String,
285 pub categories: Vec<String>,
286 #[serde(deserialize_with = "Option::deserialize")]
287 pub tags: Option<Vec<String>>,
288 #[serde(deserialize_with = "Option::deserialize")]
289 pub settlement_sources: Option<Vec<SettlementSource>>,
290 pub contract_url: String,
291 pub contract_terms_url: String,
292 pub fee_type: FeeType,
293 pub fee_multiplier: DecimalNumber,
294 #[serde(deserialize_with = "Option::deserialize")]
295 pub additional_prohibitions: Option<Vec<String>>,
296 #[serde(default, skip_serializing_if = "Field::is_missing")]
297 pub volume_fp: Field<FixedPoint>,
298 #[serde(default, skip_serializing_if = "Field::is_missing")]
299 pub last_updated_ts: Field<Timestamp>,
300 #[serde(default, skip_serializing_if = "Field::is_missing")]
301 pub exchange_index: Field<i32>,
302}
303
304#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
306pub struct Orderbook {
307 pub yes_dollars: Vec<[FixedPoint; 2]>,
308 pub no_dollars: Vec<[FixedPoint; 2]>,
309}
310
311#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
313pub struct Trade {
314 pub trade_id: String,
315 pub ticker: String,
316 pub count_fp: FixedPoint,
317 pub yes_price_dollars: FixedPoint,
318 pub no_price_dollars: FixedPoint,
319 pub taker_outcome_side: OutcomeSide,
320 pub taker_book_side: BookSide,
321 pub created_time: Timestamp,
322 pub is_block_trade: bool,
323}
324
325#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
327pub struct BidAskDistribution {
328 pub open_dollars: FixedPoint,
329 pub low_dollars: FixedPoint,
330 pub high_dollars: FixedPoint,
331 pub close_dollars: FixedPoint,
332}
333
334#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
336pub struct PriceDistribution {
337 #[serde(default, skip_serializing_if = "Field::is_missing")]
338 pub open_dollars: Field<FixedPoint>,
339 #[serde(default, skip_serializing_if = "Field::is_missing")]
340 pub low_dollars: Field<FixedPoint>,
341 #[serde(default, skip_serializing_if = "Field::is_missing")]
342 pub high_dollars: Field<FixedPoint>,
343 #[serde(default, skip_serializing_if = "Field::is_missing")]
344 pub close_dollars: Field<FixedPoint>,
345 #[serde(default, skip_serializing_if = "Field::is_missing")]
346 pub mean_dollars: Field<FixedPoint>,
347 #[serde(default, skip_serializing_if = "Field::is_missing")]
348 pub previous_dollars: Field<FixedPoint>,
349 #[serde(default, skip_serializing_if = "Field::is_missing")]
350 pub min_dollars: Field<FixedPoint>,
351 #[serde(default, skip_serializing_if = "Field::is_missing")]
352 pub max_dollars: Field<FixedPoint>,
353}
354
355#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
357pub struct Candlestick {
358 pub end_period_ts: i64,
359 pub yes_bid: BidAskDistribution,
360 pub yes_ask: BidAskDistribution,
361 pub price: PriceDistribution,
362 pub volume_fp: FixedPoint,
363 pub open_interest_fp: FixedPoint,
364}
365
366#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
368pub struct HistoricalBidAskDistribution {
369 pub open: FixedPoint,
370 pub low: FixedPoint,
371 pub high: FixedPoint,
372 pub close: FixedPoint,
373}
374
375#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
377pub struct HistoricalPriceDistribution {
378 #[serde(deserialize_with = "Option::deserialize")]
379 pub open: Option<FixedPoint>,
380 #[serde(deserialize_with = "Option::deserialize")]
381 pub low: Option<FixedPoint>,
382 #[serde(deserialize_with = "Option::deserialize")]
383 pub high: Option<FixedPoint>,
384 #[serde(deserialize_with = "Option::deserialize")]
385 pub close: Option<FixedPoint>,
386 #[serde(deserialize_with = "Option::deserialize")]
387 pub mean: Option<FixedPoint>,
388 #[serde(deserialize_with = "Option::deserialize")]
389 pub previous: Option<FixedPoint>,
390}
391
392#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
394pub struct HistoricalCandlestick {
395 pub end_period_ts: i64,
396 pub yes_bid: HistoricalBidAskDistribution,
397 pub yes_ask: HistoricalBidAskDistribution,
398 pub price: HistoricalPriceDistribution,
399 pub volume: FixedPoint,
400 pub open_interest: FixedPoint,
401}
402
403#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
405pub struct HistoricalCutoff {
406 pub market_settled_ts: Timestamp,
407 pub trades_created_ts: Timestamp,
408 pub orders_updated_ts: Timestamp,
409 #[serde(default, skip_serializing_if = "Field::is_missing")]
410 pub market_positions_last_updated_ts: Field<Timestamp>,
411}
412
413#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
415pub struct Balance {
416 pub balance: i64,
417 pub balance_dollars: FixedPoint,
418 pub portfolio_value: i64,
419 pub updated_ts: i64,
420 #[serde(default, skip_serializing_if = "Field::is_missing")]
421 pub balance_breakdown: Field<Vec<IndexedBalance>>,
422}
423
424#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
426pub struct IndexedBalance {
427 pub exchange_index: i32,
428 pub balance: FixedPoint,
429}
430
431#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
433pub struct MarketPosition {
434 pub ticker: String,
435 pub exchange_index: i32,
436 pub total_traded_dollars: FixedPoint,
437 pub position_fp: FixedPoint,
438 pub market_exposure_dollars: FixedPoint,
439 pub realized_pnl_dollars: FixedPoint,
440 pub fees_paid_dollars: FixedPoint,
441 pub last_updated_ts: Timestamp,
442}
443
444#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
446pub struct EventPosition {
447 pub event_ticker: String,
448 pub total_cost_dollars: FixedPoint,
449 pub total_cost_shares_fp: FixedPoint,
450 pub event_exposure_dollars: FixedPoint,
451 pub realized_pnl_dollars: FixedPoint,
452 pub fees_paid_dollars: FixedPoint,
453}
454
455#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
457pub struct Settlement {
458 pub ticker: String,
459 pub exchange_index: i32,
460 pub event_ticker: String,
461 pub market_result: MarketResult,
462 pub yes_count_fp: FixedPoint,
463 pub yes_total_cost_dollars: FixedPoint,
464 pub no_count_fp: FixedPoint,
465 pub no_total_cost_dollars: FixedPoint,
466 pub revenue: i64,
467 pub settled_time: Timestamp,
468 pub fee_cost: FixedPoint,
469 #[serde(default, skip_serializing_if = "Field::is_missing")]
470 pub value: Field<i64>,
471}
472
473#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
475pub struct Fill {
476 pub fill_id: String,
477 pub exchange_index: i32,
478 pub trade_id: String,
479 pub order_id: String,
480 pub ticker: String,
481 pub market_ticker: String,
482 pub outcome_side: OutcomeSide,
483 pub book_side: BookSide,
484 pub count_fp: FixedPoint,
485 pub yes_price_dollars: FixedPoint,
486 pub no_price_dollars: FixedPoint,
487 pub is_taker: bool,
488 pub fee_cost: FixedPoint,
489 #[serde(default, skip_serializing_if = "Field::is_missing")]
490 pub created_time: Field<Timestamp>,
491 #[serde(default, skip_serializing_if = "Field::is_missing")]
492 pub subaccount_number: Field<i32>,
493 #[serde(default, skip_serializing_if = "Field::is_missing")]
494 pub ts: Field<i64>,
495}
496
497#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
499pub struct Order {
500 pub order_id: String,
501 pub user_id: String,
502 pub client_order_id: String,
503 pub ticker: String,
504 pub outcome_side: OutcomeSide,
505 pub book_side: BookSide,
506 #[serde(rename = "type")]
507 pub order_type: OrderType,
508 pub status: OrderStatus,
509 pub yes_price_dollars: FixedPoint,
510 pub no_price_dollars: FixedPoint,
511 pub fill_count_fp: FixedPoint,
512 pub remaining_count_fp: FixedPoint,
513 pub initial_count_fp: FixedPoint,
514 pub taker_fill_cost_dollars: FixedPoint,
515 pub maker_fill_cost_dollars: FixedPoint,
516 pub taker_fees_dollars: FixedPoint,
517 pub maker_fees_dollars: FixedPoint,
518 #[serde(default, skip_serializing_if = "Field::is_missing")]
519 pub expiration_time: Field<Timestamp>,
520 #[serde(default, skip_serializing_if = "Field::is_missing")]
521 pub created_time: Field<Timestamp>,
522 #[serde(default, skip_serializing_if = "Field::is_missing")]
523 pub last_update_time: Field<Timestamp>,
524 #[serde(default, skip_serializing_if = "Field::is_missing")]
525 pub self_trade_prevention_type: Field<SelfTradePrevention>,
526 #[serde(default, skip_serializing_if = "Field::is_missing")]
527 pub order_group_id: Field<String>,
528 #[serde(default, skip_serializing_if = "Field::is_missing")]
529 pub cancel_order_on_pause: Field<bool>,
530 #[serde(default, skip_serializing_if = "Field::is_missing")]
531 pub subaccount_number: Field<i32>,
532 #[serde(default, skip_serializing_if = "Field::is_missing")]
533 pub exchange_index: Field<i32>,
534}
535
536#[derive(Clone, PartialEq, Eq, Serialize, Deserialize)]
538pub struct VenueError {
539 #[serde(default, skip_serializing_if = "Field::is_missing")]
540 pub code: Field<String>,
541 #[serde(default, skip_serializing_if = "Field::is_missing")]
542 pub message: Field<String>,
543 #[serde(default, skip_serializing_if = "Field::is_missing")]
544 pub details: Field<String>,
545}
546
547impl Debug for VenueError {
548 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
549 f.debug_struct(stringify!(VenueError))
550 .finish_non_exhaustive()
551 }
552}
553
554#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
556pub struct CreateOrderResponse {
557 pub order_id: String,
558 pub fill_count: FixedPoint,
559 pub remaining_count: FixedPoint,
560 pub ts_ms: i64,
561 #[serde(default, skip_serializing_if = "Field::is_missing")]
562 pub client_order_id: Field<String>,
563 #[serde(default, skip_serializing_if = "Field::is_missing")]
564 pub average_fill_price: Field<FixedPoint>,
565 #[serde(default, skip_serializing_if = "Field::is_missing")]
566 pub average_fee_paid: Field<FixedPoint>,
567}
568
569#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
571pub struct AmendOrderResponse {
572 pub order_id: String,
573 pub ts_ms: i64,
574 #[serde(default, skip_serializing_if = "Field::is_missing")]
575 pub client_order_id: Field<String>,
576 #[serde(default, skip_serializing_if = "Field::is_missing")]
577 pub remaining_count: Field<FixedPoint>,
578 #[serde(default, skip_serializing_if = "Field::is_missing")]
579 pub fill_count: Field<FixedPoint>,
580 #[serde(default, skip_serializing_if = "Field::is_missing")]
581 pub average_fill_price: Field<FixedPoint>,
582 #[serde(default, skip_serializing_if = "Field::is_missing")]
583 pub average_fee_paid: Field<FixedPoint>,
584}
585
586#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
588pub struct DecreaseOrderResponse {
589 pub order_id: String,
590 pub remaining_count: FixedPoint,
591 pub ts_ms: i64,
592 #[serde(default, skip_serializing_if = "Field::is_missing")]
593 pub client_order_id: Field<String>,
594}
595
596#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
598pub struct CancelOrderResponse {
599 pub order_id: String,
600 pub reduced_by: FixedPoint,
601 pub ts_ms: i64,
602 #[serde(default, skip_serializing_if = "Field::is_missing")]
603 pub client_order_id: Field<String>,
604}
605
606#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
608pub struct BatchCreateOrder {
609 #[serde(default, skip_serializing_if = "Field::is_missing")]
610 pub order_id: Field<String>,
611 #[serde(default, skip_serializing_if = "Field::is_missing")]
612 pub client_order_id: Field<String>,
613 #[serde(default, skip_serializing_if = "Field::is_missing")]
614 pub fill_count: Field<FixedPoint>,
615 #[serde(default, skip_serializing_if = "Field::is_missing")]
616 pub remaining_count: Field<FixedPoint>,
617 #[serde(default, skip_serializing_if = "Field::is_missing")]
618 pub average_fill_price: Field<FixedPoint>,
619 #[serde(default, skip_serializing_if = "Field::is_missing")]
620 pub average_fee_paid: Field<FixedPoint>,
621 #[serde(default, skip_serializing_if = "Field::is_missing")]
622 pub ts_ms: Field<i64>,
623 #[serde(default, skip_serializing_if = "Field::is_missing")]
624 pub error: Field<VenueError>,
625}
626
627#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
629pub struct BatchCancelOrder {
630 pub order_id: String,
631 pub reduced_by: FixedPoint,
632 #[serde(default, skip_serializing_if = "Field::is_missing")]
633 pub client_order_id: Field<String>,
634 #[serde(default, skip_serializing_if = "Field::is_missing")]
635 pub ts_ms: Field<i64>,
636 #[serde(default, skip_serializing_if = "Field::is_missing")]
637 pub error: Field<VenueError>,
638}
639
640#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
642pub struct BucketLimit {
643 pub refill_rate: i64,
644 pub bucket_capacity: i64,
645}
646
647#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
649pub struct UsageGrant {
650 pub exchange_instance: ExchangeInstance,
651 pub level: ApiUsageTier,
652 pub source: UsageGrantSource,
653 #[serde(default, skip_serializing_if = "Field::is_missing")]
654 pub expires_ts: Field<i64>,
655}
656
657#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
659pub struct AccountLimits {
660 pub usage_tier: ApiUsageTier,
661 pub read: BucketLimit,
662 pub write: BucketLimit,
663 pub grants: Vec<UsageGrant>,
664}
665
666#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
668pub struct EndpointCost {
669 pub method: String,
670 pub path: String,
671 pub cost: i64,
672}
673
674#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
676pub struct EndpointCosts {
677 pub default_cost: i64,
678 pub endpoint_costs: Vec<EndpointCost>,
679}
680
681#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
683pub struct MarketResponse {
684 pub market: Market,
685}
686
687#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
689pub struct MarketsResponse {
690 pub markets: Vec<Market>,
691 #[serde(deserialize_with = "Field::deserialize")]
692 pub cursor: Field<String>,
693}
694
695#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
697pub struct EventResponse {
698 pub event: Event,
699 pub markets: Vec<Market>,
700}
701
702#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
704pub struct EventsResponse {
705 pub events: Vec<Event>,
706 #[serde(deserialize_with = "Field::deserialize")]
707 pub cursor: Field<String>,
708}
709
710#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
712pub struct SeriesResponse {
713 pub series: Series,
714}
715
716#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
718pub struct SeriesListResponse {
719 pub series: Vec<Series>,
720}
721
722#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
724pub struct OrderbookResponse {
725 pub orderbook_fp: Orderbook,
726}
727
728#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
730pub struct TradesResponse {
731 pub trades: Vec<Trade>,
732 #[serde(deserialize_with = "Field::deserialize")]
733 pub cursor: Field<String>,
734}
735
736#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
738pub struct CandlesticksResponse {
739 pub ticker: String,
740 pub candlesticks: Vec<Candlestick>,
741}
742
743#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
745pub struct HistoricalCandlesticksResponse {
746 pub ticker: String,
747 pub candlesticks: Vec<HistoricalCandlestick>,
748}
749
750#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
752pub struct PositionsResponse {
753 pub market_positions: Vec<MarketPosition>,
754 pub event_positions: Vec<EventPosition>,
755 #[serde(default, skip_serializing_if = "Field::is_missing")]
756 pub cursor: Field<String>,
757}
758
759#[derive(Debug, Clone, PartialEq, Eq)]
761pub struct PositionPages {
762 pub market_positions: Vec<MarketPosition>,
763 pub event_positions: Vec<EventPosition>,
764 pub complete: bool,
765 pub next_cursor: Option<String>,
766}
767
768#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
770pub struct SettlementsResponse {
771 pub settlements: Vec<Settlement>,
772 #[serde(default, skip_serializing_if = "Field::is_missing")]
773 pub cursor: Field<String>,
774}
775
776#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
778pub struct FillsResponse {
779 pub fills: Vec<Fill>,
780 #[serde(deserialize_with = "Field::deserialize")]
781 pub cursor: Field<String>,
782}
783
784#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
786pub struct OrdersResponse {
787 pub orders: Vec<Order>,
788 #[serde(deserialize_with = "Field::deserialize")]
789 pub cursor: Field<String>,
790}
791
792#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
794pub struct OrderResponse {
795 pub order: Order,
796}
797
798#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
800pub struct BatchCreateResponse {
801 pub orders: Vec<BatchCreateOrder>,
802}
803
804#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
806pub struct BatchCancelResponse {
807 pub orders: Vec<BatchCancelOrder>,
808}