syntax = "proto3";

enum AnnounceTime {
  Premarket = 0;
  Postmarket = 1;
  Unknown = 2;
}

// Category of the market's question. Mirrors the category assigned to the
// question from its Polymarket tags.
enum Category {
  // Cryptocurrency markets (BTC/ETH price levels, etc.).
  CRYPTO = 0;
  // Pop culture, celebrities and entertainment.
  CULTURE = 1;
  // Finance and economics (stocks, Fed, macro).
  FINANCE = 2;
  // Video games and gaming events.
  GAMES = 3;
  // "Will X mention/say Y" style markets.
  MENTIONS = 4;
  // Anything that doesn't fit the other categories. Also used as a
  // fallback when the question's category is unknown.
  OTHER = 5;
  // Elections, legislation and geopolitics.
  POLITICS = 6;
  // Sports markets.
  SPORTS = 7;
  // Weather and climate markets.
  WEATHER = 8;
}

// Whether a position is long or short.
enum Direction {
  // Direction could not be determined.
  DIRECTION_UNKNOWN = 0;
  // Long position.
  DIRECTION_LONG = 1;
  // Short position.
  DIRECTION_SHORT = 2;
}

// Extended hours / "sold" qualifier for the sale.
enum ExthourSoldCodes {
  // Trade executed outside regular trading hours.
  EXTENDED_HOURS_TRADE = 0;
  // Extended hours trade reported late or out of sequence.
  EXTENDED_HOURS_TRADE_LATE_OR_OUT_OF_SEQUENCE = 1;
  // Late report of a trade that is the last sale for its market.
  SOLD_LAST = 2;
  // Trade reported out of sequence.
  SOLD_OUT_OF_SEQUENCE = 3;
  // Sentinel: the trade carries no extended hours/sold code.
  EXTHOUR_SOLD_CODES_EMPTY = 4;
  // Sentinel: the trade carries no extended hours/sold code (alias of EXTHOUR_SOLD_CODES_EMPTY).
  ESC_EMPTY = 5;
}

// How the contract is fulfilled upon exercise or assignment.
enum FlexOption.Delivery {
  // Delivers the underlying security.
  PHYSICAL = 0;
  // Delivers a cash settlement amount.
  CASH = 1;
}

// When the contract can be exercised.
enum FlexOption.ExerciseStyle {
  // Can be exercised on any business day through expiration.
  AMERICAN = 0;
  // Can be exercised only on the expiration date.
  EUROPEAN = 1;
}

// When or how the contract's settlement value is determined.
enum FlexOption.Settlement {
  // Settles using the opening prices on the expiration date.
  AM = 0;
  // Settles using the closing prices on the expiration date.
  PM = 1;
  // Settles using an average of underlying prices over a defined period.
  ASIAN = 2;
  // Settles from periodically locked-in underlying performance.
  CLIQUET = 3;
}

// Which trades an interval counts.
enum IntervalType {
  // Every option trade of the ticker.
  All = 0;
  // OTM trades only. Only emitted when the interval saw OTM trades.
  OtmOnly = 1;
}

enum IssueType {
  Adr = 0;
  CommonStock = 1;
  Etf = 2;
  Other = 3;
  PreferredStock = 4;
  Right = 5;
  StructuredProduct = 6;
  Unit = 7;
  Warrant = 8;
  Index = 9;
}

// The trading session a state belongs to, in Eastern Time.
enum MarketTime {
  // Before 9:30.
  PREMARKET = 0;
  // After the close. The close is 16:00 on normal days and 13:00 on
  // early close days (e.g. the day after Thanksgiving).
  POSTMARKET = 1;
  // From 9:30 until the close.
  REGULAR = 2;
  // Not being sent as of now.
  UNKNOWN = 3;
}

// Which side of the market a trade hit.
enum OptionTradeSide {
  // No side.
  OPTION_TRADE_SIDE_NO = 0;
  // Hit the ask.
  OPTION_TRADE_SIDE_ASK = 1;
  // Hit the bid.
  OPTION_TRADE_SIDE_BID = 2;
  // Filled at the mid.
  OPTION_TRADE_SIDE_MID = 3;
}

// Option Type
enum OptionType {
  // Call option.
  call = 0;
  // Put option.
  put = 1;
}

enum Sector {
  BasicMaterials = 0;
  CommunicationServices = 1;
  ConsumerCyclical = 2;
  ConsumerDefensive = 3;
  Energy = 4;
  FinancialServices = 5;
  Healthcare = 6;
  Industrials = 7;
  RealEstate = 8;
  Technology = 9;
  Utilities = 10;
}

// Which side of the trade a counterparty was on.
enum Side {
  // Paid USDC to receive outcome tokens.
  BUYER = 0;
  // Sold outcome tokens to receive USDC.
  SELLER = 1;
}

// Special sale condition qualifier for the sale.
enum SpecialSaleConditionsCodes {
  // Acquisition.
  ACQUISITION = 0;
  // Bunched trade
  BUNCHED = 1;
  // Distribution.
  DISTRIBUTION = 2;
  // Price variation transaction
  PRICE_VARIATION_TRANSACTION = 3;
  // Nasdaq Official Closing Price (NOCP).
  NASDAQ_OFFICIAL_CLOSE_PRICE = 4;
  // Prior reference price (priced off an earlier point in time).
  PRIOR_REFERENCE_PRICE = 5;
  // Nasdaq Official Opening Price (NOOP).
  NASDAQ_OFFICIAL_OPENING_PRICE = 6;
  // Split trade.
  SPLIT_TRADE = 7;
  // Contingent trade.
  CONTINGENT_TRADE = 8;
  // Average price trade.
  AVERAGE_PRICE_TRADE = 9;
  // Cross trade.
  CROSS_TRADE = 10;
  // Odd lot execution
  ODD_LOT_EXECUTION = 11;
  // Odd lot cross execution.
  ODD_LOT_CROSS_EXECUTION = 12;
  // Sentinel: the trade carries no special sale condition code.
  SPECIAL_SALE_CONDITIONS_CODES_EMPTY = 13;
  // Sentinel: the trade carries no special sale condition code (alias of SPECIAL_SALE_CONDITIONS_CODES_EMPTY).
  SSC_EMPTY = 14;
}

// The classified options strategy a spread represents.
enum Strategy {
  // The legs did not match a known strategy.
  STRATEGY_OTHER = 0;
  // Synthetic.
  STRATEGY_SYNTHETIC = 1;
  // Strip.
  STRATEGY_STRIP = 2;
  // Strap.
  STRATEGY_STRAP = 3;
  // One by one by two.
  STRATEGY_1_1_2 = 4;
  // Iron butterfly.
  STRATEGY_IRON_BUTTERFLY = 5;
  // Iron condor.
  STRATEGY_IRON_CONDOR = 6;
  // Call condor.
  STRATEGY_CALL_CONDOR = 7;
  // Put condor.
  STRATEGY_PUT_CONDOR = 8;
  // Jade lizard.
  STRATEGY_JADE_LIZARD = 9;
  // Put ladder.
  STRATEGY_PUT_LADDER = 10;
  // Call ladder.
  STRATEGY_CALL_LADDER = 11;
  // Call vertical spread.
  STRATEGY_CALL_VERTICAL_SPREAD = 12;
  // Put vertical spread.
  STRATEGY_PUT_VERTICAL_SPREAD = 13;
  // Strangle.
  STRATEGY_STRANGLE = 14;
  // Straddle.
  STRATEGY_STRADDLE = 15;
  // Put calendar.
  STRATEGY_PUT_CALENDAR = 16;
  // Call calendar.
  STRATEGY_CALL_CALENDAR = 17;
  // Put ratio spread.
  STRATEGY_PUT_RATIO_SPREAD = 18;
  // Call ratio spread.
  STRATEGY_CALL_RATIO_SPREAD = 19;
  // Put backspread.
  STRATEGY_PUT_BACKSPREAD = 20;
  // Call backspread.
  STRATEGY_CALL_BACKSPREAD = 21;
  // Put frontspread.
  STRATEGY_PUT_FRONTSPREAD = 22;
  // Call frontspread.
  STRATEGY_CALL_FRONTSPREAD = 23;
  // Call butterfly spread.
  STRATEGY_CALL_BUTTERFLY_SPREAD = 24;
  // Put butterfly spread.
  STRATEGY_PUT_BUTTERFLY_SPREAD = 25;
  // Single call.
  STRATEGY_CALL = 26;
  // Single put.
  STRATEGY_PUT = 27;
  // Risk reversal.
  STRATEGY_RISK_REVERSAL = 28;
  // Deprecated, folded into STRATEGY_CALL_DIAGONAL_SPREAD.
  STRATEGY_CALL_DIAGONAL_SPREAD_BULLISH = 29;
  // Deprecated, folded into STRATEGY_PUT_DIAGONAL_SPREAD.
  STRATEGY_PUT_DIAGONAL_SPREAD_BULLISH = 30;
  // Deprecated, folded into STRATEGY_CALL_DIAGONAL_SPREAD.
  STRATEGY_CALL_DIAGONAL_SPREAD_BEARISH = 31;
  // Deprecated, folded into STRATEGY_PUT_DIAGONAL_SPREAD.
  STRATEGY_PUT_DIAGONAL_SPREAD_BEARISH = 32;
  // Box spread.
  STRATEGY_BOX_SPREAD = 33;
  // Straddle swap.
  STRATEGY_STRADDLE_SWAP = 34;
  // Strangle swap.
  STRATEGY_STRANGLE_SWAP = 35;
  // Ratio risk reversal.
  STRATEGY_RATIO_RISK_REVERSAL = 36;
  // Time butterfly.
  STRATEGY_TIME_BUTTERFLY = 37;
  // Jelly roll.
  STRATEGY_JELLY_ROLL = 38;
  // Call diagonal spread.
  STRATEGY_CALL_DIAGONAL_SPREAD = 39;
  // Put diagonal spread.
  STRATEGY_PUT_DIAGONAL_SPREAD = 40;
}

// How soon the traded contract expires.
enum TideExpiration {
  // Expiring later in the same ISO week. Trades expiring after this week
  // are not part of this feed at all.
  WEEKLY = 0;
  // Expiring the same day.
  ZERO_DTE = 1;
}

// The moneyness of the traded contract.
enum TideMoneyness {
  // All kind of trades
  ALL_MONEYNESS = 0;
  // In the money trades only
  ITM = 1;
  // Out of the money trades only
  OTM = 2;
  // At the money trades only
  ATM = 3;
}

// The classification of a trade's underlying.
enum TideType {
  // All types
  ALL_TYPES = 0;
  // Index tickers only
  INDEX_ONLY = 1;
  // Stocks only
  EQUITY_ONLY = 2;
  // ETFs only
  ETF_ONLY = 3;
}

