ws_models.hpp

Go to the documentation of this file.

// Generated by tools/codegen/generate.py from spec/asyncapi.yaml. Do not edit.
#pragma once
 
// WebSocket message types. They live in `kalshi::ws` because several share
// names with REST models, such as `Trade` and `Fill`.
 
#include "kalshi/models.hpp"
 
#include <array>
#include <cstdint>
#include <optional>
#include <string>
#include <string_view>
#include <variant>
#include <vector>
 
namespace kalshi::ws {
 
enum class Channel : std::uint8_t {
    Unknown,                     
    OrderbookDelta,              
    Ticker,                      
    Trade,                       
    Fill,                        
    MarketPositions,             
    MarketLifecycleV2,           
    MultivariateMarketLifecycle, 
    Communications,              
    OrderGroupUpdates,           
    UserOrders,                  
    CfbenchmarksValue,           
    CfbenchmarksValue5hz,        
    PythValue,                   
};
 
[[nodiscard]] constexpr std::string_view to_string(Channel value) noexcept {
    switch (value) {
        case Channel::OrderbookDelta:
            return "orderbook_delta";
        case Channel::Ticker:
            return "ticker";
        case Channel::Trade:
            return "trade";
        case Channel::Fill:
            return "fill";
        case Channel::MarketPositions:
            return "market_positions";
        case Channel::MarketLifecycleV2:
            return "market_lifecycle_v2";
        case Channel::MultivariateMarketLifecycle:
            return "multivariate_market_lifecycle";
        case Channel::Communications:
            return "communications";
        case Channel::OrderGroupUpdates:
            return "order_group_updates";
        case Channel::UserOrders:
            return "user_orders";
        case Channel::CfbenchmarksValue:
            return "cfbenchmarks_value";
        case Channel::CfbenchmarksValue5hz:
            return "cfbenchmarks_value_5hz";
        case Channel::PythValue:
            return "pyth_value";
        case Channel::Unknown:
            break;
    }
    return "";
}
 
enum class CollateralReturnType : std::uint8_t {
    Unknown,  
    MECNET,   
    DIRECNET, 
    Unset,    
};
 
[[nodiscard]] constexpr std::string_view to_string(CollateralReturnType value) noexcept {
    switch (value) {
        case CollateralReturnType::MECNET:
            return "MECNET";
        case CollateralReturnType::DIRECNET:
            return "DIRECNET";
        case CollateralReturnType::Unset:
            return "";
        case CollateralReturnType::Unknown:
            break;
    }
    return "";
}
 
enum class FeeTypeOverride : std::uint8_t {
    Unknown,                      
    Quadratic,                    
    QuadraticWithMakerFees,       
    QuadraticWithComboMakerFees,  
    Flat,                         
    MarginMarketMakerProgramFees, 
};
 
[[nodiscard]] constexpr std::string_view to_string(FeeTypeOverride value) noexcept {
    switch (value) {
        case FeeTypeOverride::Quadratic:
            return "quadratic";
        case FeeTypeOverride::QuadraticWithMakerFees:
            return "quadratic_with_maker_fees";
        case FeeTypeOverride::QuadraticWithComboMakerFees:
            return "quadratic_with_combo_maker_fees";
        case FeeTypeOverride::Flat:
            return "flat";
        case FeeTypeOverride::MarginMarketMakerProgramFees:
            return "margin_market_maker_program_fees";
        case FeeTypeOverride::Unknown:
            break;
    }
    return "";
}
 
enum class LifecyclePriceLevelStructure : std::uint8_t {
    Unknown,                  
    BandedCentiCent,          
    Unset,                    
    LinearCent,               
    DeciCent,                 
    TaperedDeciCent,          
    CenterWholeEdgeHalfCent,  
    CenterWholeEdgeQuintCent, 
    CenterHalfEdgeHalfCent,   
    CenterHalfEdgeQuintCent,  
    CenterHalfEdgeDeciCent,   
    CenterQuintEdgeQuintCent, 
    CenterQuintEdgeDeciCent,  
    CenterCentiEdgeCentiCent, 
    CenterDeciEdgeCentiCent,  
};
 
[[nodiscard]] constexpr std::string_view to_string(LifecyclePriceLevelStructure value) noexcept {
    switch (value) {
        case LifecyclePriceLevelStructure::BandedCentiCent:
            return "banded_centi_cent";
        case LifecyclePriceLevelStructure::Unset:
            return "";
        case LifecyclePriceLevelStructure::LinearCent:
            return "linear_cent";
        case LifecyclePriceLevelStructure::DeciCent:
            return "deci_cent";
        case LifecyclePriceLevelStructure::TaperedDeciCent:
            return "tapered_deci_cent";
        case LifecyclePriceLevelStructure::CenterWholeEdgeHalfCent:
            return "center_whole_edge_half_cent";
        case LifecyclePriceLevelStructure::CenterWholeEdgeQuintCent:
            return "center_whole_edge_quint_cent";
        case LifecyclePriceLevelStructure::CenterHalfEdgeHalfCent:
            return "center_half_edge_half_cent";
        case LifecyclePriceLevelStructure::CenterHalfEdgeQuintCent:
            return "center_half_edge_quint_cent";
        case LifecyclePriceLevelStructure::CenterHalfEdgeDeciCent:
            return "center_half_edge_deci_cent";
        case LifecyclePriceLevelStructure::CenterQuintEdgeQuintCent:
            return "center_quint_edge_quint_cent";
        case LifecyclePriceLevelStructure::CenterQuintEdgeDeciCent:
            return "center_quint_edge_deci_cent";
        case LifecyclePriceLevelStructure::CenterCentiEdgeCentiCent:
            return "center_centi_edge_centi_cent";
        case LifecyclePriceLevelStructure::CenterDeciEdgeCentiCent:
            return "center_deci_edge_centi_cent";
        case LifecyclePriceLevelStructure::Unknown:
            break;
    }
    return "";
}
 
enum class MarketLifecycleV2EventType : std::uint8_t {
    Unknown,                    
    Created,                    
    Deactivated,                
    Activated,                  
    CloseDateUpdated,           
    Determined,                 
    Settled,                    
    PriceLevelStructureUpdated, 
};
 
[[nodiscard]] constexpr std::string_view to_string(MarketLifecycleV2EventType value) noexcept {
    switch (value) {
        case MarketLifecycleV2EventType::Created:
            return "created";
        case MarketLifecycleV2EventType::Deactivated:
            return "deactivated";
        case MarketLifecycleV2EventType::Activated:
            return "activated";
        case MarketLifecycleV2EventType::CloseDateUpdated:
            return "close_date_updated";
        case MarketLifecycleV2EventType::Determined:
            return "determined";
        case MarketLifecycleV2EventType::Settled:
            return "settled";
        case MarketLifecycleV2EventType::PriceLevelStructureUpdated:
            return "price_level_structure_updated";
        case MarketLifecycleV2EventType::Unknown:
            break;
    }
    return "";
}
 
enum class MultivariateMarketLifecycleEventType : std::uint8_t {
    Unknown,          
    Created,          
    Deactivated,      
    Activated,        
    CloseDateUpdated, 
    Determined,       
    Settled,          
};
 
[[nodiscard]] constexpr std::string_view
to_string(MultivariateMarketLifecycleEventType value) noexcept {
    switch (value) {
        case MultivariateMarketLifecycleEventType::Created:
            return "created";
        case MultivariateMarketLifecycleEventType::Deactivated:
            return "deactivated";
        case MultivariateMarketLifecycleEventType::Activated:
            return "activated";
        case MultivariateMarketLifecycleEventType::CloseDateUpdated:
            return "close_date_updated";
        case MultivariateMarketLifecycleEventType::Determined:
            return "determined";
        case MultivariateMarketLifecycleEventType::Settled:
            return "settled";
        case MultivariateMarketLifecycleEventType::Unknown:
            break;
    }
    return "";
}
 
enum class OrderAction : std::uint8_t {
    Unknown,     
    Buy,         
    Sell,        
    SellPartial, 
    SellToClose, 
    Unset,       
};
 
[[nodiscard]] constexpr std::string_view to_string(OrderAction value) noexcept {
    switch (value) {
        case OrderAction::Buy:
            return "buy";
        case OrderAction::Sell:
            return "sell";
        case OrderAction::SellPartial:
            return "sell_partial";
        case OrderAction::SellToClose:
            return "sell_to_close";
        case OrderAction::Unset:
            return "";
        case OrderAction::Unknown:
            break;
    }
    return "";
}
 
enum class OrderGroupUpdatesEventType : std::uint8_t {
    Unknown,      
    Created,      
    Triggered,    
    Reset,        
    Deleted,      
    LimitUpdated, 
};
 
[[nodiscard]] constexpr std::string_view to_string(OrderGroupUpdatesEventType value) noexcept {
    switch (value) {
        case OrderGroupUpdatesEventType::Created:
            return "created";
        case OrderGroupUpdatesEventType::Triggered:
            return "triggered";
        case OrderGroupUpdatesEventType::Reset:
            return "reset";
        case OrderGroupUpdatesEventType::Deleted:
            return "deleted";
        case OrderGroupUpdatesEventType::LimitUpdated:
            return "limit_updated";
        case OrderGroupUpdatesEventType::Unknown:
            break;
    }
    return "";
}
 
enum class UpdateAction : std::uint8_t {
    Unknown,                
    AddMarkets,             
    DeleteMarkets,          
    GetSnapshot,            
    SubscribeIndices,       
    UnsubscribeIndices,     
    Indexlist,              
    SubscribeUnderlyings,   
    UnsubscribeUnderlyings, 
    UnderlyingList,         
};
 
[[nodiscard]] constexpr std::string_view to_string(UpdateAction value) noexcept {
    switch (value) {
        case UpdateAction::AddMarkets:
            return "add_markets";
        case UpdateAction::DeleteMarkets:
            return "delete_markets";
        case UpdateAction::GetSnapshot:
            return "get_snapshot";
        case UpdateAction::SubscribeIndices:
            return "subscribe_indices";
        case UpdateAction::UnsubscribeIndices:
            return "unsubscribe_indices";
        case UpdateAction::Indexlist:
            return "indexlist";
        case UpdateAction::SubscribeUnderlyings:
            return "subscribe_underlyings";
        case UpdateAction::UnsubscribeUnderlyings:
            return "unsubscribe_underlyings";
        case UpdateAction::UnderlyingList:
            return "underlying_list";
        case UpdateAction::Unknown:
            break;
    }
    return "";
}
 
enum class UserFilter : std::uint8_t {
    Unknown, 
    Unset,   
    Self,    
};
 
[[nodiscard]] constexpr std::string_view to_string(UserFilter value) noexcept {
    switch (value) {
        case UserFilter::Unset:
            return "";
        case UserFilter::Self:
            return "self";
        case UserFilter::Unknown:
            break;
    }
    return "";
}
 
struct Subscription {
    std::int64_t id{0};
    Channel channel{Channel::Unknown};
 
