models.hpp

Go to the documentation of this file.

// Generated by tools/codegen/generate.py from spec/openapi.yaml. Do not edit.
#pragma once
 
#include "kalshi/raw_json.hpp"
 
#include <array>
#include <cstdint>
#include <map>
#include <optional>
#include <string>
#include <string_view>
#include <vector>
 
namespace kalshi {
 
// ----- Scalars ----------------------------------------------------------
 
using ExchangeIndex = std::int64_t;
 
using FixedPointCount = std::string;
 
using FixedPointDollars = std::string;
 
using PriceLevelDollarsCountFp = std::array<std::string, 2>;
 
// ----- Enums ------------------------------------------------------------
 
enum class Action : std::uint8_t {
    Unknown, 
    Buy,     
    Sell,    
};
 
[[nodiscard]] constexpr std::string_view to_string(Action value) noexcept {
    switch (value) {
        case Action::Buy:
            return "buy";
        case Action::Sell:
            return "sell";
        case Action::Unknown:
            break;
    }
    return "";
}
 
enum class ApiKeyScope : std::uint8_t {
    Unknown,               
    Read,                  
    Write,                 
    ReadBlockTradeAccept,  
    ReadPortfolioBalance,  
    WriteTrade,            
    WriteTransfer,         
    WriteFcmRisk,          
    WriteBlockTradeAccept, 
};
 
[[nodiscard]] constexpr std::string_view to_string(ApiKeyScope value) noexcept {
    switch (value) {
        case ApiKeyScope::Read:
            return "read";
        case ApiKeyScope::Write:
            return "write";
        case ApiKeyScope::ReadBlockTradeAccept:
            return "read::block_trade_accept";
        case ApiKeyScope::ReadPortfolioBalance:
            return "read::portfolio_balance";
        case ApiKeyScope::WriteTrade:
            return "write::trade";
        case ApiKeyScope::WriteTransfer:
            return "write::transfer";
        case ApiKeyScope::WriteFcmRisk:
            return "write::fcm_risk";
        case ApiKeyScope::WriteBlockTradeAccept:
            return "write::block_trade_accept";
        case ApiKeyScope::Unknown:
            break;
    }
    return "";
}
 
enum class ApiKeyType : std::uint8_t {
    Unknown, 
    Rsa,     
    Ed25519, 
};
 
[[nodiscard]] constexpr std::string_view to_string(ApiKeyType value) noexcept {
    switch (value) {
        case ApiKeyType::Rsa:
            return "rsa";
        case ApiKeyType::Ed25519:
            return "ed25519";
        case ApiKeyType::Unknown:
            break;
    }
    return "";
}
 
enum class BookSide : std::uint8_t {
    Unknown, 
    Bid,     
    Ask,     
};
 
[[nodiscard]] constexpr std::string_view to_string(BookSide value) noexcept {
    switch (value) {
        case BookSide::Bid:
            return "bid";
        case BookSide::Ask:
            return "ask";
        case BookSide::Unknown:
            break;
    }
    return "";
}
 
enum class CreditHistoryStatus : std::uint8_t {
    Unknown, 
    Pending, 
    Failed,  
    Applied, 
};
 
[[nodiscard]] constexpr std::string_view to_string(CreditHistoryStatus value) noexcept {
    switch (value) {
        case CreditHistoryStatus::Pending:
            return "pending";
        case CreditHistoryStatus::Failed:
            return "failed";
        case CreditHistoryStatus::Applied:
            return "applied";
        case CreditHistoryStatus::Unknown:
            return "unknown";
    }
    return "";
}
 
enum class DepositStatus : std::uint8_t {
    Unknown,  
    Pending,  
    Applied,  
    Failed,   
    Returned, 
};
 
[[nodiscard]] constexpr std::string_view to_string(DepositStatus value) noexcept {
    switch (value) {
        case DepositStatus::Pending:
            return "pending";
        case DepositStatus::Applied:
            return "applied";
        case DepositStatus::Failed:
            return "failed";
        case DepositStatus::Returned:
            return "returned";
        case DepositStatus::Unknown:
            break;
    }
    return "";
}
 
enum class DepositType : std::uint8_t {
    Unknown, 
    Ach,     
    Wire,    
    Crypto,  
    Debit,   
    Apm,     
};
 
[[nodiscard]] constexpr std::string_view to_string(DepositType value) noexcept {
    switch (value) {
        case DepositType::Ach:
            return "ach";
        case DepositType::Wire:
            return "wire";
        case DepositType::Crypto:
            return "crypto";
        case DepositType::Debit:
            return "debit";
        case DepositType::Apm:
            return "apm";
        case DepositType::Unknown:
            break;
    }
    return "";
}
 
enum class EventContractExitTriggerStatus : std::uint8_t {
    Unknown,        
    PendingOnEntry, 
    Active,         
    Filled,         
    Canceled,       
    Failed,         
};
 
[[nodiscard]] constexpr std::string_view to_string(EventContractExitTriggerStatus value) noexcept {
    switch (value) {
        case EventContractExitTriggerStatus::PendingOnEntry:
            return "pending_on_entry";
        case EventContractExitTriggerStatus::Active:
            return "active";
        case EventContractExitTriggerStatus::Filled:
            return "filled";
        case EventContractExitTriggerStatus::Canceled:
            return "canceled";
        case EventContractExitTriggerStatus::Failed:
            return "failed";
        case EventContractExitTriggerStatus::Unknown:
            return "unknown";
    }
    return "";
}
 
enum class ExchangeInstance : std::uint8_t {
    Unknown,       
    EventContract, 
    Margined,      
};
 
[[nodiscard]] constexpr std::string_view to_string(ExchangeInstance value) noexcept {
    switch (value) {
        case ExchangeInstance::EventContract:
            return "event_contract";
        case ExchangeInstance::Margined:
            return "margined";
        case ExchangeInstance::Unknown:
            break;
    }
    return "";
}
 
enum class FeeType : std::uint8_t {
    Unknown,                     
    Quadratic,                   
    QuadraticWithMakerFees,      
    QuadraticWithComboMakerFees, 
    Flat,                        
};
 
[[nodiscard]] constexpr std::string_view to_string(FeeType value) noexcept {
    switch (value) {
        case FeeType::Quadratic:
            return "quadratic";
        case FeeType::QuadraticWithMakerFees:
            return "quadratic_with_maker_fees";
        case FeeType::QuadraticWithComboMakerFees:
            return "quadratic_with_combo_maker_fees";
        case FeeType::Flat:
            return "flat";
        case FeeType::Unknown:
            break;
    }
    return "";
}
 
enum class GetEventsStatus : std::uint8_t {
    Unknown,  
    Unopened, 
    Open,     
    Closed,   
    Settled,  
};
 
[[nodiscard]] constexpr std::string_view to_string(GetEventsStatus value) noexcept {
    switch (value) {
        case GetEventsStatus::Unopened:
            return "unopened";
        case GetEventsStatus::Open:
            return "open";
        case GetEventsStatus::Closed:
            return "closed";
        case GetEventsStatus::Settled:
            return "settled";
        case GetEventsStatus::Unknown:
            break;
    }
    return "";
}
 
enum class GetHistoricalMarketsMveFilter : std::uint8_t {
    Unknown, 
    Exclude, 
};
 
[[nodiscard]] constexpr std::string_view to_string(GetHistoricalMarketsMveFilter value) noexcept {
    switch (value) {
        case GetHistoricalMarketsMveFilter::Exclude:
            return "exclude";
        case GetHistoricalMarketsMveFilter::Unknown:
            break;
    }
    return "";
}
 
enum class GetIncentiveProgramsStatus : std::uint8_t {
    Unknown,  
    All,      
    Active,   
    Upcoming, 
    Closed,   
    PaidOut,  
};
 
[[nodiscard]] constexpr std::string_view to_string(GetIncentiveProgramsStatus value) noexcept {
    switch (value) {
        case GetIncentiveProgramsStatus::All:
            return "all";
        case GetIncentiveProgramsStatus::Active:
            return "active";
        case GetIncentiveProgramsStatus::Upcoming:
            return "upcoming";
        case GetIncentiveProgramsStatus::Closed:
            return "closed";
        case GetIncentiveProgramsStatus::PaidOut:
            return "paid_out";
        case GetIncentiveProgramsStatus::Unknown:
            break;
    }
    return "";
}
 
enum class GetIncentiveProgramsType : std::uint8_t {
    Unknown,           
    All,               
    Liquidity,         
    Volume,            
    MarginMakerVolume, 
    MarginTakerVolume, 
};
 
[[nodiscard]] constexpr std::string_view to_string(GetIncentiveProgramsType value) noexcept {
    switch (value) {
        case GetIncentiveProgramsType::All:
            return "all";
        case GetIncentiveProgramsType::Liquidity:
            return "liquidity";
        case GetIncentiveProgramsType::Volume:
            return "volume";
        case GetIncentiveProgramsType::MarginMakerVolume:
            return "margin_maker_volume";
        case GetIncentiveProgramsType::MarginTakerVolume:
            return "margin_taker_volume";
        case GetIncentiveProgramsType::Unknown:
            break;
    }
    return "";
}
 
enum class GetMarketsMveFilter : std::uint8_t {
    Unknown, 
    Only,    
    Exclude, 
};
 
[[nodiscard]] constexpr std::string_view to_string(GetMarketsMveFilter value) noexcept {
    switch (value) {
        case GetMarketsMveFilter::Only:
            return "only";
        case GetMarketsMveFilter::Exclude:
            return "exclude";
        case GetMarketsMveFilter::Unknown:
            break;
    }
    return "";
}
 
enum class GetMarketsStatus : std::uint8_t {
    Unknown,  
    Unopened, 
    Open,     
    Paused,   
    Closed,   
    Settled,  
};
 
[[nodiscard]] constexpr std::string_view to_string(GetMarketsStatus value) noexcept {
    switch (value) {
        case GetMarketsStatus::Unopened:
            return "unopened";
        case GetMarketsStatus::Open:
            return "open";
        case GetMarketsStatus::Paused:
            return "paused";
        case GetMarketsStatus::Closed:
            return "closed";
        case GetMarketsStatus::Settled:
            return "settled";
        case GetMarketsStatus::Unknown:
            break;
    }
    return "";
}
 
enum class GetMultivariateEventCollectionsStatus : std::uint8_t {
    Unknown,  
    Unopened, 
    Open,     
    Closed,   
};
 
[[nodiscard]] constexpr std::string_view
to_string(GetMultivariateEventCollectionsStatus value) noexcept {
    switch (value) {
        case GetMultivariateEventCollectionsStatus::Unopened:
            return "unopened";
        case GetMultivariateEventCollectionsStatus::Open:
            return "open";
        case GetMultivariateEventCollectionsStatus::Closed:
            return "closed";
        case GetMultivariateEventCollectionsStatus::Unknown:
            break;
    }
    return "";
}
 
enum class IncentiveProgramIncentiveType : std::uint8_t {
    Unknown,           
    Liquidity,         
    Volume,            
    MarginMakerVolume, 
    MarginTakerVolume, 
};
 
[[nodiscard]] constexpr std::string_view to_string(IncentiveProgramIncentiveType value) noexcept {
    switch (value) {
        case IncentiveProgramIncentiveType::Liquidity:
            return "liquidity";
        case IncentiveProgramIncentiveType::Volume:
            return "volume";
        case IncentiveProgramIncentiveType::MarginMakerVolume:
            return "margin_maker_volume";
        case IncentiveProgramIncentiveType::MarginTakerVolume:
            return "margin_taker_volume";
        case IncentiveProgramIncentiveType::Unknown:
            break;
    }
    return "";
}
 
enum class IntraExchangeInstanceTransferStatus : std::uint8_t {
    Unknown,  
    Pending,  
    Complete, 
};
 
[[nodiscard]] constexpr std::string_view
to_string(IntraExchangeInstanceTransferStatus value) noexcept {
    switch (value) {
        case IntraExchangeInstanceTransferStatus::Pending:
            return "pending";
        case IntraExchangeInstanceTransferStatus::Complete:
            return "complete";
        case IntraExchangeInstanceTransferStatus::Unknown:
            break;
    }
    return "";
}
 
enum class Kind : std::uint8_t {
    Unknown, 
    Bracket, 
};
 
[[nodiscard]] constexpr std::string_view to_string(Kind value) noexcept {
    switch (value) {
        case Kind::Bracket:
            return "bracket";
        case Kind::Unknown:
            break;
    }
    return "";
}
 
enum class MarketIndexStatus : std::uint8_t {
    Unknown, 
    Open,    
    Closed,  
    Stale,   
};
 
[[nodiscard]] constexpr std::string_view to_string(MarketIndexStatus value) noexcept {
    switch (value) {
        case MarketIndexStatus::Open:
            return "open";
        case MarketIndexStatus::Closed:
            return "closed";
        case MarketIndexStatus::Stale:
            return "stale";
        case MarketIndexStatus::Unknown:
            break;
    }
    return "";
}
 
enum class MarketResult : std::uint8_t {
    Unknown, 
    Yes,     
    No,      
    Scalar,  
    Unset,   
};
 
[[nodiscard]] constexpr std::string_view to_string(MarketResult value) noexcept {
    switch (value) {
        case MarketResult::Yes:
            return "yes";
        case MarketResult::No:
            return "no";
        case MarketResult::Scalar:
            return "scalar";
        case MarketResult::Unset:
            return "";
        case MarketResult::Unknown:
            break;
    }
    return "";
}
 
enum class MarketStatus : std::uint8_t {
    Unknown,     
    Initialized, 
    Inactive,    
    Active,      
    Closed,      
    Determined,  
    Disputed,    
    Amended,     
    Finalized,   
};
 
[[nodiscard]] constexpr std::string_view to_string(MarketStatus value) noexcept {
    switch (value) {
        case MarketStatus::Initialized:
            return "initialized";
        case MarketStatus::Inactive:
            return "inactive";
        case MarketStatus::Active:
            return "active";
        case MarketStatus::Closed:
            return "closed";
        case MarketStatus::Determined:
            return "determined";
        case MarketStatus::Disputed:
            return "disputed";
        case MarketStatus::Amended:
            return "amended";
        case MarketStatus::Finalized:
            return "finalized";
        case MarketStatus::Unknown:
            break;
    }
    return "";
}
 
enum class MarketType : std::uint8_t {
    Unknown, 
    Binary,  
    Scalar,  
};
 
[[nodiscard]] constexpr std::string_view to_string(MarketType value) noexcept {
    switch (value) {
        case MarketType::Binary:
            return "binary";
        case MarketType::Scalar:
            return "scalar";
        case MarketType::Unknown:
            break;
    }
    return "";
}
 
enum class OrderStatus : std::uint8_t {
    Unknown,  
    Resting,  
    Canceled, 
    Executed, 
};
 
[[nodiscard]] constexpr std::string_view to_string(OrderStatus value) noexcept {
    switch (value) {
        case OrderStatus::Resting:
            return "resting";
        case OrderStatus::Canceled:
            return "canceled";
        case OrderStatus::Executed:
            return "executed";
        case OrderStatus::Unknown:
            break;
    }
    return "";
}
 
enum class OrderType : std::uint8_t {
    Unknown, 
    Limit,   
    Market,  
};
 
[[nodiscard]] constexpr std::string_view to_string(OrderType value) noexcept {
    switch (value) {
        case OrderType::Limit:
            return "limit";
        case OrderType::Market:
            return "market";
        case OrderType::Unknown:
            break;
    }
    return "";
}
 
enum class OutcomeSide : std::uint8_t {
    Unknown, 
    Yes,     
    No,      
};
 
[[nodiscard]] constexpr std::string_view to_string(OutcomeSide value) noexcept {
    switch (value) {
        case OutcomeSide::Yes:
            return "yes";
        case OutcomeSide::No:
            return "no";
        case OutcomeSide::Unknown:
            break;
    }
    return "";
}
 
enum class QuoteStatus : std::uint8_t {
    Unknown,   
    Open,      
    Accepted,  
    Confirmed, 
    Executed,  
    Cancelled, 
};
 
[[nodiscard]] constexpr std::string_view to_string(QuoteStatus value) noexcept {
    switch (value) {
        case QuoteStatus::Open:
            return "open";
        case QuoteStatus::Accepted:
            return "accepted";
        case QuoteStatus::Confirmed:
            return "confirmed";
        case QuoteStatus::Executed:
            return "executed";
        case QuoteStatus::Cancelled:
            return "cancelled";
        case QuoteStatus::Unknown:
            break;
    }
    return "";
}
 
enum class RFQBatchQuoteStatus : std::uint8_t {
    Unknown,           
    Open,              
    Accepted,          
    Confirmed,         
    Executed,          
    PartiallyExecuted, 
    Cancelled,         
};
 
[[nodiscard]] constexpr std::string_view to_string(RFQBatchQuoteStatus value) noexcept {
    switch (value) {
        case RFQBatchQuoteStatus::Open:
            return "open";
        case RFQBatchQuoteStatus::Accepted:
            return "accepted";
        case RFQBatchQuoteStatus::Confirmed:
            return "confirmed";
        case RFQBatchQuoteStatus::Executed:
            return "executed";
        case RFQBatchQuoteStatus::PartiallyExecuted:
            return "partially_executed";
        case RFQBatchQuoteStatus::Cancelled:
            return "cancelled";
        case RFQBatchQuoteStatus::Unknown:
            break;
    }
    return "";
}
 
enum class RFQBatchStatus : std::uint8_t {
    Unknown,  
    Open,     
    Accepted, 
    Closed,   
};
 
[[nodiscard]] constexpr std::string_view to_string(RFQBatchStatus value) noexcept {
    switch (value) {
        case RFQBatchStatus::Open:
            return "open";
        case RFQBatchStatus::Accepted:
            return "accepted";
        case RFQBatchStatus::Closed:
            return "closed";
        case RFQBatchStatus::Unknown:
            break;
    }
    return "";
}
 
enum class RFQStatus : std::uint8_t {
    Unknown, 
    Open,    
    Closed,  
};
 
[[nodiscard]] constexpr std::string_view to_string(RFQStatus value) noexcept {
    switch (value) {
        case RFQStatus::Open:
            return "open";
        case RFQStatus::Closed:
            return "closed";
        case RFQStatus::Unknown:
            break;
    }
    return "";
}
 
enum class RestingMarginReservation : std::uint8_t {
    Unknown, 
    None,    
    Max,     
    Sum,     
};
 
[[nodiscard]] constexpr std::string_view to_string(RestingMarginReservation value) noexcept {
    switch (value) {
        case RestingMarginReservation::None:
            return "none";
        case RestingMarginReservation::Max:
            return "max";
        case RestingMarginReservation::Sum:
            return "sum";
        case RestingMarginReservation::Unknown:
            break;
    }
    return "";
}
 
enum class SelfTradePreventionType : std::uint8_t {
    Unknown,      
    TakerAtCross, 
    Maker,        
};
 
[[nodiscard]] constexpr std::string_view to_string(SelfTradePreventionType value) noexcept {
    switch (value) {
        case SelfTradePreventionType::TakerAtCross:
            return "taker_at_cross";
        case SelfTradePreventionType::Maker:
            return "maker";
        case SelfTradePreventionType::Unknown:
            break;
    }
    return "";
}
 
enum class SettlementBoundsType : std::uint8_t {
    Unknown, 
    Default, 
    Floor,   
};
 
[[nodiscard]] constexpr std::string_view to_string(SettlementBoundsType value) noexcept {
    switch (value) {
        case SettlementBoundsType::Default:
            return "default";
        case SettlementBoundsType::Floor:
            return "floor";
        case SettlementBoundsType::Unknown:
            break;
    }
    return "";
}
 
enum class SettlementMarketResult : std::uint8_t {
    Unknown, 
    Yes,     
    No,      
    Scalar,  
};
 
[[nodiscard]] constexpr std::string_view to_string(SettlementMarketResult value) noexcept {
    switch (value) {
        case SettlementMarketResult::Yes:
            return "yes";
        case SettlementMarketResult::No:
            return "no";
        case SettlementMarketResult::Scalar:
            return "scalar";
        case SettlementMarketResult::Unknown:
            break;
    }
    return "";
}
 
enum class SettlementStatus : std::uint8_t {
    Unknown,   
    Unsettled, 
    Settled,   
    All,       
};
 
[[nodiscard]] constexpr std::string_view to_string(SettlementStatus value) noexcept {
    switch (value) {
        case SettlementStatus::Unsettled:
            return "unsettled";
        case SettlementStatus::Settled:
            return "settled";
        case SettlementStatus::All:
            return "all";
        case SettlementStatus::Unknown:
            break;
    }
    return "";
}
 
enum class Side : std::uint8_t {
    Unknown, 
    Yes,     
    No,      
};
 
[[nodiscard]] constexpr std::string_view to_string(Side value) noexcept {
    switch (value) {
        case Side::Yes:
            return "yes";
        case Side::No:
            return "no";
        case Side::Unknown:
            break;
    }
    return "";
}
 
enum class StrikeType : std::uint8_t {
    Unknown,        
    Greater,        
    GreaterOrEqual, 
    Less,           
    LessOrEqual,    
    Between,        
    Functional,     
    Custom,         
    Structured,     
};
 
[[nodiscard]] constexpr std::string_view to_string(StrikeType value) noexcept {
    switch (value) {
        case StrikeType::Greater:
            return "greater";
        case StrikeType::GreaterOrEqual:
            return "greater_or_equal";
        case StrikeType::Less:
            return "less";
        case StrikeType::LessOrEqual:
            return "less_or_equal";
        case StrikeType::Between:
            return "between";
        case StrikeType::Functional:
            return "functional";
        case StrikeType::Custom:
            return "custom";
        case StrikeType::Structured:
            return "structured";
        case StrikeType::Unknown:
            break;
    }
    return "";
}
 
enum class TimeInForce : std::uint8_t {
    Unknown,           
    FillOrKill,        
    GoodTillCanceled,  
    ImmediateOrCancel, 
};
 
[[nodiscard]] constexpr std::string_view to_string(TimeInForce value) noexcept {
    switch (value) {
        case TimeInForce::FillOrKill:
            return "fill_or_kill";
        case TimeInForce::GoodTillCanceled:
            return "good_till_canceled";
        case TimeInForce::ImmediateOrCancel:
            return "immediate_or_cancel";
        case TimeInForce::Unknown:
            break;
    }
    return "";
}
 
enum class TriggeredLeg : std::uint8_t {
    Unknown,    
    StopLoss,   
    TakeProfit, 
};
 
[[nodiscard]] constexpr std::string_view to_string(TriggeredLeg value) noexcept {
    switch (value) {
        case TriggeredLeg::StopLoss:
            return "stop_loss";
        case TriggeredLeg::TakeProfit:
            return "take_profit";
        case TriggeredLeg::Unknown:
            break;
    }
    return "";
}
 
enum class Unit : std::uint8_t {
    Unknown, 
    Bps,     
    Cents,   
};
 
[[nodiscard]] constexpr std::string_view to_string(Unit value) noexcept {
    switch (value) {
        case Unit::Bps:
            return "bps";
        case Unit::Cents:
            return "cents";
        case Unit::Unknown:
            break;
    }
    return "";
}
 
enum class UserFilter : std::uint8_t {
    Unknown, 
    Self,    
};
 
[[nodiscard]] constexpr std::string_view to_string(UserFilter value) noexcept {
    switch (value) {
        case UserFilter::Self:
            return "self";
        case UserFilter::Unknown:
            break;
    }
    return "";
}
 
// ----- Models -----------------------------------------------------------
 
struct AcceptBlockTradeProposalRequest {
    std::optional<std::string> subtrader_id;
    std::optional<std::int64_t> subaccount;
};
 
struct AcceptQuoteRequest {
    Side accepted_side{};
};
 
struct RFQBatchAcceptLimit {
    std::string rfq_id;
    FixedPointDollars bid_dollars;
};
 
struct AcceptRFQBatchRequest {
    Side accepted_side{};
    std::vector<RFQBatchAcceptLimit> min_bids;
    std::optional<std::string> client_order_id;
};
 
struct Quote {
    std::string id;
    std::string rfq_id;
    std::string creator_id;
    std::string rfq_creator_id;
    std::string market_ticker;
    FixedPointCount contracts_fp;
    FixedPointDollars yes_bid_dollars;
    FixedPointDollars no_bid_dollars;
    std::string created_ts;
    std::string updated_ts;
    QuoteStatus status{};
    std::optional<Side> accepted_side;
    std::optional<std::string> accepted_ts;
    std::optional<std::string> confirmed_ts;
    std::optional<std::string> executed_ts;
    std::optional<std::string> cancelled_ts;
    std::optional<bool> rest_remainder;
    std::optional<bool> post_only;
    std::optional<std::string> cancellation_reason;
    std::optional<std::string> creator_user_id;
    std::optional<std::string> rfq_creator_user_id;
    std::optional<FixedPointDollars> rfq_target_cost_dollars;
    std::optional<bool> target_cost_excludes_fees;
    std::optional<std::string> rfq_creator_order_id;
    std::optional<std::string> creator_order_id;
    std::optional<std::int64_t> creator_subaccount;
    std::optional<std::int64_t> rfq_creator_subaccount;
    std::optional<FixedPointCount> yes_contracts_fp;
    std::optional<FixedPointCount> no_contracts_fp;
};
 
struct AcceptRFQBatchResponse {
    Side accepted_side{};
    std::vector<Quote> quotes;
};
 
struct AccountApiUsageLevelVolumeGoal {
    std::string level;
    FixedPointCount earn_volume_goal_fp;
    FixedPointCount keep_volume_goal_fp;
};
 
struct AccountApiUsageLevelVolumeProgress {
    std::int64_t computed_ts{};
    FixedPointCount trailing_30d_volume_fp;
    std::vector<AccountApiUsageLevelVolumeGoal> goals;
};
 
struct AmendOrderParams {
    std::optional<std::int64_t> subaccount;
};
 
struct AmendOrderRequest {
    std::optional<std::int64_t> subaccount;
    std::string ticker;
    Side side{};
    Action action{};
    std::optional<std::string> client_order_id;
    std::optional<std::string> updated_client_order_id;
    std::optional<std::int64_t> yes_price;
    std::optional<std::int64_t> no_price;
    std::optional<FixedPointDollars> yes_price_dollars;
    std::optional<FixedPointDollars> no_price_dollars;
    std::optional<std::int64_t> count;
    std::optional<FixedPointCount> count_fp;
    std::optional<ExchangeIndex> exchange_index;
};
 
struct Order {
    std::string order_id;
    std::string user_id;
    std::string client_order_id;
    std::string ticker;
    std::optional<Side> side;
    std::optional<Action> action;
    OutcomeSide outcome_side{};
    BookSide book_side{};
    OrderType type{};
    OrderStatus status{};
    FixedPointDollars yes_price_dollars;
    FixedPointDollars no_price_dollars;
    FixedPointCount fill_count_fp;
    FixedPointCount remaining_count_fp;
    FixedPointCount initial_count_fp;
    FixedPointDollars taker_fill_cost_dollars;
    FixedPointDollars maker_fill_cost_dollars;
    FixedPointDollars taker_fees_dollars;
    FixedPointDollars maker_fees_dollars;
    std::optional<std::string> expiration_time;
    std::optional<std::string> created_time;
    std::optional<std::string> last_update_time;
    std::optional<SelfTradePreventionType> self_trade_prevention_type;
    std::optional<std::string> order_group_id;
    std::optional<bool> cancel_order_on_pause;
    std::optional<std::int64_t> subaccount_number;
    std::optional<ExchangeIndex> exchange_index;
};
 
struct AmendOrderResponse {
    Order old_order;
    Order order;
};
 
struct AmendOrderV2Request {
    std::string ticker;
    BookSide side{};
    FixedPointDollars price;
    FixedPointCount count;
    std::optional<std::string> client_order_id;
    std::optional<std::string> updated_client_order_id;
    std::optional<std::int64_t> expiration_time;
    std::optional<ExchangeIndex> exchange_index;
};
 
struct AmendOrderV2Response {
    std::string order_id;
    std::optional<std::string> client_order_id;
    std::optional<FixedPointCount> remaining_count;
    std::optional<FixedPointCount> fill_count;
    std::optional<FixedPointDollars> average_fill_price;
    std::optional<FixedPointDollars> average_fee_paid;
    std::int64_t ts_ms{};
};
 
struct ApiKey {
    std::string api_key_id;
    std::string name;
    std::vector<ApiKeyScope> scopes;
    std::optional<std::int64_t> subaccount;
    std::optional<std::string> fcm_subtrader_id;
};
 
struct ApiUsageLevelGrant {
    ExchangeInstance exchange_instance{};
    std::string level;
    std::optional<std::int64_t> expires_ts;
    std::string source;
};
 
struct ApplySubaccountTransferRequest {
    std::string client_transfer_id;
    std::int64_t from_subaccount{};
    std::int64_t to_subaccount{};
    std::int64_t amount_cents{};
    std::optional<ExchangeIndex> exchange_index;
};
 
struct AssociatedEvent {
    std::string ticker;
    bool is_yes_only{};
    std::optional<std::int64_t> size_max;
    std::optional<std::int64_t> size_min;
    std::vector<std::string> active_quoters;
};
 
struct EventContractExitSlippage {
    Unit unit{};
    std::int64_t value{};
};
 
struct AttachedEventContractExitTrigger {
    std::optional<EventContractExitSlippage> slippage;
    std::optional<FixedPointDollars> stop_loss_price;
    std::optional<FixedPointDollars> take_profit_price;
};
 
struct ErrorResponse {
    std::optional<std::string> code;
    std::optional<std::string> message;
    std::optional<std::string> details;
};
 
struct BatchCancelOrdersIndividualResponse {
    std::string order_id;
    std::optional<Order> order;
    FixedPointCount reduced_by_fp;
    std::optional<ErrorResponse> error;
};
 
struct BatchCancelOrdersRequestOrder {
    std::string order_id;
    std::optional<std::int64_t> subaccount;
    std::optional<ExchangeIndex> exchange_index;
    std::optional<std::string> market_ticker;
};
 
struct BatchCancelOrdersRequest {
    std::optional<std::vector<std::string>> ids;
    std::optional<std::vector<BatchCancelOrdersRequestOrder>> orders;
};
 
struct BatchCancelOrdersResponse {
    std::vector<BatchCancelOrdersIndividualResponse> orders;
};
 
struct BatchCancelOrdersV2RequestOrdersItem {
    std::string order_id;
    std::optional<std::int64_t> subaccount;
    std::optional<ExchangeIndex> exchange_index;
    std::optional<std::string> market_ticker;
};
 
struct BatchCancelOrdersV2Request {
    std::vector<BatchCancelOrdersV2RequestOrdersItem> orders;
};
 
struct BatchCancelOrdersV2ResponseOrdersItem {
    std::string order_id;
    std::optional<std::string> client_order_id;
    FixedPointCount reduced_by;
    std::optional<std::int64_t> ts_ms;
    std::optional<ErrorResponse> error;
};
 
struct BatchCancelOrdersV2Response {
    std::vector<BatchCancelOrdersV2ResponseOrdersItem> orders;
};
 
struct BatchCreateOrdersIndividualResponse {
    std::optional<std::string> client_order_id;
    std::optional<Order> order;
    std::optional<ErrorResponse> error;
};
 
struct CreateOrderRequest {
    std::string ticker;
    std::optional<std::string> client_order_id;
    Side side{};
    Action action{};
    std::optional<std::int64_t> count;
    std::optional<FixedPointCount> count_fp;
    std::optional<std::int64_t> yes_price;
    std::optional<std::int64_t> no_price;
    std::optional<FixedPointDollars> yes_price_dollars;
    std::optional<FixedPointDollars> no_price_dollars;
    std::optional<std::int64_t> expiration_ts;
    std::optional<TimeInForce> time_in_force;
    std::optional<std::int64_t> buy_max_cost;
    std::optional<bool> post_only;
    std::optional<bool> reduce_only;
    std::optional<std::int64_t> sell_position_floor;
    std::optional<SelfTradePreventionType> self_trade_prevention_type;
    std::optional<std::string> order_group_id;
    std::optional<bool> cancel_order_on_pause;
    std::optional<std::int64_t> subaccount;
    std::optional<ExchangeIndex> exchange_index;
};
 
struct BatchCreateOrdersRequest {
    std::vector<CreateOrderRequest> orders;
};
 
struct BatchCreateOrdersResponse {
    std::vector<BatchCreateOrdersIndividualResponse> orders;
};
 
struct CreateOrderV2Request {
    std::string ticker;
    std::optional<std::string> client_order_id;
    BookSide side{};
    FixedPointCount count;
    FixedPointDollars price;
    std::optional<std::int64_t> expiration_time;
    TimeInForce time_in_force{};
    std::optional<bool> post_only;
    SelfTradePreventionType self_trade_prevention_type{};
    std::optional<bool> cancel_order_on_pause;
    std::optional<bool> reduce_only;
    std::optional<std::int64_t> subaccount;
    std::optional<std::string> order_group_id;
    std::optional<ExchangeIndex> exchange_index;
};
 
struct BatchCreateOrdersV2Request {
    std::vector<CreateOrderV2Request> orders;
};
 
struct BatchCreateOrdersV2ResponseOrdersItem {
    std::optional<std::string> order_id;
    std::optional<std::string> client_order_id;
    std::optional<FixedPointCount> fill_count;
    std::optional<FixedPointCount> remaining_count;
    std::optional<FixedPointDollars> average_fill_price;
    std::optional<FixedPointDollars> average_fee_paid;
    std::optional<std::int64_t> ts_ms;
    std::optional<ErrorResponse> error;
};
 
struct BatchCreateOrdersV2Response {
    std::vector<BatchCreateOrdersV2ResponseOrdersItem> orders;
};
 
struct BatchGetMarketCandlesticksParams {
    std::string market_tickers;
    std::int64_t start_ts{};
    std::int64_t end_ts{};
    std::int64_t period_interval{};
    std::optional<bool> include_latest_before_start;
};
 
struct BidAskDistribution {
    FixedPointDollars open_dollars;
    FixedPointDollars low_dollars;
    FixedPointDollars high_dollars;
    FixedPointDollars close_dollars;
};
 
struct PriceDistribution {
    std::optional<FixedPointDollars> open_dollars;
    std::optional<FixedPointDollars> low_dollars;
    std::optional<FixedPointDollars> high_dollars;
    std::optional<FixedPointDollars> close_dollars;
    std::optional<FixedPointDollars> mean_dollars;
    std::optional<FixedPointDollars> previous_dollars;
    std::optional<FixedPointDollars> min_dollars;
    std::optional<FixedPointDollars> max_dollars;
};
 
struct MarketCandlestick {
    std::int64_t end_period_ts{};
    BidAskDistribution yes_bid;
    BidAskDistribution yes_ask;
    PriceDistribution price;
    FixedPointCount volume_fp;
    FixedPointCount open_interest_fp;
};
 
struct MarketCandlesticksResponse {
    std::string market_ticker;
    std::vector<MarketCandlestick> candlesticks;
};
 
struct BatchGetMarketCandlesticksResponse {
    std::vector<MarketCandlesticksResponse> markets;
};
 
struct BidAskDistributionHistorical {
    FixedPointDollars open;
    FixedPointDollars low;
    FixedPointDollars high;
    FixedPointDollars close;
};
 
struct BlockTradeProposal {
    std::string id;
    std::string proposer_user_id;
    std::string buyer_user_id;
    std::optional<std::string> buyer_subtrader_id;
    std::string seller_user_id;
    std::optional<std::string> seller_subtrader_id;
    std::string market_ticker;
    std::int64_t price_centi_cents{};
    std::int64_t centicount{};
    Side maker_side{};
    std::string expiration_ts;
    std::string status;
    std::string created_ts;
    std::string updated_ts;
    bool buyer_accepted{};
    bool seller_accepted{};
    std::optional<std::string> buyer_accepted_ts;
    std::optional<std::string> seller_accepted_ts;
    std::optional<std::string> executed_ts;
    std::optional<std::string> buyer_order_id;
    std::optional<std::string> seller_order_id;
};
 
struct BucketLimit {
    std::int64_t refill_rate{};
    std::int64_t bucket_capacity{};
};
 
struct CancelAllOrdersParams {
    std::optional<std::int64_t> subaccount;
};
 
struct CancelOrderParams {
    std::optional<std::int64_t> subaccount;
    std::optional<ExchangeIndex> exchange_index;
    std::optional<std::string> market_ticker;
};
 
struct CancelOrderV2Response {
    std::string order_id;
    std::optional<std::string> client_order_id;
    FixedPointCount reduced_by;
    std::int64_t ts_ms{};
};
 
struct CreateApiKeyRequest {
    std::string name;
    std::string public_key;
    std::optional<std::vector<ApiKeyScope>> scopes;
    std::optional<std::int64_t> subaccount;
    std::optional<std::string> fcm_subtrader_id;
};
 
struct CreateApiKeyResponse {
    std::string api_key_id;
    std::optional<std::string> warning;
};
 
struct CreateFCMPositionTransferRequest {
    std::string source_subtrader_id;
    std::string target_subtrader_id;
    std::string market_ticker;
    std::int64_t position_centicount{};
    std::int64_t price_centicents{};
};
 
struct CreateFCMPositionTransferResponse {
    std::string position_transfer_id;
};
 
struct CreateFCMSubtraderRequest {
    std::string subtrader_suffix;
};
 
struct CreateFCMSubtraderResponse {
    std::string subtrader_id;
};
 
struct TickerPair {
    std::string market_ticker;
    std::string event_ticker;
    Side side{};
};
 
struct CreateMarketInMultivariateEventCollectionRequest {
    std::vector<TickerPair> selected_markets;
    std::optional<bool> with_market_payload;
};
 
struct MveSelectedLeg {
    std::optional<std::string> event_ticker;
    std::optional<std::string> market_ticker;
    std::optional<std::string> side;
    std::optional<FixedPointDollars> yes_settlement_value_dollars;
};
 
struct PriceRange {
    std::string start;
    std::string end;
    std::string step;
};
 
struct Market {
    std::string ticker;
    std::string event_ticker;
    MarketType market_type{};
    std::optional<std::string> title;
    std::optional<std::string> subtitle;
    std::string yes_sub_title;
    std::string no_sub_title;
    std::string created_time;
    std::string updated_time;
    std::string open_time;
    std::string close_time;
    std::optional<std::string> expected_expiration_time;
    std::optional<std::string> expiration_time;
    std::string latest_expiration_time;
    std::int64_t settlement_timer_seconds{};
    MarketStatus status{};
    FixedPointDollars yes_bid_dollars;
    FixedPointCount yes_bid_size_fp;
    FixedPointDollars yes_ask_dollars;
    FixedPointCount yes_ask_size_fp;
    FixedPointDollars no_bid_dollars;
    FixedPointDollars no_ask_dollars;
    FixedPointDollars last_price_dollars;
    FixedPointCount volume_fp;
    FixedPointCount volume_24h_fp;
    MarketResult result{};
    bool can_close_early{};
    FixedPointCount open_interest_fp;
    FixedPointDollars notional_value_dollars;
    FixedPointDollars previous_yes_bid_dollars;
    FixedPointDollars previous_yes_ask_dollars;
    FixedPointDollars previous_price_dollars;
    std::optional<FixedPointDollars> settlement_value_dollars;
    std::optional<std::string> settlement_ts;
    SettlementBoundsType settlement_bounds_type{};
    std::optional<FixedPointDollars> settlement_floor_dollars;
    std::string expiration_value;
    std::optional<std::string> occurrence_datetime;
    std::optional<std::string> fee_waiver_expiration_time;
    std::optional<std::string> early_close_condition;
    std::optional<StrikeType> strike_type;
    std::optional<double> floor_strike;
    std::optional<double> cap_strike;
    std::optional<std::string> functional_strike;
    std::optional<RawJson> custom_strike;
    std::string rules_primary;
    std::string rules_secondary;
    std::optional<std::string> mve_collection_ticker;
    std::optional<std::vector<MveSelectedLeg>> mve_selected_legs;
    std::optional<std::string> primary_participant_key;
    std::string price_level_structure;
    std::vector<PriceRange> price_ranges;
    std::optional<bool> is_provisional;
    std::optional<ExchangeIndex> exchange_index;
};
 
struct CreateMarketInMultivariateEventCollectionResponse {
    std::string event_ticker;
    std::string market_ticker;
    std::optional<Market> market;
};
 
struct CreateOrderGroupRequest {
    std::optional<std::int64_t> subaccount;
    std::optional<std::int64_t> contracts_limit;
    std::optional<FixedPointCount> contracts_limit_fp;
    std::optional<ExchangeIndex> exchange_index;
};
 
struct CreateOrderGroupResponse {
    std::string order_group_id;
    std::int64_t subaccount{};
    std::optional<ExchangeIndex> exchange_index;
};
 
struct CreateOrderResponse {
    Order order;
};
 
struct CreateOrderV2Response {
    std::string order_id;
    std::optional<std::string> client_order_id;
    FixedPointCount fill_count;
    FixedPointCount remaining_count;
    std::optional<FixedPointDollars> average_fill_price;
    std::optional<FixedPointDollars> average_fee_paid;
    std::int64_t ts_ms{};
};
 
struct CreateOrderWithExitTriggerRequest {
    std::string ticker;
    std::optional<std::string> client_order_id;
    BookSide side{};
    FixedPointCount count;
    FixedPointDollars price;
    std::optional<std::int64_t> expiration_time;
    TimeInForce time_in_force{};
    std::optional<bool> post_only;
    SelfTradePreventionType self_trade_prevention_type{};
    std::optional<bool> cancel_order_on_pause;
    std::optional<bool> reduce_only;
    std::optional<std::int64_t> subaccount;
    std::optional<std::string> order_group_id;
    std::optional<ExchangeIndex> exchange_index;
    AttachedEventContractExitTrigger exit_trigger;
};
 
struct CreateQuoteRequest {
    std::string rfq_id;
    FixedPointDollars yes_bid;
    FixedPointDollars no_bid;
    bool rest_remainder{};
    std::optional<bool> post_only;
    std::optional<std::int64_t> subaccount;
};
 
struct CreateQuoteResponse {
    std::string id;
};
 
struct CreateRFQBatchChild {
    std::optional<std::string> market_ticker;
    std::optional<std::vector<TickerPair>> selected_markets;
    std::optional<FixedPointCount> contracts_fp;
    std::optional<FixedPointDollars> target_cost_dollars;
};
 
struct RFQBatchQuoteEntry {
    std::string rfq_id;
    FixedPointDollars yes_bid;
    FixedPointDollars no_bid;
};
 
struct CreateRFQBatchQuoteRequest {
    std::vector<RFQBatchQuoteEntry> quotes;
    bool rest_remainder{};
    std::optional<bool> post_only;
    std::optional<std::int64_t> subaccount;
};
 
struct CreateRFQBatchQuoteResponse {
    std::string id;
};
 
struct CreateRFQBatchRequest {
    std::vector<CreateRFQBatchChild> children;
    std::optional<std::string> mve_collection_ticker;
    std::optional<FixedPointCount> contracts_fp;
    std::optional<FixedPointDollars> target_cost_dollars;
    std::optional<bool> target_cost_excludes_fees;
    std::optional<bool> rest_remainder;
    std::optional<bool> replace_existing;
    std::optional<bool> obscure_creator_id;
    std::optional<std::string> client_batch_id;
    std::optional<std::string> subtrader_id;
    std::optional<std::int64_t> subaccount;
};
 
struct RFQ {
    std::string id;
    std::string creator_id;
    std::string market_ticker;
    FixedPointCount contracts_fp;
    std::optional<FixedPointDollars> target_cost_dollars;
    std::optional<bool> target_cost_excludes_fees;
    RFQStatus status{};
    std::string created_ts;
    std::optional<std::string> mve_collection_ticker;
    std::optional<std::vector<MveSelectedLeg>> mve_selected_legs;
    std::optional<bool> rest_remainder;
    std::optional<std::string> cancellation_reason;
    std::optional<std::string> creator_user_id;
    std::optional<std::int64_t> creator_subaccount;
    std::optional<std::string> cancelled_ts;
    std::optional<std::string> updated_ts;
    std::optional<std::string> rfq_batch_id;
};
 
struct RFQBatch {
    std::string id;
    std::string creator_id;
    RFQBatchStatus status{};
    std::string created_ts;
    std::optional<std::string> accepted_ts;
    std::optional<std::string> closed_ts;
    std::vector<RFQ> rfqs;
    std::optional<std::string> updated_ts;
    std::optional<std::string> close_reason;
    std::optional<std::string> client_batch_id;
    std::optional<std::string> creator_user_id;
    std::optional<std::int64_t> creator_subaccount;
};
 
struct CreateRFQBatchResponse {
    RFQBatch rfq_batch;
};
 
struct CreateRFQRequest {
    std::string market_ticker;
    std::optional<std::int64_t> contracts;
    std::optional<FixedPointCount> contracts_fp;
    std::optional<std::int64_t> target_cost_centi_cents;
    std::optional<FixedPointDollars> target_cost_dollars;
    std::optional<bool> target_cost_excludes_fees;
    std::optional<bool> obscure_creator_id;
    bool rest_remainder{};
    std::optional<bool> replace_existing;
    std::optional<std::string> subtrader_id;
    std::optional<std::int64_t> subaccount;
};
 
struct CreateRFQResponse {
    std::string id;
};
 
struct CreateSubaccountRequest {
    std::optional<ExchangeIndex> exchange_index;
};
 
struct CreateSubaccountResponse {
    std::int64_t subaccount_number{};
};
 
struct CreditHistory {
    std::string credit_id;
    std::string type;
    CreditHistoryStatus status{};
    FixedPointDollars amount_dollars;
    std::string reason;
    std::string created_time;
};
 
struct DailySchedule {
    std::string open_time;
    std::string close_time;
};
 
struct DecreaseOrderParams {
    std::optional<std::int64_t> subaccount;
};
 
struct DecreaseOrderV2Request {
    std::optional<FixedPointCount> reduce_by;
    std::optional<FixedPointCount> reduce_to;
    std::optional<ExchangeIndex> exchange_index;
    std::optional<std::string> market_ticker;
};
 
struct DecreaseOrderV2Response {
    std::string order_id;
    std::optional<std::string> client_order_id;
    FixedPointCount remaining_count;
    std::int64_t ts_ms{};
};
 
struct DeleteEventContractExitTriggerParams {
    std::optional<std::int64_t> subaccount;
    std::optional<Kind> kind;
};
 
struct DeleteFcmEventContractDailyCapParams {
    std::string subtrader_id;
};
 
struct DeleteOrderGroupParams {
    std::optional<std::int64_t> subaccount;
    std::optional<ExchangeIndex> exchange_index;
};
 
struct Deposit {
    std::string id;
    DepositStatus status{};
    DepositType type{};
    std::int64_t amount_cents{};
    std::int64_t fee_cents{};
    std::int64_t created_ts{};
    std::optional<std::int64_t> finalized_ts;
};
 
struct EndpointTokenCost {
    std::string method;
    std::string path;
    std::int64_t cost{};
};
 
struct EventContractExitTrigger {
    std::optional<EventContractExitSlippage> slippage;
    std::string id;
    std::string ticker;
    Side side{};
    std::int64_t subaccount_number{};
    Kind kind{};
    std::optional<FixedPointDollars> stop_loss_price;
    std::optional<FixedPointDollars> take_profit_price;
    EventContractExitTriggerStatus status{};
    std::optional<std::string> status_reason;
    std::optional<std::string> triggered_order_id;
    std::optional<TriggeredLeg> triggered_leg;
    std::string created_time;
    std::string updated_time;
};
 
struct SettlementSource {
    std::optional<std::string> name;
    std::optional<std::string> url;
};
 
struct EventData {
    std::string event_ticker;
    std::string series_ticker;
    std::string sub_title;
    std::string title;
    std::string collateral_return_type;
    bool mutually_exclusive{};
    std::optional<std::string> category;
    std::optional<std::string> strike_date;
    std::optional<std::string> strike_period;
    std::optional<std::vector<Market>> markets;
    std::optional<RawJson> product_metadata;
    std::optional<std::vector<SettlementSource>> settlement_sources;
    std::optional<std::string> last_updated_ts;
    std::optional<std::string> fee_type_override;
    std::optional<double> fee_multiplier_override;
    std::optional<ExchangeIndex> exchange_index;
};
 
struct EventFeeChange {
    std::string id;
    std::string event_ticker;
    std::string series_ticker;
    std::optional<FeeType> fee_type_override;
    std::optional<double> fee_multiplier_override;
    std::string scheduled_ts;
};
 
struct EventLiveData {
    std::string type;
    RawJson details;
    std::optional<bool> is_historical;
    std::optional<std::string> default_range;
    std::optional<std::vector<std::string>> range_options;
};
 
struct EventPosition {
    std::string event_ticker;
    FixedPointDollars total_cost_dollars;
    FixedPointCount total_cost_shares_fp;
    FixedPointDollars event_exposure_dollars;
    FixedPointDollars realized_pnl_dollars;
    FixedPointDollars fees_paid_dollars;
};
 
struct ExchangeIndexStatus {
    ExchangeIndex exchange_index{};
    std::string description;
    bool exchange_active{};
    bool trading_active{};
    bool intra_exchange_transfers_active{};
};
 
struct ExchangeStatus {
    bool exchange_active{};
    bool trading_active{};
    std::optional<bool> intra_exchange_transfers_active;
    std::optional<std::string> exchange_estimated_resume_time;
    std::optional<std::vector<ExchangeIndexStatus>> exchange_index_statuses;
};
 
struct FCMSubtrader {
    std::string subtrader_id;
    std::vector<std::int64_t> exchange_indices;
    bool trading_blocked{};
    bool fcm_trading_blocked{};
    bool propagation_pending{};
};
 
struct FcmFill {
    std::string fill_id;
    ExchangeIndex exchange_index{};
    std::string ticker;
    OutcomeSide taker_outcome_side{};
    FixedPointCount count_fp;
    FixedPointDollars yes_price_dollars;
    std::optional<std::string> created_time;
    std::optional<std::string> maker_order_id;
    std::optional<std::string> maker_subtrader_id;
    std::optional<FixedPointDollars> maker_fee_cost;
    std::optional<std::string> taker_order_id;
    std::optional<std::string> taker_subtrader_id;
    std::optional<FixedPointDollars> taker_fee_cost;
};
 
struct Fill {
    std::string fill_id;
    ExchangeIndex exchange_index{};
    std::string trade_id;
    std::string order_id;
    std::string ticker;
    std::string market_ticker;
    std::optional<Side> side;
    std::optional<Action> action;
    OutcomeSide outcome_side{};
    BookSide book_side{};
    FixedPointCount count_fp;
    FixedPointDollars yes_price_dollars;
    FixedPointDollars no_price_dollars;
    bool is_taker{};
    std::optional<std::string> created_time;
    FixedPointDollars fee_cost;
    std::optional<std::int64_t> subaccount_number;
    std::optional<std::int64_t> ts;
};
 
struct PercentilePoint {
    std::int64_t percentile{};
    double raw_numerical_forecast{};
    double numerical_forecast{};
    std::string formatted_forecast;
};
 
struct ForecastPercentilesPoint {
    std::string event_ticker;
    std::int64_t end_period_ts{};
    std::int64_t period_interval{};
    std::vector<PercentilePoint> percentile_points;
};
 
struct GenerateApiKeyRequest {
    std::string name;
    std::optional<ApiKeyType> key_type;
    std::optional<std::vector<ApiKeyScope>> scopes;
    std::optional<std::int64_t> subaccount;
    std::optional<std::string> fcm_subtrader_id;
};
 
struct GenerateApiKeyResponse {
    std::string api_key_id;
    std::optional<ApiKeyType> key_type;
    std::string private_key;
    std::optional<std::string> warning;
};
 
struct GetAccountApiLimitsResponse {
    std::string usage_tier;
    BucketLimit read;
    BucketLimit write;
    std::vector<ApiUsageLevelGrant> grants;
};
 
struct GetAccountApiUsageLevelVolumeProgressResponse {
    std::vector<AccountApiUsageLevelVolumeProgress> volume_progress;
};
 
struct GetAccountEndpointCostsResponse {
    std::int64_t default_cost{};
    std::vector<EndpointTokenCost> endpoint_costs;
};
 
struct GetApiKeysParams {
    std::optional<std::string> fcm_subtrader_id;
};
 
struct GetApiKeysResponse {
    std::vector<ApiKey> api_keys;
    std::optional<std::int64_t> api_key_region_expiration_ts;
};
 
struct GetBalanceParams {
    std::optional<std::int64_t> subaccount;
    std::optional<ExchangeIndex> exchange_index;
};
 
struct IndexedBalance {
    ExchangeIndex exchange_index{};
    FixedPointDollars balance;
};
 
struct GetBalanceResponse {
    std::int64_t balance{};
    FixedPointDollars balance_dollars;
    std::int64_t portfolio_value{};
    std::int64_t updated_ts{};
    std::optional<std::vector<IndexedBalance>> balance_breakdown;
};
 
struct GetBlockTradeProposalsParams {
    std::optional<std::string> cursor;
    std::optional<std::string> market_ticker;
    std::optional<std::int64_t> limit;
    std::optional<std::string> status;
};
 
struct GetBlockTradeProposalsResponse {
    std::vector<BlockTradeProposal> block_trade_proposals;
    std::optional<std::string> cursor;
};
 
struct GetCommunicationsIDResponse {
    std::string communications_id;
};
 
struct GetCreditHistoryParams {
    std::optional<std::int64_t> limit;
    std::optional<std::string> cursor;
    std::optional<std::int64_t> min_ts;
    std::optional<std::int64_t> max_ts;
};
 
struct GetCreditHistoryResponse {
    std::vector<CreditHistory> credits;
    std::string cursor;
};
 
struct GetDepositsParams {
    std::optional<std::int64_t> limit;
    std::optional<std::string> cursor;
};
 
struct GetDepositsResponse {
    std::vector<Deposit> deposits;
    std::optional<std::string> cursor;
};
 
struct GetEventCandlesticksResponse {
    std::vector<std::string> market_tickers;
    std::vector<std::vector<MarketCandlestick>> market_candlesticks;
    std::int64_t adjusted_end_ts{};
};
 
struct GetEventContractExitTriggersParams {
    std::optional<std::int64_t> subaccount;
    std::optional<Kind> kind;
};
 
struct GetEventContractExitTriggersResponse {
    std::optional<EventContractExitTrigger> exit_trigger;
    std::vector<EventContractExitTrigger> exit_triggers;
};
 
struct GetEventFeeChangesParams {
    std::optional<std::string> event_ticker;
    std::optional<std::int64_t> limit;
    std::optional<std::string> cursor;
};
 
struct GetEventFeeChangesResponse {
    std::vector<EventFeeChange> event_fee_changes;
    std::string cursor;
};
 
struct GetEventForecastPercentilesHistoryParams {
    std::vector<std::int64_t> percentiles;
    std::int64_t start_ts{};
    std::int64_t end_ts{};
    std::int64_t period_interval{};
};
 
struct GetEventForecastPercentilesHistoryResponse {
    std::vector<ForecastPercentilesPoint> forecast_history;
};
 
struct GetEventLiveDataParams {
    std::optional<std::string> range;
};
 
struct GetEventLiveDataResponse {
    EventLiveData live_data;
};
 
struct MarketMetadata {
    std::string market_ticker;
    std::string image_url;
    std::string color_code;
};
 
struct GetEventMetadataResponse {
    std::string image_url;
    std::optional<std::string> featured_image_url;
    std::vector<MarketMetadata> market_details;
    std::vector<SettlementSource> settlement_sources;
    std::optional<std::string> competition;
    std::optional<std::string> competition_scope;
};
 
struct GetEventParams {
    std::optional<bool> exclude_markets;
    std::optional<bool> with_nested_markets;
};
 
struct GetEventResponse {
    EventData event;
    std::vector<Market> markets;
};
 
struct GetEventsParams {
    std::optional<std::int64_t> limit;
    std::optional<std::string> cursor;
    std::optional<bool> with_nested_markets;
    std::optional<bool> with_milestones;
    std::optional<GetEventsStatus> status;
    std::optional<std::string> series_ticker;
    std::optional<std::string> tickers;
    std::optional<std::int64_t> min_close_ts;
    std::optional<std::int64_t> min_updated_ts;
};
 
struct Milestone {
    std::string id;
    std::string category;
    std::string type;
    std::string start_date;
    std::optional<std::string> end_date;
    std::vector<std::string> related_event_tickers;
    std::string title;
    std::string notification_message;
    std::optional<std::string> source_id;
    std::optional<std::map<std::string, std::string>> source_ids;
    RawJson details;
    std::vector<std::string> primary_event_tickers;
    std::string last_updated_ts;
};
 
struct GetEventsResponse {
    std::vector<EventData> events;
    std::optional<std::vector<Milestone>> milestones;
    std::string cursor;
};
 
struct WeeklySchedule {
    std::string start_time;
    std::string end_time;
    std::vector<DailySchedule> monday;
    std::vector<DailySchedule> tuesday;
    std::vector<DailySchedule> wednesday;
    std::vector<DailySchedule> thursday;
    std::vector<DailySchedule> friday;
    std::vector<DailySchedule> saturday;
    std::vector<DailySchedule> sunday;
};
 
struct MaintenanceWindow {
    std::string start_datetime;
    std::string end_datetime;
};
 
struct Schedule {
    std::vector<WeeklySchedule> standard_hours;
    std::vector<MaintenanceWindow> maintenance_windows;
};
 
struct GetExchangeScheduleResponse {
    Schedule schedule;
};
 
struct GetFCMEventContractDailyCapResponse {
    std::string subtrader_id;
    FixedPointDollars limit;
    FixedPointDollars executed_utilization;
    FixedPointDollars resting_order_utilization;
    FixedPointDollars pending_order_utilization;
    std::string cap_date;
};
 
struct GetFCMSubtraderBlockedCategoriesResponse {
    std::vector<std::string> categories;
};
 
struct GetFcmEventContractDailyCapParams {
    std::optional<std::string> subtrader_id;
};
 
struct GetFcmFillsParams {
    std::optional<std::int64_t> min_ts;
    std::optional<std::int64_t> max_ts;
    std::optional<std::string> cursor;
};
 
struct GetFcmFillsResponse {
    std::vector<FcmFill> fills;
    std::string cursor;
};
 
struct GetFcmOrdersParams {
    std::optional<std::string> subtrader_id;
    std::optional<std::string> client_order_ids;
    std::optional<std::string> cursor;
    std::optional<std::string> event_ticker;
    std::optional<std::string> ticker;
    std::optional<std::int64_t> min_ts;
    std::optional<std::int64_t> max_ts;
    std::optional<OrderStatus> status;
    std::optional<std::int64_t> limit;
};
 
struct GetFcmPositionsParams {
    std::optional<std::string> subtrader_id;
    std::optional<std::string> ticker;
    std::optional<std::string> event_ticker;
    std::optional<std::string> count_filter;
    std::optional<SettlementStatus> settlement_status;
    std::optional<std::int64_t> limit;
    std::optional<std::string> cursor;
};
 
struct GetFcmSubtraderBlockedCategoriesParams {
    std::string subtrader_id;
};
 
struct GetFillsHistoricalParams {
    std::optional<std::string> ticker;
    std::optional<std::int64_t> min_ts;
    std::optional<std::int64_t> max_ts;
    std::optional<std::int64_t> limit;
    std::optional<std::string> cursor;
    std::optional<std::int64_t> subaccount;
};
 
struct GetFillsParams {
    std::optional<std::string> ticker;
    std::optional<std::string> order_id;
    std::optional<std::int64_t> min_ts;
    std::optional<std::int64_t> max_ts;
    std::optional<std::int64_t> limit;
    std::optional<std::string> cursor;
    std::optional<std::int64_t> subaccount;
    std::optional<std::int64_t> exchange_index;
};
 
struct GetFillsResponse {
    std::vector<Fill> fills;
    std::string cursor;
};
 
struct ScopeList {
    std::vector<std::string> scopes;
};
 
struct SportFilterDetails {
    std::vector<std::string> scopes;
    std::map<std::string, ScopeList> competitions;
};
 
struct GetFiltersBySportsResponse {
    std::map<std::string, SportFilterDetails> filters_by_sports;
    std::vector<std::string> sport_ordering;
};
 
struct PlayByPlayPeriodsItem {
    std::optional<std::vector<RawJson>> events;
};
 
struct PlayByPlay {
    std::optional<std::vector<PlayByPlayPeriodsItem>> periods;
};
 
struct GetGameStatsResponse {
    std::optional<PlayByPlay> pbp;
};
 
struct GetHistoricalCutoffResponse {
    std::string market_settled_ts;
    std::string trades_created_ts;
    std::string orders_updated_ts;
    std::optional<std::string> market_positions_last_updated_ts;
};
 
struct GetHistoricalMarketsParams {
    std::optional<std::int64_t> limit;
    std::optional<std::string> cursor;
    std::optional<std::string> tickers;
    std::optional<std::string> event_ticker;
    std::optional<std::string> series_ticker;
    std::optional<GetHistoricalMarketsMveFilter> mve_filter;
};
 
struct GetHistoricalOrdersParams {
    std::optional<std::string> ticker;
    std::optional<std::int64_t> min_ts;
    std::optional<std::int64_t> max_ts;
    std::optional<std::int64_t> limit;
    std::optional<std::string> cursor;
    std::optional<std::int64_t> subaccount;
};
 
struct GetHistoricalPositionsParams {
    std::optional<std::string> ticker;
    std::optional<std::string> event_ticker;
    std::optional<std::int64_t> subaccount;
    std::optional<std::int64_t> limit;
    std::optional<std::string> cursor;
};
 
struct GetIncentiveProgramsParams {
    std::optional<GetIncentiveProgramsStatus> status;
    std::optional<GetIncentiveProgramsType> type;
    std::optional<std::string> incentive_description;
    std::optional<std::int64_t> limit;
    std::optional<std::string> cursor;
};
 
struct IncentiveProgram {
    std::string id;
    std::string market_id;
    std::string market_ticker;
    IncentiveProgramIncentiveType incentive_type{};
    std::string incentive_description;
    std::string start_date;
    std::string end_date;
    std::int64_t period_reward{};
    bool paid_out{};
    std::optional<std::int64_t> discount_factor_bps;
    std::optional<FixedPointCount> target_size_fp;
    std::optional<std::int64_t> max_reward_per_account;
};
 
struct GetIncentiveProgramsResponse {
    std::vector<IncentiveProgram> incentive_programs;
    std::optional<std::string> next_cursor;
};
 
struct IntraExchangeInstanceTransfer {
    std::string transfer_id;
    std::optional<std::string> client_transfer_id;
    ExchangeInstance source{};
    ExchangeInstance destination{};
    std::int64_t source_exchange_shard{};
    std::int64_t destination_exchange_shard{};
    FixedPointDollars amount;
    IntraExchangeInstanceTransferStatus status{};
    std::int64_t created_ts{};
};
 
struct GetIntraExchangeInstanceTransferResponse {
    IntraExchangeInstanceTransfer transfer;
};
 
struct GetIntraExchangeInstanceTransfersParams {
    std::optional<std::int64_t> limit;
    std::optional<std::string> cursor;
};
 
struct GetIntraExchangeInstanceTransfersResponse {
    std::vector<IntraExchangeInstanceTransfer> transfers;
    std::optional<std::string> cursor;
};
 
struct GetLiveDataByMilestoneParams {
    std::optional<bool> include_player_stats;
};
 
struct GetLiveDataParams {
    std::optional<bool> include_player_stats;
};
 
struct LiveData {
    std::string type;
    RawJson details;
    std::string milestone_id;
};
 
struct GetLiveDataResponse {
    LiveData live_data;
};
 
struct GetLiveDatasParams {
    std::vector<std::string> milestone_ids;
    std::optional<bool> include_player_stats;
};
 
struct GetLiveDatasResponse {
    std::vector<LiveData> live_datas;
};
 
struct GetMarketCandlesticksByEventParams {
    std::int64_t start_ts{};
    std::int64_t end_ts{};
    std::int64_t period_interval{};
};
 
struct GetMarketCandlesticksHistoricalParams {
    std::int64_t start_ts{};
    std::int64_t end_ts{};
    std::int64_t period_interval{};
};
 
struct PriceDistributionHistorical {
    std::optional<FixedPointDollars> open;
    std::optional<FixedPointDollars> low;
    std::optional<FixedPointDollars> high;
    std::optional<FixedPointDollars> close;
    std::optional<FixedPointDollars> mean;
    std::optional<FixedPointDollars> previous;
};
 
struct MarketCandlestickHistorical {
    std::int64_t end_period_ts{};
    BidAskDistributionHistorical yes_bid;
    BidAskDistributionHistorical yes_ask;
    PriceDistributionHistorical price;
    FixedPointCount volume;
    FixedPointCount open_interest;
};
 
struct GetMarketCandlesticksHistoricalResponse {
    std::string ticker;
    std::vector<MarketCandlestickHistorical> candlesticks;
};
 
struct GetMarketCandlesticksParams {
    std::int64_t start_ts{};
    std::int64_t end_ts{};
    std::int64_t period_interval{};
    std::optional<bool> include_latest_before_start;
};
 
struct GetMarketCandlesticksResponse {
    std::string ticker;
    std::vector<MarketCandlestick> candlesticks;
};
 
struct MarketIndexTimeseriesPoint {
    std::int64_t t{};
    double v{};
};
 
struct GetMarketIndexHistoryResponse {
    std::string id;
    std::string source;
    MarketIndexStatus status{};
    std::optional<std::int64_t> last_tick_ms;
    std::string interval;
    std::int64_t start_ms{};
    std::int64_t end_ms{};
    std::vector<MarketIndexTimeseriesPoint> timeseries;
};
 
struct MarketIndexSession {
    std::string timezone;
    std::string open;
    std::string close;
    std::vector<std::string> days;
    std::optional<std::string> calendar;
};
 
struct MarketIndexLatest {
    std::string source;
    MarketIndexStatus status{};
    std::optional<double> value;
    std::optional<std::int64_t> last_tick_ms;
};
 
struct MarketIndex {
    std::string id;
    std::string name;
    std::string family;
    std::optional<std::string> gics_code;
    std::optional<std::string> sector;
    std::string currency;
    std::string units;
    MarketIndexSession session;
    bool available{};
    std::optional<MarketIndexLatest> latest;
};
 
struct GetMarketIndexResponse {
    MarketIndex index;
    std::string source;
    MarketIndexStatus status{};
    std::optional<double> value;
    std::optional<std::int64_t> last_tick_ms;
    std::string interval;
    std::int64_t start_ms{};
    std::int64_t end_ms{};
    std::vector<MarketIndexTimeseriesPoint> timeseries;
};
 
struct GetMarketIndexesResponse {
    std::vector<MarketIndex> indexes;
};
 
struct GetMarketOrderbookParams {
    std::optional<std::int64_t> depth;
};
 
struct OrderbookCountFp {
    std::vector<PriceLevelDollarsCountFp> yes_dollars;
    std::vector<PriceLevelDollarsCountFp> no_dollars;
};
 
struct GetMarketOrderbookResponse {
    OrderbookCountFp orderbook_fp;
};
 
struct GetMarketOrderbooksParams {
    std::vector<std::string> tickers;
};
 
struct MarketOrderbookFp {
    std::string ticker;
    OrderbookCountFp orderbook_fp;
};
 
struct GetMarketOrderbooksResponse {
    std::vector<MarketOrderbookFp> orderbooks;
};
 
struct GetMarketResponse {
    Market market;
};
 
struct GetMarketsParams {
    std::optional<std::int64_t> limit;
    std::optional<std::string> cursor;
    std::optional<std::string> event_ticker;
    std::optional<std::string> series_ticker;
    std::optional<std::int64_t> min_created_ts;
    std::optional<std::int64_t> max_created_ts;
    std::optional<std::int64_t> min_updated_ts;
    std::optional<std::int64_t> max_updated_ts;
    std::optional<std::int64_t> max_close_ts;
    std::optional<std::int64_t> min_close_ts;
    std::optional<std::int64_t> min_settled_ts;
    std::optional<std::int64_t> max_settled_ts;
    std::optional<GetMarketsStatus> status;
    std::optional<std::string> tickers;
    std::optional<GetMarketsMveFilter> mve_filter;
};
 
struct GetMarketsResponse {
    std::vector<Market> markets;
    std::string cursor;
};
 
struct GetMilestoneResponse {
    Milestone milestone;
};
 
struct GetMilestonesParams {
    std::int64_t limit{};
    std::optional<std::string> minimum_start_date;
    std::optional<std::string> category;
    std::optional<std::string> competition;
    std::optional<std::string> source_id;
    std::optional<std::string> type;
    std::optional<std::string> related_event_ticker;
    std::optional<std::string> cursor;
    std::optional<std::int64_t> min_updated_ts;
};
 
struct GetMilestonesResponse {
    std::vector<Milestone> milestones;
    std::optional<std::string> cursor;
};
 
struct MultivariateEventCollection {
    std::string collection_ticker;
    std::string series_ticker;
    std::optional<ExchangeIndex> exchange_index;
    std::string title;
    std::string description;
    std::string open_date;
    std::string close_date;
    std::vector<AssociatedEvent> associated_events;
    std::vector<std::string> associated_event_tickers;
    bool is_ordered{};
    bool is_single_market_per_event{};
    bool is_all_yes{};
    std::int64_t size_min{};
    std::int64_t size_max{};
    std::string functional_description;
    std::string price_level_structure;
    std::vector<PriceRange> price_ranges;
};
 
struct GetMultivariateEventCollectionResponse {
    MultivariateEventCollection multivariate_contract;
};
 
struct GetMultivariateEventCollectionsParams {
    std::optional<GetMultivariateEventCollectionsStatus> status;
    std::optional<std::string> associated_event_ticker;
    std::optional<std::string> series_ticker;
    std::optional<std::int64_t> limit;
    std::optional<std::string> cursor;
};
 
struct GetMultivariateEventCollectionsResponse {
    std::vector<MultivariateEventCollection> multivariate_contracts;
    std::optional<std::string> cursor;
};
 
struct GetMultivariateEventsParams {
    std::optional<std::int64_t> limit;
    std::optional<std::string> cursor;
    std::optional<std::string> series_ticker;
    std::optional<std::string> collection_ticker;
    std::optional<std::string> tickers;
    std::optional<bool> with_nested_markets;
};
 
struct GetMultivariateEventsResponse {
    std::vector<EventData> events;
    std::string cursor;
};
 
struct GetOrderGroupParams {
    std::optional<std::int64_t> subaccount;
};
 
struct GetOrderGroupResponse {
    bool is_auto_cancel_enabled{};
    std::optional<FixedPointCount> contracts_limit_fp;
    std::vector<std::string> orders;
    std::optional<ExchangeIndex> exchange_index;
};
 
struct GetOrderGroupsParams {
    std::optional<std::int64_t> subaccount;
};
 
struct OrderGroup {
    std::string id;
    std::optional<FixedPointCount> contracts_limit_fp;
    bool is_auto_cancel_enabled{};
    std::optional<ExchangeIndex> exchange_index;
};
 
struct GetOrderGroupsResponse {
    std::optional<std::vector<OrderGroup>> order_groups;
};
 
struct GetOrderQueuePositionResponse {
    FixedPointCount queue_position_fp;
};
 
struct GetOrderQueuePositionsParams {
    std::optional<std::string> market_tickers;
    std::optional<std::string> event_ticker;
    std::optional<std::int64_t> subaccount;
};
 
struct OrderQueuePosition {
    std::string order_id;
    std::string market_ticker;
    FixedPointCount queue_position_fp;
};
 
struct GetOrderQueuePositionsResponse {
    std::vector<OrderQueuePosition> queue_positions;
};
 
struct GetOrderResponse {
    Order order;
};
 
struct GetOrdersParams {
    std::optional<std::string> ticker;
    std::optional<std::string> event_ticker;
    std::optional<std::int64_t> min_ts;
    std::optional<std::int64_t> max_ts;
    std::optional<std::string> status;
    std::optional<std::int64_t> limit;
    std::optional<std::string> cursor;
    std::optional<std::int64_t> subaccount;
    std::optional<std::int64_t> exchange_index;
};
 
struct GetOrdersResponse {
    std::vector<Order> orders;
    std::string cursor;
};
 
struct GetPortfolioRestingOrderTotalValueResponse {
    std::int64_t total_resting_order_value{};
    std::vector<IndexedBalance> resting_order_value_breakdown;
};
 
struct GetPositionsParams {
    std::optional<std::string> cursor;
    std::optional<std::int64_t> limit;
    std::optional<std::string> count_filter;
    std::optional<SettlementStatus> settlement_status;
    std::optional<std::string> ticker;
    std::optional<std::string> event_ticker;
    std::optional<std::int64_t> subaccount;
    std::optional<std::int64_t> exchange_index;
};
 
struct MarketPosition {
    std::string ticker;
    ExchangeIndex exchange_index{};
    FixedPointDollars total_traded_dollars;
    FixedPointCount position_fp;
    FixedPointDollars market_exposure_dollars;
    FixedPointDollars realized_pnl_dollars;
    FixedPointDollars fees_paid_dollars;
    std::string last_updated_ts;
    bool netting_enabled{};
};
 
struct GetPositionsResponse {
    std::optional<std::string> cursor;
    std::vector<MarketPosition> market_positions;
    std::vector<EventPosition> event_positions;
};
 
struct GetQuoteResponse {
    Quote quote;
};
 
struct GetQuotesParams {
    std::optional<std::string> cursor;
    std::optional<std::int64_t> min_ts;
    std::optional<std::int64_t> max_ts;
    std::optional<std::int64_t> limit;
    std::optional<std::string> status;
    std::optional<std::string> quote_creator_user_id;
    std::optional<UserFilter> user_filter;
    std::optional<UserFilter> rfq_user_filter;
    std::optional<std::string> rfq_creator_user_id;
    std::optional<std::string> rfq_creator_subtrader_id;
    std::optional<std::string> rfq_id;
};
 
struct GetQuotesResponse {
    std::vector<Quote> quotes;
    std::optional<std::string> cursor;
};
 
struct RFQBatchBestQuote {
    std::string rfq_id;
    std::string market_ticker;
    std::optional<FixedPointDollars> yes_bid_dollars;
    std::optional<FixedPointDollars> no_bid_dollars;
    std::optional<FixedPointCount> yes_contracts_offered_fp;
    std::optional<FixedPointCount> no_contracts_offered_fp;
};
 
struct RFQBatchBestQuotes {
    std::string rfq_batch_id;
    RFQBatchStatus status{};
    std::int64_t version{};
    std::optional<std::string> updated_ts;
    bool yes_complete{};
    bool no_complete{};
    std::vector<RFQBatchBestQuote> rfqs;
};
 
struct GetRFQBatchBestQuotesResponse {
    RFQBatchBestQuotes best_quotes;
};
 
struct RFQBatchQuote {
    std::string id;
    std::string rfq_batch_id;
    std::string creator_id;
    std::string rfq_creator_id;
    RFQBatchQuoteStatus status{};
    std::string created_ts;
    std::string updated_ts;
    std::optional<Side> accepted_side;
    std::optional<std::string> accepted_ts;
    std::optional<std::string> confirmed_ts;
    std::vector<Quote> quotes;
    std::optional<bool> rest_remainder;
    std::optional<bool> post_only;
    std::optional<std::string> creator_user_id;
    std::optional<std::int64_t> creator_subaccount;
    std::optional<std::string> rfq_creator_user_id;
    std::optional<std::int64_t> rfq_creator_subaccount;
};
 
struct GetRFQBatchQuotesResponse {
    std::vector<RFQBatchQuote> batch_quotes;
};
 
struct GetRFQBatchResponse {
    RFQBatch rfq_batch;
};
 
struct GetRFQBatchesResponse {
    std::vector<RFQBatch> rfq_batches;
    std::optional<std::string> cursor;
};
 
struct GetRFQResponse {
    RFQ rfq;
};
 
struct GetRFQsResponse {
    std::vector<RFQ> rfqs;
    std::optional<std::string> cursor;
};
 
struct GetRfqBatchesParams {
    std::optional<std::string> cursor;
    std::optional<std::int64_t> subaccount;
    std::optional<std::int64_t> limit;
    std::optional<RFQBatchStatus> status;
    std::optional<UserFilter> user_filter;
};
 
struct GetRfqsParams {
    std::optional<std::string> cursor;
    std::optional<std::string> event_ticker;
    std::optional<std::string> market_ticker;
    std::optional<std::int64_t> subaccount;
    std::optional<std::int64_t> limit;
    std::optional<std::string> status;
    std::optional<std::string> creator_user_id;
    std::optional<UserFilter> user_filter;
};
 
struct GetSeriesFeeChangesParams {
    std::optional<std::string> series_ticker;
    std::optional<bool> show_historical;
};
 
struct SeriesFeeChange {
    std::string id;
    std::string series_ticker;
    FeeType fee_type{};
    double fee_multiplier{};
    std::string scheduled_ts;
};
 
struct GetSeriesFeeChangesResponse {
    std::vector<SeriesFeeChange> series_fee_change_arr;
};
 
struct GetSeriesListParams {
    std::optional<std::string> category;
    std::optional<std::string> tags;
    std::optional<bool> include_product_metadata;
    std::optional<bool> include_volume;
    std::optional<std::int64_t> min_updated_ts;
};
 
struct Series {
    std::string ticker;
    std::string frequency;
    std::string title;
    std::string category;
    std::vector<std::string> categories;
    std::optional<std::vector<std::string>> tags;
    std::optional<std::vector<SettlementSource>> settlement_sources;
    std::string contract_url;
    std::string contract_terms_url;
    std::optional<RawJson> product_metadata;
    FeeType fee_type{};
    double fee_multiplier{};
    std::optional<std::vector<std::string>> additional_prohibitions;
    std::optional<FixedPointCount> volume_fp;
    std::optional<std::string> last_updated_ts;
    std::optional<ExchangeIndex> exchange_index;
};
 
struct GetSeriesListResponse {
    std::vector<Series> series;
};
 
struct GetSeriesParams {
    std::optional<bool> include_volume;
};
 
struct GetSeriesResponse {
    Series series;
};
 
struct GetSettlementsParams {
    std::optional<std::int64_t> limit;
    std::optional<std::string> cursor;
    std::optional<std::string> ticker;
    std::optional<std::string> event_ticker;
    std::optional<std::int64_t> min_ts;
    std::optional<std::int64_t> max_ts;
    std::optional<std::int64_t> subaccount;
};
 
struct Settlement {
    std::string ticker;
    ExchangeIndex exchange_index{};
    std::string event_ticker;
    SettlementMarketResult market_result{};
    FixedPointCount yes_count_fp;
    FixedPointDollars yes_total_cost_dollars;
    FixedPointCount no_count_fp;
    FixedPointDollars no_total_cost_dollars;
    std::int64_t revenue{};
    std::string settled_time;
    FixedPointDollars fee_cost;
    std::optional<std::int64_t> value;
};
 
struct GetSettlementsResponse {
    std::vector<Settlement> settlements;
    std::optional<std::string> cursor;
};
 
struct StructuredTarget {
    std::optional<std::string> id;
    std::optional<std::string> name;
    std::optional<std::string> type;
    std::optional<RawJson> details;
    std::optional<std::string> source_id;
    std::optional<std::map<std::string, std::string>> source_ids;
    std::optional<std::string> last_updated_ts;
};
 
struct GetStructuredTargetResponse {
    std::optional<StructuredTarget> structured_target;
};
 
struct GetStructuredTargetsParams {
    std::vector<std::string> ids;
    std::optional<std::string> type;
    std::optional<std::string> competition;
    std::optional<std::int64_t> page_size;
    std::optional<std::string> cursor;
};
 
struct GetStructuredTargetsResponse {
    std::optional<std::vector<StructuredTarget>> structured_targets;
    std::optional<std::string> cursor;
};
 
struct SubaccountBalance {
    std::int64_t subaccount_number{};
    std::int64_t exchange_index{};
    FixedPointDollars balance;
    std::int64_t updated_ts{};
};
 
struct GetSubaccountBalancesResponse {
    std::vector<SubaccountBalance> subaccount_balances;
};
 
struct SubaccountNettingConfig {
    std::int64_t subaccount_number{};
    bool enabled{};
    std::int64_t exchange_index{};
};
 
struct GetSubaccountNettingResponse {
    std::vector<SubaccountNettingConfig> netting_configs;
};
 
struct GetSubaccountTransfersParams {
    std::optional<std::int64_t> limit;
    std::optional<std::string> cursor;
};
 
struct SubaccountTransfer {
    std::string transfer_id;
    std::int64_t from_subaccount{};
    std::int64_t to_subaccount{};
    std::int64_t amount_cents{};
    std::int64_t created_ts{};
    std::int64_t exchange_index{};
};
 
struct GetSubaccountTransfersResponse {
    std::vector<SubaccountTransfer> transfers;
    std::optional<std::string> cursor;
};
 
struct GetTagsForSeriesCategoriesResponse {
    std::map<std::string, std::vector<std::string>> tags_by_categories;
};
 
struct TargetBalanceAllocation {
    std::int64_t exchange_index{};
    std::int64_t percent{};
};
 
struct GetTargetBalanceAllocationResponse {
    std::vector<TargetBalanceAllocation> allocations;
    RestingMarginReservation resting_margin_reservation{};
};
 
struct GetTradesHistoricalParams {
    std::optional<std::string> ticker;
    std::optional<std::int64_t> min_ts;
    std::optional<std::int64_t> max_ts;
    std::optional<std::int64_t> limit;
    std::optional<std::string> cursor;
    std::optional<bool> is_block_trade;
};
 
struct GetTradesParams {
    std::optional<std::int64_t> limit;
    std::optional<std::string> cursor;
    std::optional<std::string> ticker;
    std::optional<std::int64_t> min_ts;
    std::optional<std::int64_t> max_ts;
    std::optional<bool> is_block_trade;
};
 
struct Trade {
    std::string trade_id;
    std::string ticker;
    FixedPointCount count_fp;
    FixedPointDollars yes_price_dollars;
    FixedPointDollars no_price_dollars;
    std::optional<Side> taker_side;
    OutcomeSide taker_outcome_side{};
    BookSide taker_book_side{};
    std::string created_time;
    bool is_block_trade{};
};
 
struct GetTradesResponse {
    std::vector<Trade> trades;
    std::string cursor;
};
 
struct GetUserDataTimestampResponse {
    std::string as_of_time;
};
 
struct WeatherIndexCalibrationStation {
    std::string station_id;
    double weight{};
    double offset_c{};
    std::optional<std::string> update_note;
};
 
struct WeatherIndexCalibration {
    std::string config_version;
    std::optional<std::int64_t> published_at_ms;
    std::int64_t effective_at_ms{};
    std::optional<std::string> change_reason;
    std::optional<std::int64_t> calibration_window_start_ms;
    std::optional<std::int64_t> calibration_window_end_ms;
    double city_reference_c{};
    std::vector<WeatherIndexCalibrationStation> stations;
};
 
struct GetWeatherIndexCalibrationsResponse {
    std::string city;
    std::string units;
    std::vector<WeatherIndexCalibration> calibrations;
};
 
struct GetWeatherIndexParams {
    std::optional<std::int64_t> from;
    std::optional<std::int64_t> to;
    std::optional<std::int64_t> last_sec;
    std::optional<bool> detailed;
};
 
struct WeatherIndexStationReading {
    std::string station_id;
    std::string code;
    std::optional<std::string> source;
    std::optional<double> temp_f;
    std::optional<std::int64_t> obs_time_ms;
    std::optional<std::int64_t> received_at_ms;
    std::optional<std::string> primary_code;
};
 
struct WeatherIndexPoint {
    std::int64_t t{};
    std::optional<double> v;
    std::string status;
    std::optional<std::int64_t> contributors;
    std::optional<std::string> receipt_basis;
    std::optional<std::vector<WeatherIndexStationReading>> stations;
};
 
struct GetWeatherIndexResponse {
    std::string city;
    std::optional<std::string> config_version;
    std::string units;
    std::vector<WeatherIndexPoint> timeseries;
};
 
struct GetWithdrawalsParams {
    std::optional<std::int64_t> limit;
    std::optional<std::string> cursor;
};
 
struct Withdrawal {
    std::string id;
    DepositStatus status{};
    DepositType type{};
    std::int64_t amount_cents{};
    std::int64_t fee_cents{};
    std::int64_t created_ts{};
    std::optional<std::int64_t> finalized_ts;
};
 
struct GetWithdrawalsResponse {
    std::vector<Withdrawal> withdrawals;
    std::optional<std::string> cursor;
};
 
struct IntraExchangeInstanceTransferRequest {
    std::optional<std::string> client_transfer_id;
    ExchangeInstance source{};
    ExchangeInstance destination{};
    std::int64_t amount{};
    std::optional<std::int64_t> source_exchange_shard;
    std::optional<std::int64_t> destination_exchange_shard;
    std::optional<std::int64_t> source_subaccount;
    std::optional<std::int64_t> destination_subaccount;
};
 
struct IntraExchangeInstanceTransferResponse {
    std::string transfer_id;
};
 
struct ListFCMSubtradersResponse {
    std::vector<FCMSubtrader> subtraders;
};
 
struct ProposeBlockTradeRequest {
    std::string buyer_user_id;
    std::optional<std::string> buyer_subtrader_id;
    std::optional<std::int64_t> buyer_subaccount;
    std::string seller_user_id;
    std::optional<std::string> seller_subtrader_id;
    std::optional<std::int64_t> seller_subaccount;
    std::string market_ticker;
    std::int64_t price_centi_cents{};
    std::int64_t centicount{};
    Side maker_side{};
    std::string expiration_ts;
};
 
struct ProposeBlockTradeResponse {
    std::string block_trade_proposal_id;
};
 
struct ResetOrderGroupParams {
    std::optional<std::int64_t> subaccount;
    std::optional<ExchangeIndex> exchange_index;
};
 
struct SetEventContractExitTriggerParams {
    std::optional<std::int64_t> subaccount;
};
 
struct SetEventContractExitTriggerRequest {
    std::optional<EventContractExitSlippage> slippage;
    std::optional<Kind> kind;
    std::optional<FixedPointDollars> stop_loss_price;
    std::optional<FixedPointDollars> take_profit_price;
};
 
struct TargetBalanceAllocationInput {
    std::int64_t exchange_index{};
    std::int64_t percent{};
};
 
struct SetTargetBalanceAllocationRequest {
    std::vector<TargetBalanceAllocationInput> allocations;
    std::optional<RestingMarginReservation> resting_margin_reservation;
};
 
struct TriggerOrderGroupParams {
    std::optional<std::int64_t> subaccount;
    std::optional<ExchangeIndex> exchange_index;
};
 
struct UpdateFCMEventContractDailyCapRequest {
    std::string subtrader_id;
    FixedPointDollars limit;
};
 
struct UpdateFCMSubtraderBlockedCategoriesRequest {
    std::string subtrader_id;
    std::string category;
    bool blocked{};
};
 
struct UpdateFCMSubtraderBlockedCategoriesResponse {
    std::vector<std::string> categories;
};
 
struct UpdateOrderGroupLimitParams {
    std::optional<std::int64_t> subaccount;
    std::optional<ExchangeIndex> exchange_index;
};
 
struct UpdateOrderGroupLimitRequest {
    std::optional<std::int64_t> contracts_limit;
    std::optional<FixedPointCount> contracts_limit_fp;
};
 
struct UpdateSubaccountNettingRequest {
    std::int64_t subaccount_number{};
    bool enabled{};
};
 
} // namespace kalshi