// Trade / print qualifier for the sale.
enum TradeCodes {
  // Intermarket Sweep Order (ISO).
  INTERMARKET_SWEEP = 0;
  // Opening print for the security's trading session.
  OPENING_PRINT = 1;
  // Derivatively priced trade.
  DERIVATIVE_PRICED = 2;
  // Re opening print after a trading halt or pause.
  RE_OPENING_PRINT = 3;
  // Closing print for the security's trading session.
  CLOSING_PRINT = 4;
  // Qualified Contingent Trade (QCT).
  QUALIFIED_CONTINGENT_TRADE = 5;
  // Sentinel: the trade carries no trade code.
  TRADE_CODES_EMPTY = 6;
  // Sentinel: the trade carries no trade code (alias of TRADE_CODES_EMPTY).
  TC_EMPTY = 7;
}

// When a trade settles relative to its execution date.
enum TradeSettlement {
  // Regular way settlement.
  REGULAR_SETTLEMENT = 0;
  // Cash trade, settles the same day.
  CASH_SETTLEMENT = 1;
  // Settles the next business day.
  NEXT_DAY_SETTLEMENT = 2;
  // Seller's option: settles on a day chosen by the seller within an agreed window.
  SELLER_SETTLEMENT = 3;
}

// Aggregated activity of a single option contract over a 5 minute
// interval: traded volume split by trade side and trade type, OHLC of the
// contract price, premium, greeks and IV.
// Fields without a total_ prefix are cumulative for the interval not the
// day. The total_ prefixed fields are the contract's cumulative values for
// the whole day so far.
// The Kafka message key is the ticker of the underlying; the contract is
// identified by option_symbol.
message ChainFrag {
  // OptionSymbol in the OSI format, SPY241227C00480000
  string option_symbol = 1;
  // Start of the 5 minute interval in milliseconds since 1970 (unix).
  int64 start_time = 2;
  // Execution time of the latest trade in the interval in milliseconds
  // since 1970 (unix).
  int64 tape_time = 3;
  // Contracts traded in the interval.
  int64 volume = 4;
  // The contract's cumulative volume for the whole day so far.
  int64 total_volume = 5;
  // The OI of the chain.
  int32 open_interest = 6;
  // Premium transacted in the interval in dollars. Decimal string.
  string premium = 7;
  // Contracts that transacted on the ask side in the interval.
  int32 ask_side_volume = 8;
  // Contracts that transacted on the bid side in the interval.
  int32 bid_side_volume = 9;
  // Contracts that came from the floor in the interval.
  int32 floor_volume = 10;
  // Highest trade price of the contract in the interval. Decimal string.
  string high = 11;
  // Lowest trade price of the contract in the interval. Decimal string.
  string low = 12;
  // First trade price of the contract in the interval. Decimal string.
  string open = 13;
  // Last trade price of the contract in the interval. Decimal string.
  string close = 14;
  // The most recent implied volatility of the contract. Decimal string.
  string iv = 15;
  // Number of trades in the interval.
  int32 trades = 16;
  // Volume weighted average trade price of the interval. Decimal string.
  string avg_price = 17;
  // Contracts that transacted at the mid in the interval.
  int32 mid_volume = 18;
  // Contracts that were part of sweep transactions in the interval.
  int32 sweep_volume = 19;
  // Contracts that were part of cross transactions in the interval.
  int32 cross_volume = 20;
  // Contracts that were part of stock multi leg trades in the interval.
  int32 stock_multi_leg_volume = 21;
  // Contracts without a classifiable side in the interval.
  int32 no_side_vol = 22;
  // Contracts that were part of multi leg trades in the interval.
  int32 multileg_volume = 23;
  // The price of the underlying at the latest trade. Decimal string.
  string underlying_price = 24;
  // The contract's cumulative premium for the whole day so far in dollars.
  // Decimal string.
  string total_premium = 25;
  // The contract's cumulative ask side volume for the whole day so far.
  int32 total_ask_side_volume = 26;
  // The contract's cumulative bid side volume for the whole day so far.
  int32 total_bid_side_volume = 27;
  // The contract's cumulative mid volume for the whole day so far.
  int32 total_mid_volume = 28;
  // The contract's cumulative stock multi leg volume for the whole day so far.
  int32 total_stock_multi_leg_volume = 29;
  // The contract's cumulative neutral volume for the whole day so far.
  int32 total_neutral_volume = 30;
  // The contract's cumulative multi leg volume for the whole day so far.
  int32 total_multileg_volume = 31;
  // The delta of the contract at the latest trade. Decimal string.
  string delta = 32;
  // The gamma of the contract at the latest trade. Decimal string.
  string gamma = 33;
  // The theta of the contract at the latest trade. Decimal string.
  string theta = 34;
  // The vega of the contract at the latest trade. Decimal string.
  string vega = 35;
  // The implied volatility at the first trade of the interval. Decimal string.
  string iv_start = 36;
  // The implied volatility at the last trade of the interval. Decimal string.
  string iv_end = 37;
  // The EWMA smoothed NBBO bid at the interval close. Decimal string.
  string bid = 38;
  // The EWMA smoothed NBBO ask at the interval close. Decimal string.
  string ask = 39;
}

message Date {
  int32 year = 1;
  uint32 month = 2;
  uint32 day = 3;
}

// Exact decimal number, mirroring Rust's `rust_decimal::Decimal`: a 96-bit
// unsigned integer mantissa, a base-10 scale and a sign.
//   value = (hi << 64 | lo) / 10^scale, negated when `negative` is true
// Example: lo=12345, hi=0, scale=2, negative=false represents 123.45.
// Decoding in Rust (with the `rust_decimal` crate):
//   let lo = (d.lo & 0xFFFF_FFFF) as u32;
//   let mid = (d.lo >> 32) as u32;
//   let value = Decimal::from_parts(lo, mid, d.hi, d.negative, d.scale);
// Decoding in Python (E-notation string: exact regardless of the decimal
// context's precision, and faster than dividing by 10^scale):
//   from decimal import Decimal
//   mantissa = (d.hi << 64) | d.lo
//   value = Decimal(f"{'-' if d.negative else ''}{mantissa}E-{d.scale}")
message Decimal {
  // Low 64 bits of the 96-bit mantissa.
  uint64 lo = 1;
  // High 32 bits of the 96-bit mantissa.
  uint32 hi = 2;
  // Number of decimal digits after the point, i.e. the power of ten the
  // mantissa is divided by. At most 28.
  uint32 scale = 3;
  // True when the value is negative.
  bool negative = 4;
}

// Net options flow of near dated contracts, bucketed to the minute and
// broken out by underlying type, moneyness and time to expiry. Every trade
// counts into four buckets: its own moneyness and ALL_MONEYNESS, crossed
// with its own underlying type and ALL_TYPES, so the ALL buckets are
// pre-aggregated roll ups. Each message is a per window partial sum;
// consumers add messages with the same bucket together. net means ask side
// minus bid side.
message DteTide {
  // Which underlying types this bucket counts.
  TideType tideType = 1;
  // Which moneyness this bucket counts.
  TideMoneyness moneyness = 2;
  // Whether this bucket counts same day or same week expirations.
  TideExpiration expiration = 3;
  // Net (ask side minus bid side) call contracts.
  int64 netCallVolume = 4;
  // Net (ask side minus bid side) call premium. Decimal string.
  string netCallPremium = 5;
  // Net (ask side minus bid side) put contracts.
  int64 netPutVolume = 6;
  // Net (ask side minus bid side) put premium. Decimal string.
  string netPutPremium = 7;
  // Number of trades aggregated into this message.
  int32 transactions = 8;
  // The minute bucket the trades fall into, in milliseconds since 1970 (unix).
  int64 startTime = 9;
  // Execution time of the latest trade in the bucket, in milliseconds
  // since 1970 (unix).
  int64 timestamp = 10;
  // Not populated.
  string ticker = 11;
}

// A FLEX option position being consolidated into a standard option contract.
message FlexConsolidation {
  // Underlying ticker of the standard option contract.
  Ticker ticker = 1;
  // Source FLEX option contract.
  FlexOption flex_option = 2;
  // Destination standard option contract.
  OptionChain standard_option = 3;
  // Latest underlying price when the event is published.
  Decimal underlying_price = 4;
  // Open interest transferred from the FLEX option contract.
  int32 transferred_oi = 5;
  // Date when the consolidation becomes effective.
  Date effective_date = 6;
}

// An exchange traded option created with investor selected terms instead of the
// fixed terms of an existing standard series. Investors choose the strike,
// expiration, and exercise style and their broker solicits prices from market
// participants.
message FlexOption {
  // Underlying ticker of the FLEX option contract.
  Ticker ticker = 1;
  // FLEX ticker assigned by OCC.
  string flex_ticker = 2;
  // OSI symbol of the FLEX option contract.
  string option_symbol = 3;
  // Strike price in thousandths of a dollar.
  int32 strike = 4;
  // Expiration date in YYYY-MM-DD.
  string expiry = 5;
  // Call or put.
  OptionType type = 6;
  // Settlement timing or calculation method.
  FlexOption.Settlement settlement = 7;
  // Exercise style of the contract.
  FlexOption.ExerciseStyle exercise_style = 8;
  // Delivery method of the contract.
  FlexOption.Delivery delivery = 9;
}

// Daily open interest and mark state for a FLEX option contract.
message FlexOptionState {
  // FLEX option contract metadata.
  FlexOption flex_option = 1;
  // The date this data represents
  Date date = 2;
  // Open interest reported for the contract.
  int32 open_interest = 3;
  // Open interest reported on the previous trading day.
  // Missing when it is the first day this contract trades and there is no
  // previous trading day.
  optional int32 previous_open_interest = 4;
  // Change in open interest from the previous trading day.
  // Missing when it is the first day this contract trades and there is no
  // previous trading day.
  optional int32 open_interest_change = 5;
  // Mark price reported for the contract.
  Decimal mark = 6;
  // Mark price reported on the previous trading day.
  // Missing when it is the first day this contract trades and there is no
  // previous trading day.
  optional Decimal previous_mark = 7;
  // Aggregate FLEX option state for the contract's underlying ticker.
  FlexTickerState ticker_state = 8;
}

// Daily aggregate FLEX option state for an underlying ticker.
message FlexTickerState {
  // Total open interest across the ticker's FLEX option contracts.
  int64 total_flex_oi = 1;
  // Change in total FLEX open interest from the previous trading day.
  optional int64 total_flex_oi_change = 2;
  // Number of FLEX option contracts reported for the ticker.
  int32 total_flex_chains = 3;
  // Change in the number of FLEX option contracts from the previous trading day.
  optional int32 total_flex_chains_change = 4;
  // Total option open interest reported for the ticker.
  int64 total_option_oi = 5;
}