    friend bool operator==(const Subscription&, const Subscription&) = default;
};
 
template <typename T>
struct Update {
    std::int64_t sid{0};
    std::optional<std::int64_t> seq;
    std::optional<std::int64_t> id;
    std::int64_t subscription{0};
    T msg;
};
 
struct Cfbenchmarks5HzIndexList {
    std::vector<std::string> index_ids;
};
 
struct CfbenchmarksAvgData {
    std::string value;
    std::int64_t window_size{};
    std::int64_t window_start_ts_ms{};
    std::int64_t window_end_ts_exclusive{};
};
 
struct CfbenchmarksIndexList {
    std::vector<std::string> index_ids;
};
 
struct CfbenchmarksValue {
    std::string index_id;
    std::int64_t received_at{};
    std::string data;
    CfbenchmarksAvgData avg_60s_data;
    std::optional<CfbenchmarksAvgData> last_60s_windowed_average_15min;
};
 
struct CfbenchmarksValue5Hz {
    std::string index_id;
    std::string value_usd;
    std::int64_t source_ts_ms{};
    std::int64_t received_at{};
    std::string data;
};
 
struct EventFeeUpdate {
    std::string event_ticker;
    std::optional<FeeTypeOverride> fee_type_override;
    std::optional<double> fee_multiplier_override;
};
 
struct EventLifecycle {
    std::string event_ticker;
    std::int64_t exchange_index{};
    std::string title;
    std::string subtitle;
    CollateralReturnType collateral_return_type{};
    std::string series_ticker;
    std::optional<std::int64_t> strike_date;
    std::optional<std::string> strike_period;
};
 
struct Fill {
    std::string trade_id;
    std::string order_id;
    std::optional<std::string> client_order_id;
    std::string market_ticker;
    std::int64_t exchange_index{};
    bool is_taker{};
    kalshi::Side side{};
    std::int64_t ts{};
    std::int64_t ts_ms{};
    std::string yes_price_dollars;
    std::string count_fp;
    std::string fee_cost;
    OrderAction action{};
    std::string post_position_fp;
    kalshi::Side purchased_side{};
    kalshi::OutcomeSide outcome_side{};
    kalshi::BookSide book_side{};
    std::optional<std::int64_t> subaccount;
};
 
struct LifecycleAdditionalMetadata {
    std::string name;
    std::string title;
    std::string yes_sub_title;
    std::string no_sub_title;
    std::string rules_primary;
    std::string rules_secondary;
    bool can_close_early{};
    std::string event_ticker;
    std::int64_t expected_expiration_ts{};
    std::optional<std::string> strike_type;
    std::optional<double> floor_strike;
    std::optional<double> cap_strike;
    std::optional<RawJson> custom_strike;
};
 
struct MarketLifecycleV2PriceRangesItem {
    std::string start;
    std::string end;
    std::string step;
};
 
struct MarketLifecycleV2 {
    std::string market_ticker;
    std::optional<std::int64_t> exchange_index;
    std::optional<std::int64_t> open_ts;
    std::optional<std::int64_t> close_ts;
    std::optional<std::int64_t> determination_ts;
    std::optional<std::int64_t> settled_ts;
    std::optional<std::string> result;
    std::optional<std::string> settlement_value;
    std::optional<bool> is_deactivated;
    std::optional<LifecycleAdditionalMetadata> additional_metadata;
    MarketLifecycleV2EventType event_type{};
    std::optional<LifecyclePriceLevelStructure> price_level_structure;
    std::optional<std::vector<MarketLifecycleV2PriceRangesItem>> price_ranges;
};
 
struct MarketMetadataUpdated {
    std::string market_ticker;
    std::optional<std::string> strike_type;
    std::optional<double> floor_strike;
    std::optional<double> cap_strike;
    std::optional<RawJson> custom_strike;
    std::optional<std::string> yes_sub_title;
};
 
struct MarketPosition {
    std::string user_id;
    std::string market_ticker;
    std::string position_fp;
    std::string position_cost_dollars;
    std::string realized_pnl_dollars;
    std::string fees_paid_dollars;
    std::string position_fee_cost_dollars;
    std::string volume_fp;
    std::optional<std::int64_t> subaccount;
};
 
struct MultivariateMarketLifecycle {
    std::string market_ticker;
    std::optional<std::int64_t> exchange_index;
    std::optional<std::int64_t> open_ts;
    std::optional<std::int64_t> close_ts;
    std::optional<std::int64_t> determination_ts;
    std::optional<std::int64_t> settled_ts;
    std::optional<std::string> result;
    std::optional<std::string> settlement_value;
    std::optional<bool> is_deactivated;
    std::optional<LifecycleAdditionalMetadata> additional_metadata;
    MultivariateMarketLifecycleEventType event_type{};
    std::optional<LifecyclePriceLevelStructure> price_level_structure;
};
 
struct OrderGroupUpdates {
    OrderGroupUpdatesEventType event_type{};
    std::string order_group_id;
    std::optional<std::string> contracts_limit_fp;
    std::int64_t ts_ms{};
};
 
struct OrderbookDelta {
    std::string market_ticker;
    std::string market_id;
    std::string price_dollars;
    std::string delta_fp;
    kalshi::Side side{};
    std::optional<std::string> client_order_id;
    std::optional<std::string> ts;
    std::optional<std::int64_t> ts_ms;
    std::optional<std::int64_t> subaccount;
};
 
struct OrderbookSnapshot {
    std::string market_ticker;
    std::string market_id;
    std::optional<std::vector<std::array<std::string, 2>>> yes_dollars_fp;
    std::optional<std::vector<std::array<std::string, 2>>> no_dollars_fp;
};
 
struct PythUnderlyingList {
    std::vector<std::string> underlying_tickers;
};
 
struct PythValue {
    std::string underlying_ticker;
    std::string value_usd;
    std::int64_t source_ts_ms{};
    std::int64_t received_at{};
};
 
struct QuoteAccepted {
    std::string quote_id;
    std::string rfq_id;
    std::string quote_creator_id;
    std::string rfq_creator_id;
    std::string market_ticker;
    std::optional<std::string> event_ticker;
    std::string yes_bid_dollars;
    std::string no_bid_dollars;
    std::optional<kalshi::Side> accepted_side;
    std::optional<std::string> contracts_accepted_fp;
    std::optional<std::string> yes_contracts_offered_fp;
    std::optional<std::string> no_contracts_offered_fp;
    std::optional<std::string> rfq_target_cost_dollars;
    std::optional<std::int64_t> subaccount;
};
 
struct QuoteCreated {
    std::string quote_id;
    std::string rfq_id;
    std::string quote_creator_id;
    std::string rfq_creator_id;
    std::string market_ticker;
    std::optional<std::string> event_ticker;
    std::string yes_bid_dollars;
    std::string no_bid_dollars;
    std::optional<std::string> yes_contracts_offered_fp;
    std::optional<std::string> no_contracts_offered_fp;
    std::optional<std::string> rfq_target_cost_dollars;
    std::string created_ts;
    std::optional<std::int64_t> subaccount;
};
 
struct QuoteExecuted {
    std::string quote_id;
    std::string rfq_id;
    std::string quote_creator_id;
    std::string rfq_creator_id;
    std::string order_id;
    std::string client_order_id;
    std::string market_ticker;
    std::string executed_ts;
    std::optional<std::int64_t> subaccount;
};
 
struct RfqCreatedMveSelectedLegsItem {
    std::string event_ticker;
    std::string market_ticker;
    kalshi::Side side{};
    std::optional<std::string> yes_settlement_value_dollars;
};
 
struct RfqCreated {
    std::string id;
    std::string creator_id;
    std::string market_ticker;
    std::optional<std::string> event_ticker;
    std::optional<std::string> contracts_fp;
    std::optional<std::string> target_cost_dollars;
    std::string created_ts;
    std::optional<std::string> mve_collection_ticker;
    std::optional<std::vector<RfqCreatedMveSelectedLegsItem>> mve_selected_legs;
};
 
struct RfqDeleted {
    std::string id;
    std::string creator_id;
    std::string market_ticker;
    std::optional<std::string> event_ticker;
    std::optional<std::string> contracts_fp;
    std::optional<std::string> target_cost_dollars;
    std::string deleted_ts;
};
 
struct SubscribeParams {
    std::optional<std::string> market_ticker;
    std::vector<std::string> market_tickers;
    std::optional<std::string> market_id;
    std::vector<std::string> market_ids;
    std::optional<bool> send_initial_snapshot;
    std::optional<bool> skip_ticker_ack;
    std::optional<bool> use_yes_price;
    std::optional<UserFilter> user_filter;
    std::optional<std::int64_t> shard_factor;
    std::optional<std::int64_t> shard_key;
    std::vector<std::string> index_ids;
    std::vector<std::string> underlying_tickers;
};
 
struct Ticker {
    std::string market_id;
    std::string market_ticker;
    std::string price_dollars;
    std::string yes_bid_dollars;
    std::string yes_ask_dollars;
    std::string volume_fp;
    std::string open_interest_fp;
    std::int64_t dollar_volume{};
    std::int64_t dollar_open_interest{};
    std::string yes_bid_size_fp;
    std::string yes_ask_size_fp;
    std::string last_trade_size_fp;
    std::int64_t ts{};
    std::int64_t ts_ms{};
    std::string time;
};
 
struct Trade {
    std::string trade_id;
    std::string market_ticker;
    std::string yes_price_dollars;
    std::string no_price_dollars;
    std::string count_fp;
    kalshi::Side taker_side{};
    kalshi::OutcomeSide taker_outcome_side{};
    kalshi::BookSide taker_book_side{};
    bool is_block_trade{};
    std::int64_t ts{};
    std::int64_t ts_ms{};
};
 
struct UpdateSubscriptionParams {
    std::optional<std::string> market_ticker;
    std::vector<std::string> market_tickers;
    std::optional<std::string> market_id;
    std::vector<std::string> market_ids;
    std::optional<bool> send_initial_snapshot;
    UpdateAction action{};
    std::vector<std::string> index_ids;
    std::vector<std::string> underlying_tickers;
};
 
struct UserOrder {
    std::string order_id;
    std::string user_id;
    std::string ticker;
    std::int64_t exchange_index{};
    kalshi::OrderStatus status{};
    kalshi::Side side{};
    bool is_yes{};
    kalshi::OutcomeSide outcome_side{};
    kalshi::BookSide book_side{};
    std::string yes_price_dollars;
    std::string fill_count_fp;
    std::string remaining_count_fp;
    std::string initial_count_fp;
    std::string taker_fill_cost_dollars;
    std::string maker_fill_cost_dollars;
    std::string taker_fees_dollars;
    std::string maker_fees_dollars;
    std::string client_order_id;
    std::optional<std::string> order_group_id;
    std::optional<kalshi::SelfTradePreventionType> self_trade_prevention_type;
    std::optional<std::string> created_time;
    std::optional<std::string> last_update_time;
    std::optional<std::string> expiration_time;
    std::optional<std::int64_t> expiration_ts_ms;
    std::optional<std::int64_t> created_ts_ms;
    std::optional<std::int64_t> last_updated_ts_ms;
    std::optional<std::int64_t> subaccount_number;
};
 
struct Subscribed {
    Subscription subscription;
    std::int64_t sid{0};
};
 
struct Unsubscribed {
    Subscription subscription;
};
 
struct Updated {
    Subscription subscription;
    std::vector<std::string> market_tickers;
    std::vector<std::string> market_ids;
    std::vector<std::string> index_ids;
    std::vector<std::string> underlying_tickers;
};
 
struct ListedSubscription {
    std::string channel;
    std::int64_t sid{0};
};
 
struct SubscriptionList {
    std::int64_t id{0};
    std::vector<ListedSubscription> subscriptions;
};
 
using Message =
    std::variant<Update<OrderbookSnapshot>, Update<OrderbookDelta>, Update<Ticker>, Update<Trade>,
                 Update<Fill>, Update<MarketPosition>, Update<EventLifecycle>,
                 Update<EventFeeUpdate>, Update<MultivariateMarketLifecycle>, Update<RfqCreated>,
                 Update<RfqDeleted>, Update<QuoteCreated>, Update<QuoteAccepted>,
                 Update<QuoteExecuted>, Update<OrderGroupUpdates>, Update<UserOrder>,
                 Update<CfbenchmarksValue>, Update<CfbenchmarksIndexList>,
                 Update<CfbenchmarksValue5Hz>, Update<Cfbenchmarks5HzIndexList>, Update<PythValue>,
                 Update<PythUnderlyingList>, Update<MarketMetadataUpdated>,
                 Update<MarketLifecycleV2>, Subscribed, Unsubscribed, Updated, SubscriptionList>;
[[nodiscard]] constexpr std::string_view error_code_name(std::int64_t code) noexcept {
    switch (code) {
        case 1:
            return "Unable to process message";
        case 2:
            return "Params required";
        case 3:
            return "Channels required";
        case 4:
            return "Subscription IDs required";
        case 5:
            return "Unknown command";
        case 7:
            return "Unknown subscription ID";
        case 8:
            return "Unknown channel name";
        case 9:
            return "Authentication required";
        case 10:
            return "Channel error";
        case 11:
            return "Invalid parameter";
        case 12:
            return "Exactly one subscription ID is required";
        case 13:
            return "Unsupported action";
        case 14:
            return "Market Ticker required";
        case 15:
            return "Action required";
        case 18:
            return "Command timeout";
        case 19:
            return "shard_factor must be > 0";
        case 20:
            return "shard_factor is required when shard_key is set";
        case 21:
            return "shard_key must be >= 0 and < shard_factor";
        case 22:
            return "shard_factor must be <= 100";
        case 23:
            return "Match IDs required";
        case 24:
            return "Index IDs required";
        case 25:
            return "Subscription buffer overflow";
        case 26:
            return "Subscription market limit exceeded";
        case 27:
            return "Too many requests";
        case 28:
            return "Underlying tickers required";
        default:
            return "";
    }
}
} // namespace kalshi::ws