Skip to main content

nautilus_kalshi/http/
models.rs

1// -------------------------------------------------------------------------------------------------
2//  Copyright (C) 2015-2026 Nautech Systems Pty Ltd. All rights reserved.
3//  https://nautechsystems.io
4//
5//  Licensed under the GNU Lesser General Public License Version 3.0 (the "License");
6//  You may not use this file except in compliance with the License.
7//  You may obtain a copy of the License at https://www.gnu.org/licenses/lgpl-3.0.en.html
8//
9//  Unless required by applicable law or agreed to in writing, software
10//  distributed under the License is distributed on an "AS IS" BASIS,
11//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12//  See the License for the specific language governing permissions and
13//  limitations under the License.
14// -------------------------------------------------------------------------------------------------
15
16//! Kalshi REST API models.
17
18use 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/// A fixed-point wire string, retaining its exact decimal value and scale.
32#[derive(Debug, Clone, Copy, PartialEq, Eq)]
33pub struct FixedPoint(pub Decimal);
34
35/// An exact JSON number decoded from its source text without a binary float conversion.
36#[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/// A wire field whose absence differs from explicit null and from a value.
82#[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    /// Returns whether the field is absent from the payload.
92    #[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/// The YES-price order-book side.
114#[derive(Debug, Clone, Copy, PartialEq, Eq, EnumIter, Serialize, Deserialize)]
115#[serde(rename_all = "lowercase")]
116pub enum BookSide {
117    Bid,
118    Ask,
119}
120
121/// The contract outcome side.
122#[derive(Debug, Clone, Copy, PartialEq, Eq, EnumIter, Serialize, Deserialize)]
123#[serde(rename_all = "lowercase")]
124pub enum OutcomeSide {
125    Yes,
126    No,
127}
128
129/// A venue order state; unknown states require explicit domain rejection.
130#[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/// Self-trade prevention policy accepted by V2 orders.
141#[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/// V2 time in force; expiration uses good-till-canceled with a timestamp.
149#[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/// Public exchange availability, including per-shard state when supplied.
158#[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/// Availability of one exchange shard.
171#[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/// A fixed-point market price-grid interval.
181#[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/// Raw market metadata and exact quote, volume, and settlement values.
189#[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/// Event identity and collateral metadata, with optional nested markets.
243#[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/// Provider settlement-source reference.
270#[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/// Series metadata used by discovery and fee qualification.
279#[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/// Fixed-point YES and NO bid levels, each encoded as price and count.
305#[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/// Public trade with canonical taker-side fields.
312#[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/// Bid or ask candle prices.
326#[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/// Trade candle prices; missing and null prices remain distinct.
335#[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/// One candle; the period end is Unix time in seconds.
356#[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/// Archived bid/ask prices use unsuffixed dollar fields.
367#[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/// Archived trade prices are required nullable dollar fields.
376#[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/// An archived candle with exact unsuffixed count strings.
393#[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/// Archive partition cutoffs as exact timestamps.
404#[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/// Subaccount collateral; integer amounts use venue cents.
414#[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/// Dollar collateral for one exchange shard.
425#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
426pub struct IndexedBalance {
427    pub exchange_index: i32,
428    pub balance: FixedPoint,
429}
430
431/// Signed market position and exact economics, without an inferred entry price.
432#[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/// Event-level position economics.
445#[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/// A settlement record still available in the live tier.
456#[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/// A private fill with stable fill, trade, and order identities.
474#[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/// A raw order report retaining exact costs, fees, and canonical sides.
498#[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/// Provider error fields. Diagnostics must redact their potentially private values.
537#[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/// A V2 create acknowledgement; absent average prices do not imply zero.
555#[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/// A V2 amend acknowledgement.
570#[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/// A V2 decrease acknowledgement.
587#[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/// A V2 cancellation acknowledgement.
597#[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/// One independent batch-create outcome, including venue rejection evidence.
607#[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/// One independent batch-cancel outcome.
628#[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/// Token-bucket refill and capacity advertised by the venue.
641#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
642pub struct BucketLimit {
643    pub refill_rate: i64,
644    pub bucket_capacity: i64,
645}
646
647/// A provider usage-level grant.
648#[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/// Account token limits; enforcement belongs to the shared budget owner.
658#[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/// An endpoint's advertised token cost.
667#[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/// Default and endpoint-specific token costs.
675#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
676pub struct EndpointCosts {
677    pub default_cost: i64,
678    pub endpoint_costs: Vec<EndpointCost>,
679}
680
681/// A market response envelope.
682#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
683pub struct MarketResponse {
684    pub market: Market,
685}
686
687/// A paginated markets response.
688#[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/// An event response, including the separately returned markets.
696#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
697pub struct EventResponse {
698    pub event: Event,
699    pub markets: Vec<Market>,
700}
701
702/// A paginated events response.
703#[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/// A series response envelope.
711#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
712pub struct SeriesResponse {
713    pub series: Series,
714}
715
716/// An unpaginated series response.
717#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
718pub struct SeriesListResponse {
719    pub series: Vec<Series>,
720}
721
722/// A REST order-book envelope.
723#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
724pub struct OrderbookResponse {
725    pub orderbook_fp: Orderbook,
726}
727
728/// A paginated trades response.
729#[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/// A live market's candles.
737#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
738pub struct CandlesticksResponse {
739    pub ticker: String,
740    pub candlesticks: Vec<Candlestick>,
741}
742
743/// An archived market's candles.
744#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
745pub struct HistoricalCandlesticksResponse {
746    pub ticker: String,
747    pub candlesticks: Vec<HistoricalCandlestick>,
748}
749
750/// Market and event positions from one live or archived page.
751#[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/// Collected market/event positions and explicit pagination completeness.
760#[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/// A paginated settlements response.
769#[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/// A paginated private fills response.
777#[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/// A paginated orders response.
785#[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/// A single order report envelope.
793#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
794pub struct OrderResponse {
795    pub order: Order,
796}
797
798/// Independent batch-create results.
799#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
800pub struct BatchCreateResponse {
801    pub orders: Vec<BatchCreateOrder>,
802}
803
804/// Independent selected-ID batch-cancel results.
805#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
806pub struct BatchCancelResponse {
807    pub orders: Vec<BatchCancelOrder>,
808}