// An n aggregate of option transactions that tripped a rule, see https://unusualwhales.com/option-flow-alerts/rules
message FlowAlert {
  // / UUID that represents for the rule for which the alert triggered
  string rule_id = 1;
  // The underlying ticker symbol the alert is for
  string ticker = 2;
  // OptionSymbol in the OSI format, SPY241227C00480000
  string option_chain = 3;
  // The price of the underlying at the point of when the alert got created
  double underlying_price = 4;
  // The total market volume of the option symbol
  // at the point of when the alert got created.
  int64 volume = 5;
  // The total aggregated size of all transactions
  // that make up this alert.
  int32 total_size = 6;
  // The total aggregated premium of all transactions
  // that make up this alert.
  double total_premium = 7;
  // The total aggregated ask premium
  // (meaning all trades that executed closer to the ask than bid)
  // of all transactions that make up this alert.
  double total_ask_side_prem = 8;
  // The total aggregated bid premium
  // (meaning all trades that executed closer to the bid than ask)
  // of all transactions that make up this alert.
  double total_bid_side_prem = 9;
  // The start time of the window of the alert
  int64 start_time = 10;
  // The end time of the window of the alert
  int64 end_time = 11;
  // Link to the alert on unusualwhales.com
  string url = 12;
  // the price of the contract
  double price = 13;
  // Boolean flag whether any transaction was part of a multi leg transaction
  bool has_multileg = 14;
  // Boolean flag whether any transaction was a iso sweep
  bool has_sweep = 15;
  // Boolean flag whether any transaction orginiated from the trading floor
  bool has_floor = 16;
  // The OI of the chain
  int32 open_interest = 17;
  // Boolean flag whether all trades are guranteed to be
  // executed to be opened. Opened is defined as when for each transaction the size > OI - (vol - size)
  // If this flag is false that means we simply do not know whether the trade was buy to open/close or
  // sell to open/close
  bool all_opening_trades = 18;
  // Unique UUID of the alert.
  string id = 19;
  // Boolean flag whether any transaction was a single leg transaction
  bool has_singleleg = 20;
  // The ratio of the option's volume to its open interest
  double volume_oi_ratio = 21;
  // The individual transaction ids that made up the alert as UUIDs.
  // If you are also consuming the topic all-option-trades you can use
  // those UUIDs to match the alert to the given single transactions and link them.
  repeated string trade_ids = 22;
  // Count of trades that made up this alert
  int32 trade_count = 23;
  // Count of unique expirations
  int32 expiry_count = 24;
  // Last executed timestamp of all transactions
  int64 executed_at = 25;
  // The sum of all sizes of the transactions where they executed closer to ask
  int64 ask_vol = 26;
  // The sum of all sizes of the transactions where they executed closer to bid
  int64 bid_vol = 27;
  // The sum of all sizes of the transactions where they were classified as no side
  int64 no_side_vol = 28;
  // The sum of all sizes of the transactions where they executed at mid
  int64 mid_vol = 29;
  // The sum of all sizes of the transactions that were part of a muti leg trade
  int64 multi_vol = 30;
  // The sum of all sizes of the transactions that were part of a stock muti leg trade
  int64 stock_multi_vol = 31;
  // All unique trade codes of the individual transactions
  repeated string upstream_condition_details = 32;
  // All unique exchanges on which the individual transactions executed
  repeated string exchanges = 33;
  // Latest bid of the chain
  string bid = 34;
  // Latest ask of the chain
  string ask = 35;
  // The implied volatility of the chain at the start of the alert window
  string ivStart = 36;
  // The implied volatility of the chain at the end of the alert window
  string ivEnd = 37;
}

// A filing published to SEC EDGAR. Insider trades (forms 3/4/5/144) and
// 13F reports are additionally published as enriched messages under their
// own keys.
message GeneralFiling {
  // the company's stock ticker symbol, if publicly listed (empty otherwise)
  string ticker = 1;
  // the company name from the filing
  string name = 2;
  // whether the company is publicly listed (true when a ticker is available)
  bool is_public_listed = 3;
  // the date the filing was published to the SEC on
  string filing_date = 4;
  // URL to the filing on SEC EDGAR
  string filing_url = 5;
  // URL to the filing's primary document
  string document_url = 6;
  // tags describing characteristics of the filing (e.g. "odd-lot")
  repeated string tags = 7;
  // the SEC form type of the filing
  string form = 8;
}

// Ticker-level greek exposures, expressed as the $ value of hedging required
// when the underlying moves one percent.
message Gex {
  // The underlying ticker.
  string ticker = 1;
  // Unix timestamp of the latest update of day.
  int64 timestamp = 2;
  // The sum of every call and put contract of (open interest * gamma * price * price), with put gamma negated.
  double gamma_per_one_percent_move_oi = 3;
  // The sum of every call and put contract of (open interest * delta * price * price).
  double delta_per_one_percent_move_oi = 4;
  // The sum of every call and put contract of (open interest * charm * price * 365), with put charm negated.
  double charm_per_one_percent_move_oi = 5;
  // The sum of every call and put contract of (open interest * vanna * price * iv), with put vanna negated.
  double vanna_per_one_percent_move_oi = 6;
  // The price of the underlying
  string price = 7;
  // The sum of every call and put contract of (volume * gamma * price * price), with put gamma negated.
  double gamma_per_one_percent_move_vol = 8;
  // The sum of every call and put contract of (volume * delta * price * price).
  double delta_per_one_percent_move_vol = 9;
  // The sum of every call and put contract of (volume * charm * price * 365), with put charm negated.
  double charm_per_one_percent_move_vol = 10;
  // The sum of every call and put contract of (volume * vanna * price), with put vanna negated.
  double vanna_per_one_percent_move_vol = 11;
  // The directional (bid is negated) sum of every call and put contract of (volume * gamma * price * price).
  double gamma_per_one_percent_move_dir = 12;
  // The directional (bid is negated) sum of every call and put contract of (volume * charm * price * 365).
  double charm_per_one_percent_move_dir = 13;
  // The directional (bid is negated) sum of every call and put contract of (volume * vanna * price * iv).
  double vanna_per_one_percent_move_dir = 14;
}

// Greek exposures for a single strike, aggregated across all expiries.
message GexStrike {
  // The underlying ticker.
  string ticker = 1;
  // Unix timestamp of the latest update of day.
  int64 timestamp = 2;
  // The sum of the (open interest * delta * contract multiplier) of every call contract.
  double call_delta_oi = 3;
  // The sum of the (open interest * delta * contract multiplier) of every put contract.
  double put_delta_oi = 4;
  // The sum of the (open interest * gamma * contract multiplier) of every call contract.
  double call_gamma_oi = 5;
  // The sum of the (open interest * gamma * contract multiplier) of every put contract.
  double put_gamma_oi = 6;
  // The sum of the (open interest * charm * contract multiplier) of every call contract.
  double call_charm_oi = 7;
  // The sum of the (open interest * charm * contract multiplier) of every put contract.
  double put_charm_oi = 8;
  // The sum of the (open interest * vanna * contract multiplier) of every call contract.
  double call_vanna_oi = 9;
  // The sum of the (open interest * vanna * contract multiplier) of every put contract.
  double put_vanna_oi = 10;
  // The sum of the (volume * delta * contract multiplier) of every call contract.
  double call_delta_vol = 11;
  // The sum of the (volume * delta * contract multiplier) of every put contract.
  double put_delta_vol = 12;
  // The sum of the (volume * gamma * contract multiplier) of every call contract.
  double call_gamma_vol = 13;
  // The sum of the (volume * gamma * contract multiplier) of every put contract.
  double put_gamma_vol = 14;
  // The sum of the (volume * charm * contract multiplier) of every call contract.
  double call_charm_vol = 15;
  // The sum of the (volume * charm * contract multiplier) of every put contract.
  double put_charm_vol = 16;
  // The sum of the (volume * vanna * contract multiplier) of every call contract.
  double call_vanna_vol = 17;
  // The sum of the (volume * vanna * contract multiplier) of every put contract.
  double put_vanna_vol = 18;
  // The strike price.
  string strike = 19;
  // The price of the underlying.
  string price = 20;
  // The sum of the (volume * gamma * contract multiplier) of every call contract traded closer to ask than bid.
  double call_gamma_ask_vol = 21;
  // The sum of the (volume * gamma * contract multiplier) of every call contract traded closer to bid than ask.
  double call_gamma_bid_vol = 22;
  // The sum of the (volume * gamma * contract multiplier) of every put contract traded closer to ask than bid.
  double put_gamma_ask_vol = 23;
  // The sum of the (volume * gamma * contract multiplier) of every put contract traded closer to bid than ask.
  double put_gamma_bid_vol = 24;
  // The sum of the (volume * charm * contract multiplier) of every call contract traded closer to ask than bid.
  double call_charm_ask_vol = 25;
  // The sum of the (volume * charm * contract multiplier) of every call contract traded closer to bid than ask.
  double call_charm_bid_vol = 26;
  // The sum of the (volume * charm * contract multiplier) of every put contract traded closer to ask than bid.
  double put_charm_ask_vol = 27;
  // The sum of the (volume * charm * contract multiplier) of every put contract traded closer to bid than ask.
  double put_charm_bid_vol = 28;
  // The sum of the (volume * vanna * contract multiplier) of every call contract traded closer to ask than bid.
  double call_vanna_ask_vol = 29;
  // The sum of the (volume * vanna * contract multiplier) of every call contract traded closer to bid than ask.
  double call_vanna_bid_vol = 30;
  // The sum of the (volume * vanna * contract multiplier) of every put contract traded closer to ask than bid.
  double put_vanna_ask_vol = 31;
  // The sum of the (volume * vanna * contract multiplier) of every put contract traded closer to bid than ask.
  double put_vanna_bid_vol = 32;
}

// Greek exposures for a single strike and expiry.
message GexStrikeExpiry {
  // The underlying ticker.
  string ticker = 1;
  // Unix timestamp of the latest update of day.
  int64 timestamp = 2;
  // The sum of the (open interest * delta * contract multiplier) of every call contract matching the strike and expiry fields.
  double call_delta_oi = 3;
  // The sum of the (open interest * delta * contract multiplier) of every put contract matching the strike and expiry fields.
  double put_delta_oi = 4;
  // The sum of the (open interest * gamma * contract multiplier) of every call contract matching the strike and expiry fields.
  double call_gamma_oi = 5;
  // The sum of the (open interest * gamma * contract multiplier) of every put contract matching the strike and expiry fields.
  double put_gamma_oi = 6;
  // The sum of the (open interest * charm * contract multiplier) of every call contract matching the strike and expiry fields.
  double call_charm_oi = 7;
  // The sum of the (open interest * charm * contract multiplier) of every put contract matching the strike and expiry fields.
  double put_charm_oi = 8;
  // The sum of the (open interest * vanna * contract multiplier) of every call contract matching the strike and expiry fields.
  double call_vanna_oi = 9;
  // The sum of the (open interest * vanna * contract multiplier) of every put contract matching the strike and expiry fields.
  double put_vanna_oi = 10;
  // The sum of the (volume * delta * contract multiplier) of every call contract matching the strike and expiry fields.
  double call_delta_vol = 11;
  // The sum of the (volume * delta * contract multiplier) of every put contract matching the strike and expiry fields.
  double put_delta_vol = 12;
  // The sum of the (volume * gamma * contract multiplier) of every call contract matching the strike and expiry fields.
  double call_gamma_vol = 13;
  // The sum of the (volume * gamma * contract multiplier) of every put contract matching the strike and expiry fields.
  double put_gamma_vol = 14;
  // The sum of the (volume * charm * contract multiplier) of every call contract matching the strike and expiry fields.
  double call_charm_vol = 15;
  // The sum of the (volume * charm * contract multiplier) of every put contract matching the strike and expiry fields.
  double put_charm_vol = 16;
  // The sum of the (volume * vanna * contract multiplier) of every call contract matching the strike and expiry fields.
  double call_vanna_vol = 17;
  // The sum of the (volume * vanna * contract multiplier) of every put contract matching the strike and expiry fields.
  double put_vanna_vol = 18;
  // The strike price.
  string strike = 19;
  // The price of the underlying.
  string price = 20;
  // The sum of the (volume * gamma * contract multiplier) of every call contract matching the strike and expiry fields that traded closer to ask than bid.
  double call_gamma_ask_vol = 21;
  // The sum of the (volume * gamma * contract multiplier) of every call contract matching the strike and expiry fields that traded closer to bid than ask.
  double call_gamma_bid_vol = 22;
  // The sum of the (volume * gamma * contract multiplier) of every put contract matching the strike and expiry fields that traded closer to ask than bid.
  double put_gamma_ask_vol = 23;
  // The sum of the (volume * gamma * contract multiplier) of every put contract matching the strike and expiry fields that traded closer to bid than ask.
  double put_gamma_bid_vol = 24;
  // The sum of the (volume * charm * contract multiplier) of every call contract matching the strike and expiry fields that traded closer to ask than bid.
  double call_charm_ask_vol = 25;
  // The sum of the (volume * charm * contract multiplier) of every call contract matching the strike and expiry fields that traded closer to bid than ask.
  double call_charm_bid_vol = 26;
  // The sum of the (volume * charm * contract multiplier) of every put contract matching the strike and expiry fields that traded closer to ask than bid.
  double put_charm_ask_vol = 27;
  // The sum of the (volume * charm * contract multiplier) of every put contract matching the strike and expiry fields that traded closer to bid than ask.
  double put_charm_bid_vol = 28;
  // The sum of the (volume * vanna * contract multiplier) of every call contract matching the strike and expiry fields that traded closer to ask than bid.
  double call_vanna_ask_vol = 29;
  // The sum of the (volume * vanna * contract multiplier) of every call contract matching the strike and expiry fields that traded closer to bid than ask.
  double call_vanna_bid_vol = 30;
  // The sum of the (volume * vanna * contract multiplier) of every put contract matching the strike and expiry fields that traded closer to ask than bid.
  double put_vanna_ask_vol = 31;
  // The sum of the (volume * vanna * contract multiplier) of every put contract matching the strike and expiry fields that traded closer to bid than ask.
  double put_vanna_bid_vol = 32;
  // The expiry date in YYYY-MM-DD format
  string expiry = 33;
}

// Aggregated delta and vega flow of option trades for a ticker, bucketed
// to the minute. Each message is a partial sum flushed roughly once per
// second. Consumers need to  add messages with the same timestamp together to get
// the full minute bucket. Values are not running daily totals.
// total_* fields carry the greek's own sign (calls positive delta, puts
// negative), so they represent net greek exposure regardless of who was
// the aggressor. dir_* fields instead sign the magnitude by trade
// sentiment: bullish trades (bought calls, sold puts) positive, bearish
// trades negative, mid/no-side trades excluded.
message GreekFlow {
  // Root underlying symbol. Index chains are normalized to their root
  // (SPXW becomes SPX, NDXP becomes NDX).
  string ticker = 1;
  // The minute bucket the trades fall into, in milliseconds since 1970 (unix).
  int64 timestamp = 2;
  // Sum of signed delta exposure: delta * contracts * 100. Decimal string.
  string total_delta_flow = 3;
  // Directional delta flow: |delta * contracts * 100| signed positive for
  // bullish trades (buy call / sell put), negative for bearish. Decimal string.
  string dir_delta_flow = 4;
  // Same as total_delta_flow but only counting OTM trades.
  string otm_total_delta_flow = 5;
  // Same as dir_delta_flow but only counting OTM trades.
  string otm_dir_delta_flow = 6;
  // Sum of vega exposure: vega * contracts * 100. Decimal string.
  string total_vega_flow = 7;
  // Directional vega flow: |vega * contracts * 100| signed positive for
  // buys (ask side), negative for sells (bid side). Decimal string.
  string dir_vega_flow = 8;
  // Same as total_vega_flow but only counting OTM trades.
  string otm_total_vega_flow = 9;
  // Same as dir_vega_flow but only counting OTM trades.
  string otm_dir_vega_flow = 10;
  // Number of option trades aggregated into this message.
  int32 transactions = 11;
  // Total contracts traded across the aggregated trades.
  int32 volume = 12;
}

// GreekFlow additionally broken out by option expiration date.
// See GreekFlow for the field semantics and aggregation behaviour.
message GreekFlowExpiry {
  // Root underlying symbol. Index chains are normalized to their root
  // (SPXW becomes SPX, NDXP becomes NDX).
  string ticker = 1;
  // The minute bucket the trades fall into, in milliseconds since 1970 (unix).
  int64 timestamp = 2;
  // Sum of signed delta exposure: delta * contracts * 100. Decimal string.
  string total_delta_flow = 3;
  // Directional delta flow: |delta * contracts * 100| signed positive for
  // bullish trades (buy call / sell put), negative for bearish. Decimal string.
  string dir_delta_flow = 4;
  // Same as total_delta_flow but only counting OTM trades.
  string otm_total_delta_flow = 5;
  // Same as dir_delta_flow but only counting OTM trades.
  string otm_dir_delta_flow = 6;
  // Sum of vega exposure: vega * contracts * 100. Decimal string.
  string total_vega_flow = 7;
  // Directional vega flow: |vega * contracts * 100| signed positive for
  // buys (ask side), negative for sells (bid side). Decimal string.
  string dir_vega_flow = 8;
  // Same as total_vega_flow but only counting OTM trades.
  string otm_total_vega_flow = 9;
  // Same as dir_vega_flow but only counting OTM trades.
  string otm_dir_vega_flow = 10;
  // The expiration date this bucket is broken out by, in YYYY-MM-DD.
  string expiry = 11;
  // Number of option trades aggregated into this message.
  int32 transactions = 12;
  // Total contracts traded across the aggregated trades.
  int32 volume = 13;
}

// aggregation of same-typed rows inside a singular insider trade filing
message InsiderTradeAgg {
  // the ticker traded by the insider in the filing
  // that company is the filing's issuer
  string ticker = 1;
  // the date the filing was published to the SEC on
  string filing_date = 2;
  // the date the filing's transactions were executed
  string transaction_date = 3;
  // the SEC filing form type
  // 3: initial statement of beneficial ownership
  // 4: statement of changes of beneficial ownership
  // 5: annual statement
  // 144: notice of proposed sale of restricted or control securities (intended sale, NOT yet completed)
  // .../A: amendment to a prior filing
  string formtype = 4;
  // the name of the reporting person owning the traded equity securities
  string owner_name = 5;
  // the reporting person's officer title in the issuer company, if any exists (e.g. CEO)
  string officer_title = 6;
  // whether the reporting person serves on the issuer's board of directors
  bool is_director = 7;
  // whether the reporting person is an officer of the issuer (e.g., CEO, CFO)
  // typically paired with an officer title field
  bool is_officer = 8;
  // whether the reporting person beneficially owns more than 10% of a class of the issuer's registered equity securities
  bool is_ten_percent_owner = 9;
  // composite transaction type:
  // NA: Non-derivative, Acquired -> insider gained common stock (a buy, grant, or vesting)
  // ND: Non-derivative, Disposed -> insider gave up common stock (a sale, gift, or withholding).
  // DA: Derivative, Acquired -> insider gained a derivative (option/warrant grant, etc.).
  // DD: Derivative, Disposed -> insider gave up a derivative (exercise, expiration, sale).
  string security_ad_code = 10;
  // type of the transaction (e.g. S=Sale, P=Purchase, A=Grant, ...)
  string transaction_code = 11;
  // the number of holdings owned before the transaction
  int64 shares_owned_before = 12;
  // the total number of holdings traded, summed across the aggregated transactions
  int64 amount = 13;
  // the number of holdings owned after the transaction
  int64 shares_owned_after = 14;
  // the amount-weighted average price per security across the aggregated transactions
  double price = 15;
  // the name of the security (e.g. "Common Stock")
  string security_title = 16;
  // whether the reporter directly or indirectly owns the equity securities
  string director_indirect = 17;
  // explains indirect ownership (e.g. "By Spouse", "By Trust")
  string natureofownership = 18;
  // date when the derivative becomes exercisable
  string date_excercisable = 19;
  // the derivative's price to exercise
  double price_excercisable = 20;
  // date when the derivative lapses
  string expiration_date = 21;
  // the primary-key ids of the raw rows of the raw aggregated insider trades
  repeated string ids = 22;
  // the amount of aggregated transactions (rows)
  int64 transactions = 23;
  // whether the transactions were part of a 10b5-1 plan
  // (prearranged trading plan, that lets insiders buy or sell at a preset schedule)
  bool is_10b5_1 = 24;
  // whether the reporting person is a public company
  bool reporter_is_public_company = 25;
  // the CIK of the reporting person
  string reporter_cik = 26;
}

// InterpolatedIv is the implied volatility and expected move calculated for a
// fixed horizon expressed in days. If a horizon lines up with a real option
// expiry the value is taken from an exact matching expiry
// (is_exact = true) and otherwise interpolated between the two surrounding expiries
// (is_exact = false).
// The interpolation is not linear in implied volatility. It is done in total
// variance space (volatility^2 * time): the surrounding terms are converted to
// total variance, then interpolated linearly there
// and then via the square root rooted back to an
// implied volatility.
// The message itself does not carry the ticker: the Kafka message key
// is the ticker of the underlying.
message InterpolatedIv {
  // The trading date in YYYY-MM-DD format
  string date = 1;
  // The number of days to the horizon this entry is interpolated to.
  // One of the standard horizons: 1, 5, 7, 14, 30, 60, 90, 180, 365.
  int32 days = 2;
  // The interpolated implied volatility at this horizon, scaled by 1000.
  // Divide by 1000 to get the decimal IV (e.g. 152000 means 0.152).
  int32 volatility = 3;
  // The expected absolute move of the underlying in dollars by this horizon,
  // scaled by 1000. Divide by 1000 to get the dollar value.
  int32 implied_move = 4;
  // The expected move as a fraction of the underlying price by this horizon,
  // scaled by 1000. Divide by 1000 to get the fractional value.
  int32 implied_move_perc = 5;
  // True if an actual option expiry matched this horizon exactly. False if
  // the value was interpolated between two surrounding expirations.
  bool is_exact = 6;
}

// IvTermStructure is the ATM implied volatility and expected move for a
// single real option expiry.
// These entries form the term structure that InterpolatedIv interpolates
// onto fixed horizons.
message IvTermStructure {
  // The ticker of the underlying
  string ticker = 1;
  // The trading date in YYYY-MM-DD format
  string date = 2;
  // The ATM implied volatility for this expiry as a decimal string,
  // taken as the average of the ATM call and put implied volatilities.
  string volatility = 3;
  // The expiry of the chain in YYYY-MM-DD
  string expiry = 4;
  // The expected absolute move of the underlying in dollars by this expiry as a decimal string.
  string implied_move = 5;
  // The expected move as a fraction of the underlying price by this expiry as a decimal string.
  string implied_move_perc = 6;
}

// A detected multi leg options spread and its classification.
message MultiLegSpread {
  // Unique id of the spread.
  string id = 1;
  // The underlying ticker's id.
  int32 ticker_id = 2;
  // The underlying ticker symbol.
  string ticker = 3;
  // The trade code shared by the legs.
  string code = 4;
  // The classified strategy.
  Strategy strategy = 5;
  // Whether the position is long or short.
  Direction direction = 6;
  // Whether the spread was a net debit (ask) or a net credit (bid).
  OptionTradeSide net_side = 7;
  // When the spread executed.
  int64 executed_at = 8;
  // The size of the spread.
  int32 size = 9;
  // How many legs the spread has.
  int32 leg_count = 10;
  // How many separately executed transactions make up this spread.
  int32 txns = 11;
  // Net price paid (positive) or received (negative) for the spread.
  string net_price = 12;
  // The spread's net delta exposure.
  string net_delta = 13;
  // The spread's net theta exposure.
  string net_theta = 14;
  // Total premium across all legs.
  string total_premium = 15;
  // The underlying price when the spread executed.
  string underlying_price = 16;
  // Shortest days to expiration among the legs.
  int32 min_dte = 17;
  // Longest days to expiration among the legs.
  int32 max_dte = 18;
  // The lowest leg strike.
  string min_strike = 19;
  // The highest leg strike.
  string max_strike = 20;
  // Whether every leg is out of the money.
  bool all_otm = 21;
  // Whether the legs use different strikes.
  bool diff_strikes = 22;
  // Whether the legs use different expirations.
  bool diff_expirations = 23;
  // Whether the legs mix calls and puts.
  bool diff_types = 24;
  // The option chain ids of the legs.
  repeated int32 option_chain_ids = 25;
  // The individual trades that make up the spread.
  repeated string trade_ids = 26;
  // The legs of the spread.
  repeated MultiLegSpreadLeg legs = 27;
  // Whether every leg opened new positions.
  bool all_opening_legs = 28;
  // The net quoted bid ask width of the spread, empty when a leg has no quote.
  string bid_ask_spread = 29;
  // The distinct exchanges the legs traded on.
  repeated string uniq_exchanges = 30;
  // The distinct leg strikes.
  repeated string strikes = 31;
  // Max profit at expiration; empty when unbounded or multi expiration.
  string max_profit = 32;
  // Max loss at expiration; empty when unbounded or multi expiration.
  string max_loss = 33;
  // Underlying prices where the expiry payoff crosses zero. Ascending empty when multi expiration.
  repeated string breakevens = 34;
  // Size weighted average implied volatility across the fills.
  string avg_iv = 35;
  // Size weighted implied volatility per distinct strike, arranged like strikes; empty entry when unknown.
  repeated string ivs = 36;
  // Net premium paid (positive) or received (negative) across all legs. Empty when direction is unknown.
  string net_premium = 37;
  // Net NBBO bid of the classified spread (buy legs at bid, sell legs at ask). Empty when direction is unknown or a leg has no quote.
  string net_bid = 38;
  // Net NBBO ask of the classified spread (buy legs at ask, sell legs at bid). Empty when direction is unknown or a leg has no quote.
  string net_ask = 39;
}

// One leg of a spread.
message MultiLegSpreadLeg {
  // The option chain's id.
  int32 option_symbol_id = 1;
  // The option symbol the leg trades.
  string option_symbol = 2;
  // Whether the leg was bought (ask) or sold (bid).
  OptionTradeSide side = 3;
  // Total contracts traded on this leg.
  int32 size = 4;
  // Average fill price for the leg.
  string price = 5;
  // The leg's delta.
  string delta = 6;
  // The leg's theta.
  string theta = 7;
  // The leg's NBBO bid.
  string ewma_nbbo_bid = 8;
  // The leg's NBBO ask.
  string ewma_nbbo_ask = 9;
  // Total premium for the leg.
  string premium = 10;
  // The chain's volume.
  int64 volume = 11;
  // The chain's open interest.
  int32 open_interest = 12;
}

// Market wide options net flow ("market tide"): the ask side vs bid side
// volume and premium of all option trades, aggregated across the whole
// market.
// Published under two message keys with the same payload:
// key market-cope carries one minute buckets and key second-market-cope
// carries one second buckets. Each message is a per interval delta.
// Consumers NEED TO sum the deltas to build cumulative series.
message NetFlow {
  // The trading date in YYYY-MM-DD format.
  string date = 1;
  // Start of the interval bucket in milliseconds since 1970 (unix).
  int64 timestamp = 2;
  // Call contracts that transacted on the ask side.
  int64 callAskVolume = 3;
  // Call contracts that transacted on the bid side.
  int64 callBidVolume = 4;
  // Premium of the ask side call trades. Decimal string.
  string callAskPremium = 5;
  // Premium of the bid side call trades. Decimal string.
  string callBidPremium = 6;
  // Put contracts that transacted on the ask side.
  int64 putAskVolume = 7;
  // Put contracts that transacted on the bid side.
  int64 putBidVolume = 8;
  // Premium of the ask side put trades. Decimal string.
  string putAskPremium = 9;
  // Premium of the bid side put trades. Decimal string.
  string putBidPremium = 10;
  // callAskVolume - callBidVolume.
  int64 netCallVolume = 11;
  // callAskPremium - callBidPremium. Decimal string.
  string netCallPremium = 12;
  // putAskVolume - putBidVolume.
  int64 netPutVolume = 13;
  // putAskPremium - putBidPremium. Decimal string.
  string netPutPremium = 14;
  // Out of the money only variant of callAskVolume.
  int64 otmCallAskVolume = 15;
  // Out of the money only variant of callBidVolume.
  int64 otmCallBidVolume = 16;
  // Out of the money only variant of callAskPremium. Decimal string.
  string otmCallAskPremium = 17;
  // Out of the money only variant of callBidPremium. Decimal string.
  string otmCallBidPremium = 18;
  // Out of the money only variant of putAskVolume.
  int64 otmPutAskVolume = 19;
  // Out of the money only variant of putBidVolume.
  int64 otmPutBidVolume = 20;
  // Out of the money only variant of putAskPremium. Decimal string.
  string otmPutAskPremium = 21;
  // Out of the money only variant of putBidPremium. Decimal string.
  string otmPutBidPremium = 22;
  // Out of the money only variant of netCallVolume.
  int64 otmNetCallVolume = 23;
  // Out of the money only variant of netCallPremium. Decimal string.
  string otmNetCallPremium = 24;
  // Out of the money only variant of netPutVolume.
  int64 otmNetPutVolume = 25;
  // Out of the money only variant of netPutPremium. Decimal string.
  string otmNetPutPremium = 26;
  // Not populated for the market wide tide keys.
  string ticker = 27;
}

// An option contract with all its meta data.
message OptionChain {
  // Unique id of the option contract.
  int32 id = 1;
  // OSI option symbol, e.g. AAPL260116C00150000.
  string option_symbol = 2;
  // Strike price in thousandths of a dollar.
  int32 strike = 3;
  // Underlying ticker of the contract (e.g. SPXW, not the root SPX).
  Ticker ticker = 4;
  // Expiration date in YYYY-MM-DD.
  string expiry = 5;
  // Call or put.
  OptionType type = 6;
  // Root ticker of the contract (equals ticker for stocks, parent index for
  // index options).
  Ticker root_ticker = 7;
  // True when options appear for this ticker for the first time, i.e. it had
  // no other active (non-expired) chains loaded when this chain was created.
  bool first_time_options_today = 8;
  // True when this contract was newly created (it did not exist before).
  bool created_today = 9;
}

// Daily stats for Option contracts for the given date.
// Contracts are being pushed any time there is a volume
// or open interest update is available.
message OptionState {
  // The option symbol in OSI format SPY241227C00480000
  string option_symbol = 1;
  // Internal, ignore.
  int32 channel_id = 2;
  // Current ask
  string nbbo_ask = 3;
  // Current ask size
  int64 nbbo_ask_size = 4;
  // Current bid
  string nbbo_bid = 5;
  // Current bid size
  int64 nbbo_bid_size = 6;
  // Timestamp in milliseconds that this data represents
  int64 last_tape_time = 7;
  // The trading date in YYYY-MM-DD format
  string date = 8;
  // The OI of the chain
  int32 open_interest = 9;
  // The cumulative volume for the day till this tape time.
  // Note the volume between 2 ticks can be lower and does not necessary
  // increase all the time if there was a cancel.
  // A chain might have 10,000 volume at 9:32 and then at 9:33
  // it might have 8,000 volume as a transaction with the size of 2,000
  // had been canceled. The canceled volume is also tracked in the canceled field.
  int64 volume = 10;
  // The expiry of the chain in YYYY-MM-DD
  string expires = 11;
  // The option type either call or put
  string option_type = 12;
  // The ticker of the chain. Note this is not the root symbol:
  // For instance for NDXP260116C25250000 the underlying symbol would be
  // NDXP and not NDX.
  string underlying_symbol = 13;
  // The strike as a decimal number.
  string strike = 14;
  // The highest price at which there was a trade for the chain
  // for the current trading day
  string high_price = 15;
  // The lowest price at which there was a trade for the chain
  // for the current trading day
  string low_price = 16;
  // The last price at which a trade executed for this chain
  string last_price = 17;
  // Iv for the contract
  string implied_volatility = 18;
  // Delta for the contract
  string delta = 19;
  // Theta for the contract
  string theta = 20;
  // Gamma for the contract
  string gamma = 21;
  // Vega for the contract
  string vega = 22;
  // Rho for the contract
  string rho = 23;
  // Theo for the contract
  string theo = 24;
  // Iv low for the contract for the session
  string iv_low = 25;
  // Iv high for the contract for the session
  string iv_high = 26;
  // Total amount of volume that came based on trade codes from the floor.
  // If there is a canceled transaction this field is as of now not being adjusted.
  int64 floor_volume = 27;
  // Total amount of volume that based on trade codes was part of a multi leg trade.
  // If there is a canceled transaction this field is as of now not being adjusted.
  int64 multi_leg_volume = 28;
  // Total amount of volume that based on trade codes was part of a stock multi leg trade.
  // If there is a canceled transaction this field is as of now not being adjusted.
  int64 stock_multi_leg_volume = 29;
  // Total amount of volume that based on trade codes was part of a cross trade.
  // If there is a canceled transaction this field is as of now not being adjusted.
  int64 cross_volume = 30;
  // Total amount of volume that based on trade codes was based on sweep transactions.
  // If there is a canceled transaction this field is as of now not being adjusted.
  int64 sweep_volume = 31;
  // Count of all transactions
  int64 trades = 32;
  // Total amount of volume that transacted on the ask side of the spread.
  // If there is a canceled transaction this field is as of now not being adjusted.
  int64 ask_volume = 33;
  // Total amount of volume that transacted on the bid side of the spread.
  // If there is a canceled transaction this field is as of now not being adjusted.
  int64 bid_volume = 34;
  // Total amount of volume that transacted on the mid side of the spread.
  // If there is a canceled transaction this field is as of now not being adjusted.
  int64 mid_volume = 35;
  // Total amount of volume that has been marked as neutral (cross, out of sequence, late)
  // If there is a canceled transaction this field is as of now not being adjusted.
  int64 neutral_volume = 36;
  // Total amount of NBBO bid changes of this chain. This can be used
  // as a potential volatility proxy.
  int64 total_bid_changes = 37;
  // Total amount of NBBO ask changes of this chain. This can be used
  // as a potential volatility proxy.
  int64 total_ask_changes = 38;
  // Total amount of volume of transactions that had been canceled
  int64 canceled_volume = 39;
  // Total amount of premium that transacted
  string total_premium = 40;
  // Volume weighted avg price of all transactions
  string avg_price = 41;
  // The first price at which a trade transacted for this chain.
  string open_price = 42;
  // Unique id for the option symbol
  int32 option_symbol_id = 43;
  // Unique id for the underlying symbol. These IDs are consistent
  // across different topics and can be used to merge data together.
  int32 ticker_id = 44;
  // Unique ID for the root ticker. In most cases root_ticker_id
  // will be the same as ticker_id but for chains like
  // SPXW260109P06810000 ticker_id would be the ID for SPXW and
  // root_ticker_id would be the id for SPX.
  int32 root_ticker_id = 45;
}

// A single executed option trade with its NBBO, greeks, volume breakdown
// and underlying metadata at the time of the trade.
message OptionTrade {
  // Unique UUID of the trade.
  string id = 1;
  // The underlying ticker symbol.
  string underlying_symbol = 2;
  // The time at which the trade executed in milliseconds since 1970 (unix)
  int64 executed_at = 3;
  // The NBBO bid at the time of the trade.
  string nbbo_bid = 4;
  // The NBBO ask at the time of the trade.
  string nbbo_ask = 5;
  // The size of the trade in number of contracts.
  int32 size = 6;
  // The price at which the trade executed.
  string price = 7;
  // OptionSymbol in the OSI format, SPY241227C00480000
  string option_chain_id = 8;
  // Deprecated, don't use
  string alert_score = 9;
  // The time the trade record was created in milliseconds since 1970 (unix)
  int64 created_at = 10;
  // Trade report flags from the upstream feed.
  repeated string report_flags = 11;
  // Classification tags assigned to the trade.
  repeated string tags = 12;
  // The expiration date of the option contract.
  string expiry = 13;
  // The option type, call or put.
  string option_type = 14;
  // The OI of the chain
  int32 open_interest = 15;
  // The strike price of the option contract.
  string strike = 16;
  // The premium of the trade (size * price * contract multiplier).
  string premium = 17;
  // The total market volume of the option symbol at the time of the trade.
  int64 volume = 19;
  // The price of the underlying at the time of the trade.
  string underlying_price = 20;
  // The EWMA smoothed NBBO ask.
  string ewma_nbbo_ask = 21;
  // The EWMA smoothed NBBO bid.
  string ewma_nbbo_bid = 22;
  // The implied volatility of the option.
  string implied_volatility = 23;
  // The delta of the option.
  string delta = 24;
  // The theta of the option.
  string theta = 25;
  // The gamma of the option.
  string gamma = 26;
  // The vega of the option.
  string vega = 27;
  // The rho of the option.
  string rho = 28;
  // The theoretical price of the option.
  string theo = 29;
  // The upstream trade code of the transaction.
  string upstream_cond_details = 30;
  // Deprecated, dont use
  int32 market_center_locate = 31;
  // The exchange on which the trade executed.
  string exchange = 32;
  // The total ask side volume of the option symbol at the time of the trade.
  int64 ask_vol = 33;
  // The total bid side volume of the option symbol at the time of the trade.
  int64 bid_vol = 34;
  // The total no side volume of the option symbol at the time of the trade.
  int64 no_side_vol = 35;
  // The total mid volume of the option symbol at the time of the trade.
  int64 mid_vol = 36;
  // The total multi leg volume of the option symbol at the time of the trade.
  int64 multi_vol = 37;
  // The total stock multi leg volume of the option symbol at the time of the trade.
  int64 stock_multi_vol = 38;
  // Internal unique ID for the option contract.
  int32 option_symbol_id = 39;
  // Internal unique ID for the given ticker.
  int32 ticker_id = 40;
  // Internal unique ID for the root ticker (indices).
  int32 root_ticker_id = 41;
  // Information about the ticker such as sector, industry, next earnings date and more.
  optional TickerInfo ticker_info = 42;
}

// A potential insider signal: a fresh, low-activity account taking an
// unusually large position in a single market. Published to the
// `predictions-insiders` Kafka topic each time insider detection runs;
// an existing signal is re-published when its underlying position changes.
// A position is flagged when all of the following hold:
//   - its cost basis is at least $1,000, at an average entry price of at
//     most $0.90 per share, and its realized loss is no worse than -$100
//   - the account holds fewer than 5 distinct positions
//   - the account's first observed trade was fewer than 20 days ago
message PredictionsInsider {
  // Internal numeric id of the flagged user's wallet. Same id space as
  // PredictionsTrade.maker_id/taker_id and PredictionsPosition.user_id.
  int64 user_id = 1;
  // Internal numeric id of the outcome token the position is in. Same id
  // space as PredictionsTrade.asset_id and PredictionsPosition.asset_id.
  int64 asset_id = 2;
  // Internal numeric id of the market (question) the token belongs to.
  int64 question_id = 3;
  // Number of distinct outcome tokens the user holds positions in,
  // across all markets. Always fewer than 5 by construction.
  int32 n_positions = 4;
  // Days since the user's first observed trade. Always fewer than 20
  // by construction.
  int32 days_since_first_trade = 5;
  // USDC the user invested in this token (cost basis of the position).
  Decimal total_invested_usd = 6;
  // User's average entry price per share, in USDC (between 0 and 1).
  Decimal avg_price = 7;
  // Mean invested USDC across all positions held in this token — the
  // market baseline the user is compared against.
  Decimal mean_invested_usd = 8;
  // Population standard deviation of invested USDC across all positions
  // held in this token.
  Decimal std_invested_usd = 9;
  // How unusual the position size is versus the market baseline:
  // (total_invested_usd - mean_invested_usd) / std_invested_usd, or 0
  // when std_invested_usd is 0. Values >= 2.0 are treated as strong
  // insider signals.
  Decimal invested_zscore = 10;
  // Category of the market's question.
  Category category = 11;
  // Polymarket username of the user, when known.
  optional string username = 12;
  // Text of the market's question (e.g. "Will X win the election?"),
  // when known.
  optional string question = 13;
  // Label of the outcome the position is on (e.g. "Yes"), when known.
  optional string outcome_label = 14;
  // User wallet address (0x-prefixed hex), when known.
  optional string user_address = 15;
  // Polymarket CTF (ERC-1155) token id of the outcome token, as a
  // decimal string. Matches PredictionsTrade.asset_address and
  // PredictionsPosition.asset_address.
  optional string token_id = 16;
  // User's realized profit or loss on this token so far, in USDC.
  Decimal realized_pnl = 17;
}

// Snapshot of a user's position in a single outcome token, published to
// the `predictions-positions` Kafka topic every time the position changes
// on-chain. Each message carries the full new state of the position, not
// a delta.
// Prices and USD amounts are denominated in USDC; token amounts are in
// outcome tokens (shares), where one winning share redeems for $1.
message PredictionsPosition {
  // Internal numeric id of the user's wallet. Same id space as
  // PredictionsTrade.maker_id/taker_id and PredictionsInsider.user_id.
  int64 user_id = 1;
  // Internal numeric id of the outcome token. Same id space as
  // PredictionsTrade.asset_id and PredictionsInsider.asset_id.
  int64 asset_id = 2;
  // User wallet address (0x-prefixed hex).
  string user_address = 3;
  // Polymarket CTF (ERC-1155) token id of the outcome token, as a decimal
  // string. Note: despite the name this is a token id, not a 0x contract
  // address. It matches PredictionsTrade.asset_address and
  // PredictionsInsider.token_id.
  string asset_address = 4;
  // Outcome tokens (shares) currently held.
  Decimal amount = 5;
  // Average entry price per share of the current holding, in USDC
  // (between 0 and 1).
  Decimal avg_price = 6;
  // Cost basis of the current holding, in USDC (amount * avg_price).
  Decimal invested_usd = 7;
  // Cumulative realized profit or loss from sells and redemptions of
  // this token, in USDC.
  Decimal realized_pnl = 8;
  // Cumulative shares of this token ever bought. Unlike `amount`, this
  // does not decrease when shares are sold.
  Decimal total_bought = 9;
  // Cumulative USDC ever spent buying this token. Unlike `invested_usd`,
  // this does not decrease when shares are sold.
  Decimal total_invested_usd = 10;
  // Currently not populated (always 0). Reserved for the time the
  // position was last updated.
  int64 updated_at = 11;
  // Approximate time of the user's first trade in this token, Unix epoch
  // milliseconds, UTC. Estimated from the block number using the average
  // Polygon block time, so it can drift by a few minutes.
  optional int64 first_traded_at = 12;
  // Polygon block number at which this position state took effect.
  // In this stream it equals block_start.
  int64 last_block = 13;
  // First Polygon block of the range in which this position state is
  // valid (inclusive).
  int64 block_start = 14;
  // Last Polygon block of the validity range (exclusive). 0 while this
  // is the latest state of the position.
  int64 block_end = 15;
}

// A single fill on the Polymarket CTF exchange, published to the
// `predictions-trades` Kafka topic as trades are ingested from the chain.
// One on-chain transaction can contain several fills; each fill is
// published as its own message.
// The buyer side's amount is the USDC premium and the seller side's
// amount is the number of outcome tokens, so the price per share is
// `buyer amount / seller amount`.
message PredictionsTrade {
  // Internal numeric id of the maker's wallet. Ids are stable and shared
  // across all predictions messages (PredictionsPosition.user_id,
  // PredictionsInsider.user_id, ...).
  int64 maker_id = 1;
  // Internal numeric id of the taker's wallet.
  int64 taker_id = 2;
  // Internal numeric id of the outcome token being traded. Same id space
  // as PredictionsPosition.asset_id and PredictionsInsider.asset_id.
  int64 asset_id = 3;
  // Maker wallet address (0x-prefixed hex).
  string maker_address = 4;
  // Taker wallet address (0x-prefixed hex).
  string taker_address = 5;
  // Polymarket CTF (ERC-1155) token id of the outcome token, as a decimal
  // string. Note: despite the name this is a token id, not a 0x contract
  // address. It matches PredictionsInsider.token_id and
  // PredictionsPosition.asset_address.
  string asset_address = 6;
  // When the fill executed on-chain. Unix epoch milliseconds, UTC.
  int64 executed_at = 7;
  // Exchange fee charged on this fill, in USDC.
  Decimal fee = 8;
  // Amount the maker gave up: USDC if maker_side is BUYER, outcome
  // tokens if maker_side is SELLER.
  Decimal maker_amount_filled = 9;
  // Amount the taker gave up: USDC if taker_side is BUYER, outcome
  // tokens if taker_side is SELLER.
  Decimal taker_amount_filled = 10;
  // Whether the maker bought or sold the outcome token.
  Side maker_side = 11;
  // Whether the taker bought or sold the outcome token. Always the
  // opposite of maker_side.
  Side taker_side = 12;
  // Hash of the Polygon transaction containing this fill
  // (0x-prefixed hex).
  string transaction_hash = 13;
}

// RiskReversalSkew captures the volatility skew between puts and calls at a given
// delta for a single expiry for a given ticker.
// NOTE: The ticker is not part of the message. The ticker is the key
// of the kafka msg.
message RiskReversalSkew {
  // The trading date as days since 1970-01-01
  uint32 date = 1;
  // The expiry of the chain as days since 1970-01-01
  uint32 expiry = 2;
  // The put implied volatility minus the call implied volatility at the given
  // delta. A positive value means puts are more expensive than calls
  double skew = 3;
  // The delta bucket as a whole number out of 100. 25 means the 0.25
  // delta and 10 means the 0.10 delta.
  uint32 delta = 4;
}

// Options net flow aggregated per sector. Same field semantics as NetFlow:
// net means ask side minus bid side, otm fields count OTM
// contracts only, and each message is a per interval delta.
message SecIndst {
  // The trading date in YYYY-MM-DD format.
  string date = 1;
  // Start of the interval bucket in milliseconds since 1970 (unix).
  int64 timestamp = 2;
  // Call contracts that transacted on the ask side.
  int64 callAskVolume = 3;
  // Call contracts that transacted on the bid side.
  int64 callBidVolume = 4;
  // Premium of the ask side call trades. Decimal string.
  string callAskPremium = 5;
  // Premium of the bid side call trades. Decimal string.
  string callBidPremium = 6;
  // Put contracts that transacted on the ask side.
  int64 putAskVolume = 7;
  // Put contracts that transacted on the bid side.
  int64 putBidVolume = 8;
  // Premium of the ask side put trades. Decimal string.
  string putAskPremium = 9;
  // Premium of the bid side put trades. Decimal string.
  string putBidPremium = 10;
  // callAskVolume - callBidVolume.
  int64 netCallVolume = 11;
  // callAskPremium - callBidPremium. Decimal string.
  string netCallPremium = 12;
  // putAskVolume - putBidVolume.
  int64 netPutVolume = 13;
  // putAskPremium - putBidPremium. Decimal string.
  string netPutPremium = 14;
  // Out of the money only variant of callAskVolume.
  int64 otmCallAskVolume = 15;
  // Out of the money only variant of callBidVolume.
  int64 otmCallBidVolume = 16;
  // Out of the money only variant of callAskPremium. Decimal string.
  string otmCallAskPremium = 17;
  // Out of the money only variant of callBidPremium. Decimal string.
  string otmCallBidPremium = 18;
  // Out of the money only variant of putAskVolume.
  int64 otmPutAskVolume = 19;
  // Out of the money only variant of putBidVolume.
  int64 otmPutBidVolume = 20;
  // Out of the money only variant of putAskPremium. Decimal string.
  string otmPutAskPremium = 21;
  // Out of the money only variant of putBidPremium. Decimal string.
  string otmPutBidPremium = 22;
  // Out of the money only variant of netCallVolume.
  int64 otmNetCallVolume = 23;
  // Out of the money only variant of netCallPremium. Decimal string.
  string otmNetCallPremium = 24;
  // Out of the money only variant of netPutVolume.
  int64 otmNetPutVolume = 25;
  // Out of the money only variant of netPutPremium. Decimal string.
  string otmNetPutPremium = 26;
  // The lower cased sector name, e.g. "technology", "financial services",
  // "consumer cyclical".
  string key = 27;
}

// A summary of an institution's quarterly 13F report: position counts,
// bought/sold values and the top holdings by category.
message ThirteenFAlert {
  // the name of the filing institution
  string name = 1;
  // the short name of the filing institution (e.g. 'Vanguard' for 'VANGUARD GROUP INC')
  string short_name = 2;
  // the CIK of the filing institution
  string cik = 3;
  // tags associated with the institution (e.g. hedge-fund)
  repeated string tags = 4;
  // people associated with the institution (e.g. 'Bill Ackman' for 'PERSHING SQUARE CAPITAL MANAGEMENT, L.P.')
  repeated string people = 5;
  // number of distinct stock/fund positions in the institution's latest 13F report
  int64 stock_positions = 6;
  // number of existing positions the institution added to this quarter
  // (units increased, not new positions)
  int64 stock_added_to_positions = 7;
  // number of positions the institution reduced but still holds this quarter
  // (units decreased, remaining units > 0)
  int64 stock_reduced_positions = 8;
  // number of new positions the institution opened this quarter
  int64 stock_new_positions = 9;
  // number of positions the institution fully exited this quarter (remaining units == 0)
  int64 stock_closed_positions = 10;
  // total USD value of shares bought this quarter
  int64 stock_buy_avg_weighted_prem = 11;
  // total USD value of shares sold this quarter
  int64 stock_sell_avg_weighted_prem = 12;
  // tickers (stocks only) of the ten largest currently-held positions, by reported value
  repeated string top_ten_holdings = 13;
  // the filing's report period end date
  string report_date = 14;
  // the institution's own stock ticker, if it is itself a public company with options (empty otherwise)
  string ticker = 15;
  // tickers (stocks only) of the ten largest positions fully exited this quarter, by sold value
  repeated string top_ten_closed_holdings = 16;
  // tickers (stocks only) of the ten largest newly-opened positions this quarter, by reported value
  repeated string top_ten_new_holdings = 17;
  // tickers (stocks only) of the ten largest added-to positions this quarter, by bought value
  repeated string top_ten_added_holdings = 18;
  // tickers (stocks only) of the ten largest reduced (but still held) positions this quarter, by sold value
  repeated string top_ten_reduced_holdings = 19;
  // total USD value of all reported 13F holdings (across all security types)
  // REMARK: since options are reported with their notional value, any instituion that holds options
  // will/might have a very bloated up total value that does not really represent the actual value they hold. Use this value with care.
  int64 total_value = 20;
  // total USD value of share and fund holdings only (excludes options, warrants, debt, etc.)
  int64 share_value = 21;
  // whether the institution holds put/call options
  bool holds_options = 22;
  // URL to the filing on SEC EDGAR
  string document_url = 23;
}

// A ticker symbol of any kind (stock, etf, index, option underlying, ...).
message Ticker {
  // Unique id of the ticker.
  int32 id = 1;
  // Ticker symbol, e.g. AAPL or SPXW.
  string ticker = 2;
  // Issue type (stock, etf, index, ...). Absent when not yet classified.
  optional IssueType issue_type = 3;
  // True when options appear for this ticker for the first time, i.e. it had
  // no other active (non-expired) chains loaded when this chain was created.
  bool first_time_options_today = 4;
}

// Company/ticker metadata for an underlying symbol.
message TickerInfo {
  // Date of the next scheduled earnings report.
  optional Date next_earnings_date = 1;
  // Date of the next ex-dividend.
  optional Date next_dividend_date = 2;
  // Security classification (common stock, ETF, ADR, index, etc.).
  optional IssueType issue_type = 3;
  // When earnings are announced relative to market hours (pre/post market).
  optional AnnounceTime announce_time = 4;
  // Industry classification of the company.
  optional string industry_type = 5;
  // Sector classification of the company.
  optional Sector sector = 6;
  // Market capitalization.
  optional Decimal marketcap = 7;
  // 52 week high price, split-adjusted only.
  optional Decimal week52_high_split_adjustonly = 8;
  // 52 week low price, split-adjusted only.
  optional Decimal week52_low_split_adjustonly = 9;
  // Average daily share volume over the last 30 days.
  optional Decimal avg30_volume = 10;
  // Whether the underlying has listed options.
  bool has_options = 11;
  // Average daily call option volume over the last 30 days.
  optional Decimal call_vol_30d = 12;
  // Average daily put option volume over the last 30 days.
  optional Decimal put_vol_30d = 13;
  // Short interest as a percent of float.
  optional Decimal short_int = 14;
  // Whether the underlying is tagged as a China-exposed name.
  bool is_china = 15;
  // Whether the underlying is a volatility product (e.g. VIX-related).
  bool is_volatility = 16;
}

// Aggregated options activity of a ticker over a 5 minute interval:
// call/put volumes split by trade side and trade type, net premium,
// greek flows and an IV snapshot at the interval open and close.
// All values are per interval, not running daily totals. This also applies
// to the cum_net_*_delta fields despite their name. The All and OtmOnly
// variants are published as separate messages.
// The message itself does not carry the ticker: the Kafka message key
// is the ticker of the underlying.
message TickerInterval {
  // Whether this interval counts all trades or OTM trades only.
  IntervalType interval_type = 1;
  // Start of the 5 minute interval in milliseconds since 1970 (unix).
  int64 start_time = 2;
  // Execution time of the latest trade in the interval in milliseconds
  // since 1970 (unix).
  int64 tape_time = 3;
  // Call contracts traded in the interval.
  int32 call_vol = 4;
  // Put contracts traded in the interval.
  int32 put_vol = 5;
  // Number of trades in the interval.
  int32 transactions = 6;
  // Call contracts that transacted on the ask side.
  int32 call_vol_ask_side = 7;
  // Call contracts that transacted on the bid side.
  int32 call_vol_bid_side = 8;
  // Call contracts that transacted at the mid or without a side.
  int32 call_vol_neutral_side = 9;
  // Put contracts that transacted on the ask side.
  int32 put_vol_ask_side = 10;
  // Put contracts that transacted on the bid side.
  int32 put_vol_bid_side = 11;
  // Put contracts that transacted at the mid or without a side.
  int32 put_vol_neutral_side = 12;
  // Call contracts that were part of sweep transactions.
  int32 call_sweep_vol = 13;
  // Put contracts that were part of sweep transactions.
  int32 put_sweep_vol = 14;
  // Call contracts that came from the floor.
  int32 call_floor_vol = 15;
  // Put contracts that came from the floor.
  int32 put_floor_vol = 16;
  // Call contracts that were part of cross transactions.
  int32 call_cross_vol = 17;
  // Put contracts that were part of cross transactions.
  int32 put_cross_vol = 18;
  // Call contracts that were part of multi leg or stock multi leg trades.
  int32 call_multi_vol = 19;
  // Put contracts that were part of multi leg or stock multi leg trades.
  int32 put_multi_vol = 20;
  // Net directional call delta: ask side delta flow minus bid side
  // delta flow. Cumulative for the interval not the day.
  int64 cum_net_call_delta = 30;
  // Net directional put delta: ask side delta flow minus bid side
  // delta flow. Cumulative for the interval not the day.
  int64 cum_net_put_delta = 31;
  // Size weighted average days to expiry. Decimal string.
  string avg_dte = 32;
  // Average percent OTM as a fraction. Decimal string.
  string avg_otm = 33;
  // Average trade size in contracts. Decimal string.
  string avg_size = 34;
  // Average trade premium in dollars. Decimal string.
  string avg_prem = 35;
  // Net call premium in whole dollars: ask side positive, bid side
  // negative. Each trade is capped at +-2,000,000.
  int32 net_call_prem = 36;
  // Net put premium in whole dollars: ask side positive, bid side
  // negative. Each trade is capped at +-2,000,000.
  int32 net_put_prem = 37;
  // The price of the underlying at the first trade of the interval.
  // Decimal string.
  string open = 40;
  // The price of the underlying at the last trade of the interval.
  // Decimal string.
  string close = 41;
  // The 30 day interpolated implied move fraction at the interval open,
  // scaled by 1000.
  int32 implied_move_perc_30d_open = 42;
  // The 30 day interpolated implied move fraction at the interval close,
  // scaled by 1000.
  int32 implied_move_perc_30d_close = 43;
  // The 30 day interpolated implied volatility at the interval open,
  // scaled by 1000.
  int32 volatility_30d_open = 44;
  // The 30 day interpolated implied volatility at the interval close,
  // scaled by 1000.
  int32 volatility_30d_close = 45;
  // Unsigned delta flow of the interval: delta * contracts * 100.
  int64 delta_flow = 46;
  // Unsigned gamma flow of the interval: gamma * contracts * 100.
  int64 gamma_flow = 47;
  // Unsigned vega flow of the interval: vega * contracts * 100.
  int64 vega_flow = 48;
  // Delta flow signed by trade side: ask positive, bid negative.
  int64 dir_delta_flow = 49;
  // Gamma flow signed by trade side: ask positive, bid negative.
  int64 dir_gamma_flow = 50;
  // Vega flow signed by trade side: ask positive, bid negative.
  int64 dir_vega_flow = 51;
}

// OHLCV state of a stock for the current trading session. Open, close, high and low are
// scoped to the current market_time session: a new state
// starts when the session changes (premarket to regular to postmarket).
message TickerStockState {
  // The stock symbol. Also the Kafka message key.
  string ticker = 1;
  // Cumulative shares traded for the whole day so far, across all sessions.
  int64 total_volume = 2;
  // Snapshot of total_volume at the start of the current market_time
  // session. 0 during premarket.
  int64 start_total_volume = 3;
  // Shares traded within the current market_time session only
  // (total_volume - start_total_volume).
  int64 volume = 4;
  // First trade price of the current session.
  double open = 5;
  // Most recent trade price of the current session.
  double close = 6;
  // Highest trade price of the current session.
  double high = 7;
  // Lowest trade price of the current session.
  double low = 8;
  // Execution time of the latest trade in milliseconds since 1970 (unix).
  int64 tape_time = 9;
  // The New York trading date in YYYY-MM-DD format.
  string date = 10;
  // The trading session this state belongs to.
  MarketTime market_time = 13;
}

// The consolidated stock tape
message TradeReport {
  // The ticker symbol the trade is for.
  string symbol = 1;
  // The market center where the trade executed.
  // Can be one of:
  // 1. Q => Nasdaq Stock Market (lit)
  // 2. L or 2 => TRF (dark pool/off lit)
  // 3. B or X => lit
  string market_center = 2;
  // Security class code
  string security_class = 3;
  // Identifier the upstream feed assigns to this trade message. Trade cancellations and
  // corrections reference this same control number (see TradeCancel) to point back at the original print.
  string control_number = 4;
  // The price at which the trade executed
  string price = 5;
  // The size of the trade. At the time of writing this
  // there are no fractional trades but they are planned to go live
  // this year (2026). In that case the protobuf will be extended with
  // a new field that will have the fractional shares value.
  int32 size = 6;
  // The consolidated volume across all market places till now.
  // This volume represents the total volume you see across websites,
  // tv and on your broker.
  int64 volume = 7;
  // Deprecated: do not use, use trade_settlement_enum instead.
  // The settlement type as a lower case string (e.g. "regular", "cash", "next_day", "seller").
  string trade_settlement = 8;
  // Deprecated: do not use, use trade_code_enum instead.
  // The trade code as a lower case string (e.g. "opening_print"), or "empty" when the trade has none.
  string trade_code = 9;
  // Deprecated: do not use, use ext_hour_sold_codes_enum instead.
  // The extended hours/sold code as a lower case string, or "empty" when the trade has none.
  string ext_hour_sold_codes = 10;
  // Deprecated: do not use, use sale_cond_codes_enum instead.
  // The special sale condition code as a lower case string, or "empty" when the trade has none.
  string sale_cond_codes = 11;
  // The time at which the trade executed in milliseconds since 1970 (unix)
  int64 executed_at = 12;
  // Internal tracking id of the trade
  int64 tracking_id = 13;
  // Deprecated: do not use, use ticker_info.issue_type instead, which is a well defined enum.
  string issue_type = 14;
  // The bid at the time of the trade. Note that when TRF trades
  // are being pushed the BID does not represent the bid at the time
  // of the TRF (off lit) trade but rather the bid at the time the TRF trade
  // hit the tape.
  string nbbo_bid = 15;
  // The ask at the time of the trade. Note that when TRF trades
  // are being pushed the BID does not represent the ask at the time
  // of the TRF (off lit) trade but rather the ask at the time the TRF trade
  // hit the tape.
  string nbbo_ask = 16;
  // The number of shares available at the NBBO bid at the time of the trade.
  // The same TRF caveat as nbbo_bid applies.
  int64 nbbo_bid_quantity = 17;
  // The number of shares available at the NBBO ask at the time of the trade.
  // The same TRF caveat as nbbo_ask applies.
  int64 nbbo_ask_quantity = 18;
  // A boolean flag whether this trade is eligible for updating the open,
  // high, low and close of a stock for the trading day. If you are using this data
  // to build the daily OHLC of a stock live then you need to respect this flag
  // as there is a lot of trades that are not eligible for updating the OHLC data.
  bool updates_high_low = 19;
  // The settlement type as a typed enum.
  TradeSettlement trade_settlement_enum = 20;
  // The trade code as a typed enum (an *_EMPTY value when the trade has none).
  TradeCodes trade_code_enum = 21;
  // The extended hours/sold code as a typed enum (an *_EMPTY value when the trade has none).
  ExthourSoldCodes ext_hour_sold_codes_enum = 22;
  // The special sale condition code as a typed enum (an *_EMPTY value when the trade has none).
  SpecialSaleConditionsCodes sale_cond_codes_enum = 23;
  // Internal unique ID for the given ticker at UW.
  int32 ticker_id = 24;
  // For TRF (off lit) trades, the time the trade actually executed, in milliseconds since 1970 (unix).
  // This differs from executed_at, which is when the trade hit the consolidated tape, only set for TRF prints.
  int64 trf_executed_at = 25;
  // Information about the ticker such as sector, industry, next earnings date and more.
  TickerInfo ticker_info = 26;
}

// A trading halt, pause or resumption for a stock.
message TradingState {
  // The symbol of the halted or resumed stock.
  string ticker = 1;
  // The trading state: halt, pause, quote_only_period or trading.
  string state = 2;
  // Halt or resume reason, e.g. "Volatility Trading Pause"
  // or "Halt News Pending". Empty when no reason was given.
  string reason = 3;
  // The time of the state change in milliseconds since 1970 (unix).
  int64 time = 4;
  // Currently not populated.
  string sector = 5;
  // Currently not populated.
  string marketcap = 6;
  // Currently not populated.
  string avg_vol_30 = 7;
  // Currently not populated.
  int64 curr_vol = 8;
}