types.hpp

Go to the documentation of this file.

#pragma once
 
#include "decimal.hpp"
#include <map>
#include <optional>
#include <vector>
 
namespace longbridge {
 
struct Date
{
  int32_t year;
  uint8_t month;
  uint8_t day;
};
 
struct Time
{
  uint8_t hour;
  uint8_t minute;
  uint8_t second;
};
 
struct DateTime
{
  Date date;
  Time time;
};
 
enum class Language
{
  ZH_CN,
  ZH_HK,
  EN,
};
 
enum class PushCandlestickMode
{
  Realtime,
  Confirmed,
};
 
enum class Market
{
  Unknown,
  US,
  HK,
  CN,
  SG,
  Crypto,
};
 
namespace quote {
 
enum class TradeStatus;
 
class SubFlags
{
private:
  uint8_t value_;
 
public:
  inline SubFlags(uint8_t value) { value_ = value; }
 
  inline operator uint8_t() const { return value_; }
 
  inline SubFlags operator|(const SubFlags& other) const
  {
    return SubFlags(value_ | other.value_);
  }
 
  inline SubFlags& operator|=(const SubFlags& other)
  {
    value_ |= other.value_;
    return *this;
  }
 
  inline SubFlags operator&(const SubFlags& other) const
  {
    return SubFlags(value_ & other.value_);
  }
 
  inline SubFlags& operator&=(const SubFlags& other)
  {
    value_ &= other.value_;
    return *this;
  }
 
  inline bool operator==(const SubFlags& other) const
  {
    return value_ == other.value_;
  }
 
  inline bool contains(const SubFlags& other) const
  {
    return (value_ & other.value_) > 0;
  }
 
  static SubFlags QUOTE();
  static SubFlags DEPTH();
  static SubFlags BROKER();
  static SubFlags TRADE();
};
 
struct DerivativeType
{
  uint8_t value;
 
  bool has_option();
  bool has_warrant();
};
 
enum class Period
{
  Unknown,
  Min1,
  Min2,
  Min3,
  Min5,
  Min10,
  Min15,
  Min20,
  Min30,
  Min45,
  Min60,
  Min120,
  Min180,
  Min240,
  Day,
  Week,
  Month,
  Quarter,
  Year,
};
 
struct Subscription
{
  std::string symbol;
  SubFlags sub_types;
  std::vector<Period> candlesticks;
};
 
enum class TradeSession
{
  Intraday,
  Pre,
  Post,
  Overnight,
};
 
struct PushQuote
{
  std::string symbol;
  Decimal last_done;
  Decimal open;
  Decimal high;
  Decimal low;
  int64_t timestamp;
  int64_t volume;
  Decimal turnover;
  TradeStatus trade_status;
  TradeSession trade_session;
  int64_t current_volume;
  Decimal urrent_turnover;
};
 
struct Depth
{
  int32_t position;
  std::optional<Decimal> price;
  int64_t volume;
  int64_t order_num;
};
 
struct PushDepth
{
  std::string symbol;
  std::vector<Depth> asks;
  std::vector<Depth> bids;
};
 
struct Brokers
{
  int32_t position;
  std::vector<int32_t> broker_ids;
};
 
struct PushBrokers
{
  std::string symbol;
  std::vector<Brokers> ask_brokers;
  std::vector<Brokers> bid_brokers;
};
 
enum class SecurityBoard
{
  Unknown,
  USMain,
  USPink,
  USDJI,
  USNSDQ,
  USSector,
  USOption,
  USOptionS,
  HKEquity,
  HKPreIPO,
  HKWarrant,
  HKHS,
  HKSector,
  SHMainConnect,
  SHMainNonConnect,
  SHSTAR,
  CNIX,
  CNSector,
  SZMainConnect,
  SZMainNonConnect,
  SZGEMConnect,
  SZGEMNonConnect,
  SGMain,
  STI,
  SGSector,
  SPXIndex,
  VIXIndex,
};
 
struct Security
{
  std::string symbol;
  std::string name_cn;
  std::string name_en;
  std::string name_hk;
};
 
struct SecurityStaticInfo
{
  std::string symbol;
  std::string name_cn;
  std::string name_en;
  std::string name_hk;
  std::string exchange;
  std::string currency;
  int32_t lot_size;
  int64_t total_shares;
  int64_t circulating_shares;
  int64_t hk_shares;
  Decimal eps;
  Decimal eps_ttm;
  Decimal bps;
  Decimal dividend_yield;
  DerivativeType stock_derivatives;
  SecurityBoard board;
};
 
enum class TradeStatus
{
  Normal,
  Halted,
  Delisted,
  Fuse,
  PrepareList,
  CodeMoved,
  ToBeOpened,
  SplitStockHalts,
  Expired,
  WarrantPrepareList,
  SuspendTrade,
};
 
struct PrePostQuote
{
  Decimal last_done;
  int64_t timestamp;
  int64_t volume;
  Decimal turnover;
  Decimal high;
  Decimal low;
  Decimal prev_close;
};
 
struct SecurityQuote
{
  std::string symbol;
  Decimal last_done;
  Decimal prev_close;
  Decimal open;
  Decimal high;
  Decimal low;
  int64_t timestamp;
  int64_t volume;
  Decimal turnover;
  TradeStatus trade_status;
  std::optional<PrePostQuote> pre_market_quote;
  std::optional<PrePostQuote> post_market_quote;
  std::optional<PrePostQuote> overnight_quote;
};
 
enum class OptionType
{
  Unknown,
  American,
  Europe,
};
 
enum class OptionDirection
{
  Unknown,
  Put,
  Call,
};
 
enum class OptionExpiryCycleType
{
  Unknown,
  Monthly,
  Weekly,
  Quarterly,
};
 
enum class OptionStandardAttr
{
  Unknown,
  Normal,
  Old,
};
 
struct OptionQuote
{ 
  std::string symbol;
  Decimal last_done;
  Decimal prev_close;
  Decimal open;
  Decimal high;
  Decimal low;
  int64_t timestamp;
  int64_t volume;
  Decimal turnover;
  TradeStatus trade_status;
  Decimal implied_volatility;
  int64_t open_interest;
  Date expiry_date;
  Decimal strike_price;
  Decimal contract_multiplier;
  OptionType contract_type;
  Decimal contract_size;
  OptionDirection direction;
  Decimal historical_volatility;
  std::string underlying_symbol;
};
 
enum class TradeDirection
{
  Neutral,
  Down,
  Up
};
 
struct Trade
{
  Decimal price;
  int64_t volume;
  int64_t timestamp;
  std::string trade_type;
  TradeDirection direction;
  TradeSession trade_session;
};
 
struct PushTrades
{
  std::string symbol;
  std::vector<Trade> trades;
};
 
struct Candlestick
{
  Decimal close;
  Decimal open;
  Decimal low;
  Decimal high;
  int64_t volume;
  Decimal turnover;
  int64_t timestamp;
  TradeSession trade_session;
};
 
struct PushCandlestick
{
  std::string symbol;
  Period period;
  Candlestick candlestick;
  bool is_confirmed;
};
 
enum class WarrantType
{
  Unknown,
  Call,
  Put,
  Bull,
  Bear,
  Inline
};
 
struct WarrantQuote
{ 
  std::string symbol;
  Decimal last_done;
  Decimal prev_close;
  Decimal open;
  Decimal high;
  Decimal low;
  int64_t timestamp;
  int64_t volume;
  Decimal turnover;
  TradeStatus trade_status;
  Decimal implied_volatility;
  Date expiry_date;
  Date last_trade_date;
  Decimal outstanding_ratio;
  int64_t outstanding_quantity;
  Decimal conversion_ratio;
  WarrantType category;
  Decimal strike_price;
  Decimal upper_strike_price;
  Decimal lower_strike_price;
  Decimal call_price;
  std::string underlying_symbol;
};
 
struct SecurityDepth
{
  std::vector<Depth> asks;
  std::vector<Depth> bids;
};
 
struct SecurityBrokers
{
  std::vector<Brokers> ask_brokers;
  std::vector<Brokers> bid_brokers;
};
 
struct ParticipantInfo
{
  std::vector<int32_t> broker_ids;
  std::string name_cn;
  std::string name_en;
  std::string name_hk;
};
 
struct IntradayLine
{
  Decimal price;
  int64_t timestamp;
  int64_t volume;
  Decimal turnover;
  Decimal avg_price;
};
 
enum class AdjustType
{
  NoAdjust,
  ForwardAdjust
};
 
struct OptionChainContract
{
  std::string symbol;
  Date expiry_date;
  Decimal strike_price;
  OptionDirection direction;
  OptionExpiryCycleType option_type;
  OptionStandardAttr standard_attr;
  int32_t days_to_expiry;
};
 
struct IssuerInfo
{
  int32_t issuer_id;
  std::string name_cn;
  std::string name_en;
  std::string name_hk;
};
 
struct TradingSessionInfo
{
  Time begin_time;
  Time end_time;
  TradeSession trade_session;
};
 
struct MarketTradingSession
{
  Market market;
  std::vector<TradingSessionInfo> trade_session;
};
 
struct MarketTradingDays
{
  std::vector<Date> trading_days;
  std::vector<Date> half_trading_days;
};
 
struct CapitalFlowLine
{
  Decimal inflow;
  int64_t timestamp;
};
 
struct CapitalDistribution
{
  Decimal large;
  Decimal medium;
  Decimal small;
};
 
struct CapitalDistributionResponse
{
  int64_t timestamp;
  CapitalDistribution capital_in;
  CapitalDistribution capital_out;
};
 
struct WatchlistSecurity
{
  std::string symbol;
  Market market;
  std::string name;
  std::optional<Decimal> watched_price;
  int64_t watched_at;
};
 
struct WatchlistGroup
{
  int64_t id;
  std::string name;
  std::vector<WatchlistSecurity> securities;
};
 
enum class SecuritiesUpdateMode
{
  Add,
  Remove,
  Replace,
};
 
struct CreateWatchlistGroup
{
  std::string name;
  std::vector<std::string> securities;
};
 
struct UpdateWatchlistGroup
{
  int64_t id;
  std::optional<std::string> name;
  std::optional<std::vector<std::string>> securities;
  SecuritiesUpdateMode mode;
};
 
struct RealtimeQuote
{
  std::string symbol;
  Decimal last_done;
  Decimal open;
  Decimal high;
  Decimal low;
  int64_t timestamp;
  int64_t volume;
  Decimal turnover;
  TradeStatus trade_status;
};
 
enum class CalcIndex
{
  LastDone,
  ChangeValue,
  ChangeRate,
  Volume,
  Turnover,
  YtdChangeRate,
  TurnoverRate,
  TotalMarketValue,
  CapitalFlow,
  Amplitude,
  VolumeRatio,
  PeTtmRatio,
  PbRatio,
  DividendRatioTtm,
  FiveDayChangeRate,
  TenDayChangeRate,
  HalfYearChangeRate,
  FiveMinutesChangeRate,
  ExpiryDate,
  StrikePrice,
  UpperStrikePrice,
  LowerStrikePrice,
  OutstandingQty,
  OutstandingRatio,
  Premium,
  ItmOtm,
  ImpliedVolatility,
  WarrantDelta,
  CallPrice,
  ToCallPrice,
  EffectiveLeverage,
  LeverageRatio,
  ConversionRatio,
  BalancePoint,
  OpenInterest,
  Delta,
  Gamma,
  Theta,
  Vega,
  Rho,
};
 
struct SecurityCalcIndex
{
  std::string symbol;
  std::optional<Decimal> last_done;
  std::optional<Decimal> change_value;
  std::optional<Decimal> change_rate;
  std::optional<int64_t> volume;
  std::optional<Decimal> turnover;
  std::optional<Decimal> ytd_change_rate;
  std::optional<Decimal> turnover_rate;
  std::optional<Decimal> total_market_value;
  std::optional<Decimal> capital_flow;
  std::optional<Decimal> amplitude;
  std::optional<Decimal> volume_ratio;
  std::optional<Decimal> pe_ttm_ratio;
  std::optional<Decimal> pb_ratio;
  std::optional<Decimal> dividend_ratio_ttm;
  std::optional<Decimal> five_day_change_rate;
  std::optional<Decimal> ten_day_change_rate;
  std::optional<Decimal> half_year_change_rate;
  std::optional<Decimal> five_minutes_change_rate;
  std::optional<Date> expiry_date;
  std::optional<Decimal> strike_price;
  std::optional<Decimal> upper_strike_price;
  std::optional<Decimal> lower_strike_price;
  std::optional<int64_t> outstanding_qty;
  std::optional<Decimal> outstanding_ratio;
  std::optional<Decimal> premium;
  std::optional<Decimal> itm_otm;
  std::optional<Decimal> implied_volatility;
  std::optional<Decimal> warrant_delta;
  std::optional<Decimal> call_price;
  std::optional<Decimal> to_call_price;
  std::optional<Decimal> effective_leverage;
  std::optional<Decimal> leverage_ratio;
  std::optional<Decimal> conversion_ratio;
  std::optional<Decimal> balance_point;
  std::optional<int64_t> open_interest;
  std::optional<Decimal> delta;
  std::optional<Decimal> gamma;
  std::optional<Decimal> theta;
  std::optional<Decimal> vega;
  std::optional<Decimal> rho;
};
 
enum class SortOrderType
{
  Ascending,
  Descending,
};
 
enum class WarrantSortBy
{
  LastDone,
  ChangeRate,
  ChangeValue,
  Volume,
  Turnover,
  ExpiryDate,
  StrikePrice,
  UpperStrikePrice,
  LowerStrikePrice,
  OutstandingQuantity,
  OutstandingRatio,
  Premium,
  ItmOtm,
  ImpliedVolatility,
  Delta,
  CallPrice,
  ToCallPrice,
  EffectiveLeverage,
  LeverageRatio,
  ConversionRatio,
  BalancePoint,
  Status,
};
 
enum class FilterWarrantExpiryDate
{
  LT_3,
  Between_3_6,
  Between_6_12,
  GT_12,
};
 
enum class FilterWarrantInOutBoundsType
{
  In,
  Out,
};
 
enum class WarrantStatus
{
  Unknown,
  Suspend,
  PrepareList,
  Normal,
};
 
struct WarrantInfo
{
  std::string symbol;
  WarrantType warrant_type;
  std::string name;
  Decimal last_done;
  Decimal change_rate;
  Decimal change_value;
  int64_t volume;
  Decimal turnover;
  std::optional<Date> expiry_date;
  std::optional<Decimal> strike_price;
  std::optional<Decimal> upper_strike_price;
  std::optional<Decimal> lower_strike_price;
  int64_t outstanding_qty;
  Decimal outstanding_ratio;
  Decimal premium;
  std::optional<Decimal> itm_otm;
  std::optional<Decimal> implied_volatility;
  std::optional<Decimal> delta;
  std::optional<Decimal> call_price;
  std::optional<Decimal> to_call_price;
  std::optional<Decimal> effective_leverage;
  Decimal leverage_ratio;
  std::optional<Decimal> conversion_ratio;
  std::optional<Decimal> balance_point;
  WarrantStatus status;
};
 
enum class SecurityListCategory
{
  Overnight,
};
 
struct QuotePackageDetail
{
  std::string key;
  std::string name;
  std::string description;
  int64_t start_at;
  int64_t end_at;
};
 
enum class TradeSessions
{
  Intraday,
  All,
};
 
struct MarketTemperature
{
  int32_t temperature;
  std::string description;
  int32_t valuation;
  int32_t sentiment;
  int64_t timestamp;
};
 
enum Granularity
{
  Unknown,
  Daily,
  Weekly,
  Monthly,
};
 
struct HistoryMarketTemperatureResponse
{
  Granularity granularity;
  std::vector<MarketTemperature> records;
};
 
struct FilingItem
{
  std::string id;
  std::string title;
  std::string description;
  std::string file_name;
  std::vector<std::string> file_urls;
  int64_t published_at;
};
 
struct ShortPositionsItem
{
  std::string timestamp;
  std::string rate;
  std::string close;
  std::string current_shares_short;
  std::string avg_daily_share_volume;
  std::string days_to_cover;
  std::string amount;
  std::string balance;
  std::string cost;
};
 
struct ShortPositionsResponse
{
  std::vector<ShortPositionsItem> data;
};
 
struct ShortTradesItem
{
  std::string timestamp;
  std::string rate;
  std::string close;
  std::string nus_amount;
  std::string ny_amount;
  std::string total_amount;
  std::string amount;
  std::string balance;
};
 
struct ShortTradesResponse
{
  std::vector<ShortTradesItem> data;
};
 
struct OptionVolumeStats
{
  std::string symbol;
  int64_t call_volume;
  int64_t put_volume;
};
 
struct OptionVolumeDailyStat
{
  std::string symbol;
  Date date;
  int64_t call_volume;
  int64_t put_volume;
  int64_t call_open_interest;
  int64_t put_open_interest;
  int64_t total_volume;
  int64_t total_open_interest;
  double pc_vol;
  double pc_oi;
};
 
struct OptionVolumeDaily
{
  std::string symbol;
  std::vector<OptionVolumeDailyStat> stats;
};
 
} // namespace quote
 
namespace trade {
 
enum class TopicType
{
  Private,
};
 
enum class OrderSide
{
  Unknown,
  Buy,
  Sell,
};
 
struct Execution
{
  std::string order_id;
  std::string trade_id;
  std::string symbol;
  int64_t trade_done_at;
  Decimal quantity;
  Decimal price;
  OrderSide side;
};
 
struct GetHistoryExecutionsOptions
{
  std::optional<int64_t> start_at;
  std::optional<int64_t> end_at;
  std::optional<std::string> symbol;
};
 
struct GetTodayExecutionsOptions
{
  std::optional<std::string> symbol;
  std::optional<std::string> order_id;
};
 
struct GetAllExecutionsOptions
{
  std::optional<std::string> symbol;
  std::optional<std::string> order_id;
  std::optional<int64_t> start_at;
  std::optional<int64_t> end_at;
  std::optional<uint64_t> page;
};
 
struct AllExecutionsResponse
{
  bool has_more;
  std::vector<Execution> trades;
};
 
enum class OrderStatus
{
  Unknown,
  NotReported,
  ReplacedNotReported,
  ProtectedNotReported,
  VarietiesNotReported,
  Filled,
  WaitToNew,
  New,
  WaitToReplace,
  PendingReplace,
  Replaced,
  PartialFilled,
  WaitToCancel,
  PendingCancel,
  Rejected,
  Canceled,
  Expired,
  PartialWithdrawal,
};
 
enum class OrderType
{
  Unknown,
  LO,
  ELO,
  MO,
  AO,
  ALO,
  ODD,
  LIT,
  MIT,
  TSLPAMT,
  TSLPPCT,
  TSMAMT,
  TSMPCT,
  SLO,
};
 
enum class OrderTag
{
  Unknown,
  Normal,
  LongTerm,
  Grey,
};
 
enum class TimeInForceType
{
  Unknown,
  Day,
  GoodTilCanceled,
  GoodTilDate,
};
 
enum class TriggerStatus
{
  Unknown,
  Deactive,
  Active,
  Released,
};
 
enum class OutsideRTH
{
  Unknown,
  RTHOnly,
  AnyTime,
  Overnight,
  OptionPreMarket,
};
 
enum class AttachedOrderType
{
  Unknown,
  ProfitTaker,
  StopLoss,
  Bracket,
};
 
struct AttachedOrderDetail
{
  std::string order_id;
  AttachedOrderType attached_type_display;
  std::optional<Decimal> trigger_price;
  Decimal quantity;
  Decimal executed_qty;
  OrderStatus status;
  int64_t updated_at;
  bool withdrawn;
  std::optional<Date> gtd;
  TimeInForceType time_in_force;
  std::string counter_id;
  std::optional<TriggerStatus> trigger_status;
  Decimal executed_amount;
  OrderTag tag;
  int64_t submitted_at;
  std::optional<Decimal> executed_price;
  std::optional<OutsideRTH> force_only_rth;
  bool reviewed;
  OrderType activate_order_type;
  std::optional<OutsideRTH> activate_rth;
  std::optional<Decimal> submit_price;
};
 
struct SubmitAttachedParams
{
  AttachedOrderType attached_order_type;
  std::optional<Decimal> profit_taker_price;
  std::optional<Decimal> stop_loss_price;
  std::optional<TimeInForceType> time_in_force;
  std::optional<int64_t> expire_time;
  std::optional<OrderType> activate_order_type;
  std::optional<Decimal> profit_taker_submit_price;
  std::optional<Decimal> stop_loss_submit_price;
  std::optional<OutsideRTH> activate_rth;
};
 
struct ReplaceAttachedParams
{
  AttachedOrderType attached_order_type;
  std::optional<Decimal> profit_taker_price;
  std::optional<Decimal> stop_loss_price;
  std::optional<TimeInForceType> time_in_force;
  std::optional<int64_t> expire_time;
  std::optional<OrderType> activate_order_type;
  std::optional<Decimal> profit_taker_submit_price;
  std::optional<Decimal> stop_loss_submit_price;
  std::optional<OutsideRTH> activate_rth;
  std::optional<int64_t> profit_taker_id;
  std::optional<int64_t> stop_loss_id;
  std::optional<bool> cancel_all_attached;
  std::optional<int64_t> main_id;
  std::optional<Decimal> quantity;
  std::optional<Decimal> market_price;
};
 
enum class MultiLegStrategy
{
  Unknown,
  CoveredCall,
  CoveredPut,
  VerticalCallSpread,
  VerticalPutSpread,
  Collar,
  Straddle,
  Strangle,
  CalendarCallSpread,
  CalendarPutSpread,
};
 
enum class MultiLegPosition
{
  Unknown,
  Long,
  Short,
};
 
enum class ContractDirection
{
  Unknown,
  Call,
  Put,
};
 
struct MultiLegOrderLeg
{
  std::string symbol;
  OrderSide side;
  MultiLegPosition position;
  Decimal ratio_quantity;
  std::optional<Decimal> strike_price;
  std::optional<Date> expire_date;
  ContractDirection contract_direction;
};
 
struct MultiLegInfo
{
  MultiLegStrategy strategy;
  std::string strategy_name;
  std::string multileg_id;
  std::string code;
  std::vector<MultiLegOrderLeg> legs;
};
 
struct Order
{
  std::string order_id;
  OrderStatus status;
  std::string stock_name;
  Decimal quantity;
  Decimal executed_quantity;
  std::optional<Decimal> price;
  std::optional<Decimal> executed_price;
  int64_t submitted_at;
  OrderSide side;
  std::string symbol;
  OrderType order_type;
  std::optional<Decimal> last_done;
  std::optional<Decimal> trigger_price;
  std::string msg;
  OrderTag tag;
  TimeInForceType time_in_force;
  std::optional<Date> expire_date;
  std::optional<int64_t> updated_at;
  std::optional<int64_t> trigger_at;
  std::optional<Decimal> trailing_amount;
  std::optional<Decimal> trailing_percent;
  std::optional<Decimal> limit_offset;
  std::optional<TriggerStatus> trigger_status;
  std::string currency;
  std::optional<OutsideRTH> outside_rth;
  std::optional<int32_t> limit_depth_level;
  std::optional<int32_t> trigger_count;
  std::optional<Decimal> monitor_price;
  std::string remark;
  std::vector<AttachedOrderDetail> attached_orders;
  std::optional<MultiLegInfo> multi_leg;
};
 
struct PushOrderChanged
{
  OrderSide side;
  std::string stock_name;
  Decimal submitted_quantity;
  std::string symbol;
  OrderType order_type;
  Decimal submitted_price;
  Decimal executed_quantity;
  std::optional<Decimal> executed_price;
  std::string order_id;
  std::string currency;
  OrderStatus status;
  int64_t submitted_at;
  int64_t updated_at;
  std::optional<Decimal> trigger_price;
  std::string msg;
  OrderTag tag;
  std::optional<TriggerStatus> trigger_status;
  std::optional<int64_t> trigger_at;
  std::optional<Decimal> trailing_amount;
  std::optional<Decimal> trailing_percent;
  std::optional<Decimal> limit_offset;
  std::string account_no;
  std::optional<Decimal> last_share;
  std::optional<Decimal> last_price;
  std::string remark;
  std::optional<MultiLegInfo> multi_leg;
};
 
struct GetHistoryOrdersOptions
{
  std::optional<std::string> symbol;
  std::optional<std::vector<OrderStatus>> status;
  std::optional<OrderSide> side;
  std::optional<Market> market;
  std::optional<int64_t> start_at;
  std::optional<int64_t> end_at;
};
 
struct GetTodayOrdersOptions
{
  std::optional<std::string> symbol;
  std::optional<std::vector<OrderStatus>> status;
  std::optional<OrderSide> side;
  std::optional<Market> market;
  std::optional<std::string> order_id;
  std::optional<bool> is_attached;
};
 
struct ReplaceOrderOptions
{
  std::string order_id;
  Decimal quantity;
  std::optional<Decimal> price;
  std::optional<Decimal> trigger_price;
  std::optional<Decimal> limit_offset;
  std::optional<Decimal> trailing_amount;
  std::optional<Decimal> trailing_percent;
  std::optional<int32_t> limit_depth_level;
  std::optional<int32_t> trigger_count;
  std::optional<Decimal> monitor_price;
  std::optional<std::string> remark;
  std::optional<ReplaceAttachedParams> attached_params;
};
 
struct SubmitOrderOptions
{
  std::string symbol;
  OrderType order_type;
  OrderSide side;
  Decimal submitted_quantity;
  TimeInForceType time_in_force;
  std::optional<Decimal> submitted_price;
  std::optional<Decimal> trigger_price;
  std::optional<Decimal> limit_offset;
  std::optional<Decimal> trailing_amount;
  std::optional<Decimal> trailing_percent;
  std::optional<Date> expire_date;
  std::optional<OutsideRTH> outside_rth;
  std::optional<int32_t> limit_depth_level;
  std::optional<int32_t> trigger_count;
  std::optional<Decimal> monitor_price;
  std::optional<std::string> remark;
  std::optional<std::string> client_request_id;
  std::optional<SubmitAttachedParams> attached_params;
};
 
struct SubmitOrderResponse
{
  std::string order_id;
};
 
struct SubmitMultiLegOrderLeg
{
  std::string symbol;
  Decimal ratio_quantity;
};
 
struct SubmitMultiLegOrderOptions
{
  OrderSide side;
  OrderType order_type;
  Decimal submitted_quantity;
  MultiLegStrategy strategy;
  std::vector<SubmitMultiLegOrderLeg> legs;
  std::optional<Decimal> submitted_price;
  std::optional<std::string> remark;
  std::optional<std::string> client_request_id;
};
 
struct CashInfo
{
  Decimal withdraw_cash;
  Decimal available_cash;
  Decimal frozen_cash;
  Decimal settling_cash;
  std::string currency;
};
 
struct FrozenTransactionFee
{
  std::string currency;
  Decimal frozen_transaction_fee;
};
 
struct AccountBalance
{
  Decimal total_cash;
  Decimal max_finance_amount;
  Decimal remaining_finance_amount;
  int32_t risk_level;
  Decimal margin_call;
  std::string currency;
  std::vector<CashInfo> cash_infos;
  Decimal net_assets;
  Decimal init_margin;
  Decimal maintenance_margin;
  Decimal buy_power;
  std::vector<FrozenTransactionFee> frozen_transaction_fees;
};
 
enum class CashFlowDirection
{
  Unknown,
  Out,
  In,
};
 
enum class BalanceType
{
  Unknown,
  Cash,
  Stock,
  Fund,
};
 
struct CashFlow
{
  std::string transaction_flow_name;
  CashFlowDirection direction;
  BalanceType business_type;
  Decimal balance;
  std::string currency;
  int64_t business_time;
  std::optional<std::string> symbol;
  std::string description;
};
 
struct GetCashFlowOptions
{
  int64_t start_at;
  int64_t end_at;
  std::optional<BalanceType> business_type;
  std::optional<std::string> symbol;
  std::optional<uintptr_t> page;
  std::optional<uintptr_t> size;
};
 
struct GetFundPositionsOptions
{
  std::optional<std::vector<std::string>> symbols;
};
 
struct GetStockPositionsOptions
{
  std::optional<std::vector<std::string>> symbols;
};
 
struct FundPosition
{
  std::string symbol;
  Decimal current_net_asset_value;
  int64_t net_asset_value_day;
  std::string symbol_name;
  std::string currency;
  Decimal cost_net_asset_value;
  Decimal holding_units;
};
 
struct FundPositionChannel
{
  std::string account_channel;
  std::vector<FundPosition> positions;
};
 
struct FundPositionsResponse
{
  std::vector<FundPositionChannel> channels;
};
 
struct StockPosition
{
  std::string symbol;
  std::string symbol_name;
  Decimal quantity;
  Decimal available_quantity;
  std::string currency;
  Decimal cost_price;
  Market market;
  std::optional<Decimal> init_quantity;
};
 
struct StockPositionChannel
{
  std::string account_channel;
  std::vector<StockPosition> positions;
};
 
struct StockPositionsResponse
{
  std::vector<StockPositionChannel> channels;
};
 
struct MarginRatio
{
  Decimal im_factor;
  Decimal mm_factor;
  Decimal fm_factor;
};
 
enum class CommissionFreeStatus
{
  Unknown,
  None,
  Calculated,
  Pending,
  Ready,
};
 
enum class DeductionStatus
{
  Unknown,
  None,
  NoData,
  Pending,
  Done,
};
 
enum class ChargeCategoryCode
{
  Unknown,
  Broker,
  Third,
};
 
struct OrderHistoryDetail
{
  Decimal price;
  Decimal quantity;
  OrderStatus status;
  std::string msg;
  int64_t time;
};
 
struct OrderChargeFee
{
  std::string code;
  std::string name;
  Decimal amount;
  std::string currency;
};
 
struct OrderChargeItem
{
  ChargeCategoryCode code;
  std::string name;
  std::vector<OrderChargeFee> fees;
};
 
struct OrderChargeDetail
{
  Decimal total_amount;
  std::string currency;
  std::vector<OrderChargeItem> items;
};
 
struct OrderDetail
{
  std::string order_id;
  OrderStatus status;
  std::string stock_name;
  Decimal quantity;
  Decimal executed_quantity;
  std::optional<Decimal> price;
  std::optional<Decimal> executed_price;
  int64_t submitted_at;
  OrderSide side;
  std::string symbol;
  OrderType order_type;
  std::optional<Decimal> last_done;
  std::optional<Decimal> trigger_price;
  std::string msg;
  OrderTag tag;
  TimeInForceType time_in_force;
  std::optional<Date> expire_date;
  std::optional<int64_t> updated_at;
  std::optional<int64_t> trigger_at;
  std::optional<Decimal> trailing_amount;
  std::optional<Decimal> trailing_percent;
  std::optional<Decimal> limit_offset;
  std::optional<TriggerStatus> trigger_status;
  std::string currency;
  std::optional<OutsideRTH> outside_rth;
  std::optional<int32_t> limit_depth_level;
  std::optional<int32_t> trigger_count;
  std::optional<Decimal> monitor_price;
  std::string remark;
  CommissionFreeStatus free_status;
  std::optional<Decimal> free_amount;
  std::optional<std::string> free_currency;
  DeductionStatus deductions_status;
  std::optional<Decimal> deductions_amount;
  std::optional<std::string> deductions_currency;
  DeductionStatus platform_deducted_status;
  std::optional<Decimal> platform_deducted_amount;
  std::optional<std::string> platform_deducted_currency;
  std::vector<OrderHistoryDetail> history;
  std::optional<OrderChargeDetail> charge_detail;
  std::vector<AttachedOrderDetail> attached_orders;
  std::optional<MultiLegInfo> multi_leg;
};
 
struct EstimateMaxPurchaseQuantityOptions
{
  std::string symbol;
  OrderType order_type;
  OrderSide side;
  std::optional<Decimal> price;
  std::optional<std::string> currency;
  std::optional<std::string> order_id;
  bool fractional_shares;
};
 
struct EstimateMaxPurchaseQuantityResponse
{
  Decimal cash_max_qty;
  Decimal margin_max_qty;
};
 
 
struct PushGridOrderChanged
{
  std::string order_id;
  std::string status;
  std::string symbol;
  std::string suspend_reason;
  std::string submitted_base_price;
  std::string current_base_price;
  std::string upper_limit_price;
  std::string lower_limit_price;
  int32_t trigger_price_type;
  std::string trigger_quantity;
  std::string settlement_currency;
  int32_t time_in_force;
  int32_t rth;
  std::string grid_order_type_up;
  std::string grid_order_type_down;
};
 
} // namespace trade
 
namespace grid {
 
enum class TriggerPriceType : int32_t
{
  Unknown = 0,
  Spread = 1,
  Percent = 2,
};
 
enum class GridTimeInForce : int32_t
{
  Day = 0,
  GoodTilCanceled = 1,
  GoodTilDate = 6,
};
 
enum class GridLimitEvent : int32_t
{
  Unknown = 0,
  Ignore = 1,
  CloseAtLast = 2,
};
 
struct GridTrigger
{
  enum class Kind
  {
    Percent,
    Spread,
  };
  Kind kind;
  Decimal up;
  Decimal down;
 
  static GridTrigger percent(Decimal up, Decimal down)
  {
    return GridTrigger{ Kind::Percent, up, down };
  }
  static GridTrigger spread(Decimal up, Decimal down)
  {
    return GridTrigger{ Kind::Spread, up, down };
  }
};
 
struct GridTradeRule
{
  std::optional<Decimal> submitted_base_price;
  std::optional<Decimal> upper_limit_price;
  std::optional<Decimal> lower_limit_price;
  std::optional<TriggerPriceType> trigger_price_type;
  std::optional<Decimal> trigger_spread_up;
  std::optional<Decimal> trigger_spread_down;
  std::optional<Decimal> trigger_percent_up;
  std::optional<Decimal> trigger_percent_down;
  std::optional<bool> multiple_trigger;
  std::optional<GridTimeInForce> time_in_force;
  std::optional<Decimal> upper_limit_quantity;
  std::optional<Decimal> lower_limit_quantity;
  std::optional<int64_t> expire_time;
  std::optional<GridLimitEvent> upper_limit_event;
  std::optional<GridLimitEvent> lower_limit_event;
  std::optional<int32_t> trigger_sell_depth;
  std::optional<int32_t> trigger_buy_depth;
  std::optional<Decimal> trigger_quantity;
  std::optional<bool> support_shortsell;
  std::optional<int32_t> rth;
  std::optional<std::string> grid_order_type_up;
  std::optional<std::string> grid_order_type_down;
 
  static GridTradeRule create(Decimal base_price,
                              Decimal upper_price,
                              Decimal lower_price,
                              GridTrigger trigger,
                              Decimal quantity,
                              Decimal upper_quantity,
                              Decimal lower_quantity,
                              GridTimeInForce time_in_force)
  {
    GridTradeRule rule;
    rule.submitted_base_price = base_price;
    rule.upper_limit_price = upper_price;
    rule.lower_limit_price = lower_price;
    rule.trigger_quantity = quantity;
    rule.upper_limit_quantity = upper_quantity;
    rule.lower_limit_quantity = lower_quantity;
    rule.time_in_force = time_in_force;
    if (trigger.kind == GridTrigger::Kind::Percent) {
      rule.trigger_price_type = TriggerPriceType::Percent;
      rule.trigger_percent_up = trigger.up;
      rule.trigger_percent_down = trigger.down;
    } else {
      rule.trigger_price_type = TriggerPriceType::Spread;
      rule.trigger_spread_up = trigger.up;
      rule.trigger_spread_down = trigger.down;
    }
    return rule;
  }
 
  GridTradeRule& with_limit_events(GridLimitEvent upper, GridLimitEvent lower)
  {
    upper_limit_event = upper;
    lower_limit_event = lower;
    return *this;
  }
 
  GridTradeRule& with_depths(int32_t sell, int32_t buy)
  {
    trigger_sell_depth = sell;
    trigger_buy_depth = buy;
    return *this;
  }
 
  GridTradeRule& with_order_types(std::string up, std::string down)
  {
    grid_order_type_up = std::move(up);
    grid_order_type_down = std::move(down);
    return *this;
  }
 
  GridTradeRule& with_multiple_trigger(bool value)
  {
    multiple_trigger = value;
    return *this;
  }
 
  GridTradeRule& with_support_shortsell(bool value)
  {
    support_shortsell = value;
    return *this;
  }
 
  GridTradeRule& with_rth(int32_t value)
  {
    rth = value;
    return *this;
  }
 
  GridTradeRule& with_expire_time(int64_t unix_seconds)
  {
    expire_time = unix_seconds;
    return *this;
  }
};
 
struct SubmitGridOrderOptions
{
  std::string symbol;
  std::string settlement_currency;
  GridTradeRule grid_trading_rule;
};
 
struct ReplaceGridOrderOptions
{
  std::string order_id;
  GridTradeRule grid_trading_rule;
};
 
struct GetGridOrdersOptions
{
  std::optional<int32_t> page;
  std::optional<int32_t> limit;
  std::optional<Market> market;
  std::optional<std::string> status;
  std::optional<std::string> symbol;
  std::optional<std::string> sort_by;
  std::optional<std::string> sort_order;
};
 
struct GetGridOrdersByIdsOptions
{
  std::vector<std::string> order_ids;
};
 
struct GetGridOrderDetailOptions
{
  std::string order_id;
  std::optional<std::string> history_id;
  std::optional<int32_t> limit;
};
 
struct GetGridTriggerHistoryOptions
{
  std::string grid_order_id;
  std::optional<int32_t> page;
  std::optional<int32_t> limit;
};
 
struct SubmitGridOrderResponse
{
  std::string order_id;
};
 
struct GridOrder
{
  std::string order_id;
  std::string symbol;
  std::string stock_name;
  std::string market;
  std::string status;
  std::string grid_status;
  std::optional<Decimal> submitted_base_price;
  std::optional<Decimal> current_base_price;
  std::optional<Decimal> pre_trigger_base_price;
  std::optional<Decimal> post_trigger_base_price;
  std::optional<Decimal> upper_limit_price;
  std::optional<Decimal> lower_limit_price;
  TriggerPriceType trigger_price_type;
  std::optional<Decimal> trigger_spread_up;
  std::optional<Decimal> trigger_spread_down;
  std::optional<Decimal> trigger_percent_up;
  std::optional<Decimal> trigger_percent_down;
  std::optional<Decimal> pullback_percent;
  std::optional<Decimal> pullback_spread;
  std::optional<Decimal> rebound_percent;
  std::optional<Decimal> rebound_spread;
  std::string trigger_sell_order_type;
  std::string trigger_buy_order_type;
  int32_t trigger_sell_depth;
  int32_t trigger_buy_depth;
  std::optional<Decimal> trigger_quantity;
  std::optional<Decimal> trigger_sell_quantity;
  std::optional<Decimal> trigger_buy_quantity;
  std::optional<Decimal> upper_limit_quantity;
  std::optional<Decimal> lower_limit_quantity;
  GridLimitEvent upper_limit_event;
  GridLimitEvent lower_limit_event;
  bool multiple_trigger;
  int32_t trigger_times;
  std::optional<Decimal> total_buy_quantity;
  std::optional<Decimal> total_sell_quantity;
  std::optional<Decimal> total_profit_balance;
  std::string settlement_currency;
  GridTimeInForce time_in_force;
  std::string gtd;
  std::optional<int64_t> created_at;
  int32_t rth;
  bool support_shortsell;
  std::string grid_order_type_up;
  std::string grid_order_type_down;
};
 
struct GridOrderSubOrder
{
  std::string id;
  std::optional<Decimal> price;
  std::string order_type;
  std::optional<Decimal> quantity;
  std::optional<Decimal> executed_qty;
  int32_t action;
  std::string status;
  std::optional<int64_t> submitted_at;
  int32_t rth;
};
 
struct GridOrderHistory
{
  std::string history_id;
  std::optional<int64_t> created_at;
  std::string status;
  std::string suspend_reason;
  std::string reason;
};
 
struct GridOrderDetail
{
  std::string order_id;
  std::string symbol;
  std::string stock_name;
  std::string status;
  std::string grid_status;
  std::string suspend_reason;
  std::string sleeping_reason;
  std::optional<Decimal> submitted_base_price;
  std::optional<Decimal> current_base_price;
  std::optional<Decimal> upper_limit_price;
  std::optional<Decimal> lower_limit_price;
  TriggerPriceType trigger_price_type;
  std::optional<Decimal> trigger_spread_up;
  std::optional<Decimal> trigger_spread_down;
  std::optional<Decimal> trigger_percent_up;
  std::optional<Decimal> trigger_percent_down;
  std::optional<Decimal> pullback_percent;
  std::optional<Decimal> pullback_spread;
  std::optional<Decimal> rebound_percent;
  std::optional<Decimal> rebound_spread;
  bool multiple_trigger;
  GridTimeInForce time_in_force;
  std::optional<Decimal> trigger_quantity;
  std::optional<Decimal> trigger_sell_quantity;
  std::optional<Decimal> trigger_buy_quantity;
  std::optional<Decimal> upper_limit_quantity;
  std::optional<Decimal> lower_limit_quantity;
  GridLimitEvent upper_limit_event;
  GridLimitEvent lower_limit_event;
  int32_t trigger_sell_depth;
  int32_t trigger_buy_depth;
  std::optional<int64_t> created_at;
  std::optional<int64_t> updated_at;
  std::string settlement_currency;
  std::optional<int64_t> expire_time;
  std::string gtd;
  std::vector<GridOrderSubOrder> grid_sub_orders;
  bool sub_has_more;
  std::vector<GridOrderHistory> grid_order_history;
  bool history_has_more;
  bool support_shortsell;
  int32_t rth;
  std::string grid_order_type_up;
  std::string grid_order_type_down;
};
 
struct TriggerOrder
{
  std::string id;
  std::string status;
  std::string name;
  std::string symbol;
  std::optional<Decimal> price;
  std::optional<Decimal> quantity;
  std::optional<Decimal> executed_price;
  std::optional<Decimal> executed_qty;
  std::optional<int64_t> submitted_at;
  int32_t action;
  std::string order_type;
  std::optional<Decimal> trigger_price;
  std::string msg;
  std::string currency;
  std::optional<Decimal> last_done;
  std::optional<int64_t> updated_at;
  GridTimeInForce time_in_force;
  std::string gtd;
  std::optional<int64_t> trigger_at;
  int32_t trigger_status;
};
 
struct GridBidSize
{
  std::optional<Decimal> str_proceed;
  std::optional<Decimal> end_proceed;
  std::optional<Decimal> bid_size;
};
 
struct GridChannelInfo
{
  bool strategy_granted;
  bool support_rth;
  std::string currency;
  std::vector<std::string> settlement_currency;
};
 
struct GridSymbolInfo
{
  std::string name;
  std::optional<Decimal> last_done;
  std::optional<Decimal> lot_size;
  std::optional<Decimal> buy_lot_size;
  std::optional<Decimal> sell_lot_size;
  std::vector<GridBidSize> bid_sizes;
  GridChannelInfo channel_info;
};
 
struct GridOrdersResponse
{
  std::vector<GridOrder> grid_order;
  bool has_more;
};
 
struct GridTriggerHistoryResponse
{
  std::vector<TriggerOrder> trigger_orders;
  bool has_more;
};
} // namespace grid
 
namespace content {
 
struct TopicItem
{
  std::string id;
  std::string title;
  std::string description;
  std::string url;
  int64_t published_at;
  int32_t comments_count;
  int32_t likes_count;
  int32_t shares_count;
};
 
struct NewsItem
{
  std::string id;
  std::string title;
  std::string description;
  std::string url;
  int64_t published_at;
  int32_t comments_count;
  int32_t likes_count;
  int32_t shares_count;
};
 
struct TopicAuthor
{
  std::string member_id;
  std::string name;
  std::string avatar;
};
 
struct TopicImage
{
  std::string url;
  std::string sm;
  std::string lg;
};
 
struct OwnedTopic
{
  std::string id;
  std::string title;
  std::string description;
  std::string body;
  TopicAuthor author;
  std::vector<std::string> tickers;
  std::vector<std::string> hashtags;
  std::vector<TopicImage> images;
  int32_t likes_count;
  int32_t comments_count;
  int32_t views_count;
  int32_t shares_count;
  std::string topic_type;
  std::string detail_url;
  int64_t created_at;
  int64_t updated_at;
};
 
struct MyTopicsOptions
{
  int32_t page = 0;
  int32_t size = 0;
  std::string topic_type;
};
 
struct CreateTopicOptions
{
  std::string title;
  std::string body;
  std::string topic_type;
  std::vector<std::string> tickers;
  std::vector<std::string> hashtags;
};
 
} // namespace content
 
// ── MarketContext types ───────────────────────────────────────────
namespace market {
 
struct MarketTimeItem
{
  longbridge::Market market;
  int32_t trade_status;
  std::string timestamp;
  int32_t delay_trade_status;
  std::string delay_timestamp;
  int32_t sub_status;
  int32_t delay_sub_status;
};
 
struct MarketStatusResponse
{
  std::vector<MarketTimeItem> market_time;
};
 
struct BrokerHoldingEntry
{
  std::string name;
  std::string parti_number;
  std::string chg;
  bool strong;
};
 
struct BrokerHoldingTop
{
  std::vector<BrokerHoldingEntry> buy;
  std::vector<BrokerHoldingEntry> sell;
  std::string updated_at;
};
 
struct BrokerHoldingChanges
{
  std::string value;
  std::string chg_1;
  std::string chg_5;
  std::string chg_20;
  std::string chg_60;
};
 
struct BrokerHoldingDetailItem
{
  std::string name;
  std::string parti_number;
  BrokerHoldingChanges ratio;
  BrokerHoldingChanges shares;
  bool strong;
};
 
struct BrokerHoldingDetail
{
  std::vector<BrokerHoldingDetailItem> list;
  std::string updated_at;
};
 
struct BrokerHoldingDailyItem
{
  std::string date;
  std::string holding;
  std::string ratio;
  std::string chg;
};
 
struct BrokerHoldingDailyHistory
{
  std::vector<BrokerHoldingDailyItem> list;
};
 
struct AhPremiumKline
{
  std::string aprice;
  std::string apreclose;
  std::string hprice;
  std::string hpreclose;
  std::string currency_rate;
  std::string ahpremium_rate;
  std::string price_spread;
  int64_t timestamp;
};
 
struct AhPremiumKlines
{
  std::vector<AhPremiumKline> klines;
};
 
struct AhPremiumIntraday
{
  std::vector<AhPremiumKline> klines;
};
 
struct TradePriceLevel
{
  std::string buy_amount;
  std::string neutral_amount;
  std::string price;
  std::string sell_amount;
};
 
struct TradeStatistics
{
  std::string avgprice;
  std::string buy;
  std::string neutral;
  std::string preclose;
  std::string sell;
  std::string timestamp;
  std::string total_amount;
  std::vector<std::string> trade_date;
  std::string trades_count;
};
 
struct TradeStatsResponse
{
  TradeStatistics statistics;
  std::vector<TradePriceLevel> trades;
};
 
struct TopMoversStock
{
  std::string symbol;
  std::string code;
  std::string name;
  std::string full_name;
  std::string change;
  std::string last_done;
  std::string market;
  std::string logo;
  std::vector<std::string> labels;
};
 
struct TopMoversEvent
{
  std::string timestamp;
  std::string alert_reason;
  int64_t alert_type;
  TopMoversStock stock;
  std::string post;
};
 
struct TopMoversResponse
{
  std::vector<TopMoversEvent> events;
  std::string next_params;
};
 
struct RankListItem
{
  std::string symbol;
  std::string code;
  std::string name;
  std::string last_done;
  std::string chg;
  std::string change;
  std::string inflow;
  std::string market_cap;
  std::string industry;
  std::string pre_post_price;
  std::string pre_post_chg;
  std::string amplitude;
  std::string five_day_chg;
  std::string turnover_rate;
  std::string volume_rate;
  std::string pb_ttm;
};
 
struct RankListResponse
{
  bool bmp;
  std::vector<RankListItem> lists;
};
 
struct RankSubCategory
{
  std::string key;
  std::string name;
  std::string market;
};
 
struct RankCategory
{
  std::string key;
  std::string name;
  std::vector<RankSubCategory> sub_categories;
};
 
struct RankCategoriesResponse
{
  std::vector<RankCategory> categories;
};
 
struct AnomalyItem
{
  std::string symbol;
  std::string name;
  std::string alert_name;
  int64_t alert_time;
  std::vector<std::string> change_values;
  int32_t emotion;
};
 
struct AnomalyResponse
{
  bool all_off;
  std::vector<AnomalyItem> changes;
};
 
struct ConstituentStock
{
  std::string symbol;
  std::string name;
  std::string last_done;
  std::string prev_close;
  std::string inflow;
  std::string balance;
  std::string amount;
  std::string total_shares;
  std::vector<std::string> tags;
  std::string intro;
  std::string market;
  std::string circulating_shares;
  bool delay;
  std::string chg;
  int32_t trade_status;
};
 
struct IndexConstituents
{
  int32_t fall_num;
  int32_t flat_num;
  int32_t rise_num;
  std::vector<ConstituentStock> stocks;
};
 
} // namespace market
 
// ── FundamentalContext types ──────────────────────────────────────
namespace fundamental {
 
enum class InstitutionRecommend
{
  Unknown     = 0,
  StrongBuy   = 1,
  Buy         = 2,
  Hold        = 3,
  Sell        = 4,
  StrongSell  = 5,
  Underperform = 6,
};
 
struct DividendItem
{
  std::string symbol;
  std::string id;
  std::string desc;
  std::string record_date;
  std::string ex_date;
  std::string payment_date;
};
 
struct DividendList
{
  std::vector<DividendItem> list;
};
 
struct RatingEvaluate
{
  int32_t buy;
  int32_t over;
  int32_t hold;
  int32_t under;
  int32_t sell;
  int32_t no_opinion;
  int32_t total;
  std::string start_date;
  std::string end_date;
};
 
struct RatingTarget
{
  std::string highest_price;
  std::string lowest_price;
  std::string prev_close;
  std::string start_date;
  std::string end_date;
};
 
struct RatingSummaryEvaluate
{
  int32_t buy;
  std::string date;
  int32_t hold;
  int32_t sell;
  int32_t strong_buy;
  int32_t under;
};
 
struct InstitutionRatingLatest
{
  RatingEvaluate evaluate;
  RatingTarget target;
  int64_t industry_id;
  std::string industry_name;
  int32_t industry_rank;
  int32_t industry_total;
  int32_t industry_mean;
  int32_t industry_median;
};
 
struct InstitutionRatingSummary
{
  std::string ccy_symbol;
  std::string change;
  RatingSummaryEvaluate evaluate;
  InstitutionRecommend recommend;
  std::string target;
  std::string updated_at;
};
 
struct InstitutionRating
{
  InstitutionRatingLatest latest;
  InstitutionRatingSummary summary;
};
 
struct InstitutionRatingDetailEvaluateItem
{
  int32_t buy;
  std::string date;
  int32_t hold;
  int32_t sell;
  int32_t strong_buy;
  int32_t under;
};
 
struct InstitutionRatingDetailTargetItem
{
  std::string avg_target;
  std::string date;
  std::string max_target;
  std::string min_target;
  bool meet;
  std::string price;
  std::string timestamp;
};
 
struct InstitutionRatingDetail
{
  std::string ccy_symbol;
  std::vector<InstitutionRatingDetailEvaluateItem> evaluate_list;
  std::string data_percent;
  std::string prediction_accuracy;
  std::string updated_at;
  std::vector<InstitutionRatingDetailTargetItem> target_list;
};
 
struct ForecastEpsItem
{
  std::string forecast_eps_median;
  std::string forecast_eps_mean;
  std::string forecast_eps_lowest;
  std::string forecast_eps_highest;
  int32_t institution_total;
  int32_t institution_up;
  int32_t institution_down;
  int64_t forecast_start_date;
  int64_t forecast_end_date;
};
 
struct ForecastEps
{
  std::vector<ForecastEpsItem> items;
};
 
struct ValuationPoint
{
  int64_t timestamp;
  std::string value;
};
 
struct ValuationMetricData
{
  std::string desc;
  std::string high;
  std::string low;
  std::string median;
  std::vector<ValuationPoint> list;
};
 
struct ValuationMetricsData
{
  std::optional<ValuationMetricData> pe;
  std::optional<ValuationMetricData> pb;
  std::optional<ValuationMetricData> ps;
  std::optional<ValuationMetricData> dvd_yld;
};
 
struct ValuationData
{
  ValuationMetricsData metrics;
};
 
struct ValuationHistoryResponse
{
  std::optional<ValuationMetricData> pe;
  std::optional<ValuationMetricData> pb;
  std::optional<ValuationMetricData> ps;
};
 
struct CompanyOverview
{
  std::string name;
  std::string company_name;
  std::string founded;
  std::string listing_date;
  std::string market;
  std::string region;
  std::string address;
  std::string office_address;
  std::string website;
  std::string issue_price;
  std::string shares_offered;
  std::string chairman;
  std::string secretary;
  std::string audit_inst;
  std::string category;
  std::string year_end;
  std::string employees;
  std::string phone;
  std::string fax;
  std::string email;
  std::string legal_repr;
  std::string manager;
  std::string ticker;
  std::string profile;
  int32_t sector;
};
 
struct ShareholderStock
{
  std::string symbol;
  std::string code;
  std::string market;
  std::string chg;
};
 
struct Shareholder
{
  std::string shareholder_id;
  std::string shareholder_name;
  std::string institution_type;
  std::string percent_of_shares;
  std::string shares_changed;
  std::string report_date;
  std::vector<ShareholderStock> stocks;
};
 
struct ShareholderList
{
  std::vector<Shareholder> shareholder_list;
  std::string forward_url;
  int32_t total;
};
 
struct FundHolder
{
  std::string code;
  std::string symbol;
  std::string currency;
  std::string name;
  std::string position_ratio;
  std::string report_date;
};
 
struct FundHolders
{
  std::vector<FundHolder> lists;
};
 
struct CorpActionItem
{
  std::string id;
  std::string date;
  std::string date_str;
  std::string date_type;
  std::string date_zone;
  std::string act_type;
  std::string act_desc;
  std::string action;
  bool recent;
  bool is_delay;
  std::string delay_content;
};
 
struct CorpActions
{
  std::vector<CorpActionItem> items;
};
 
struct InvestSecurity
{
  std::string company_id;
  std::string company_name;
  std::string company_name_en;
  std::string company_name_zhcn;
  std::string symbol;
  std::string currency;
  std::string percent_of_shares;
  std::string shares_rank;
  std::string shares_value;
};
 
struct InvestRelations
{
  std::string forward_url;
  std::vector<InvestSecurity> invest_securities;
};
 
struct OperatingIndicator
{
  std::string field_name;
  std::string indicator_name;
  std::string indicator_value;
  std::string yoy;
};
 
struct OperatingItem
{
  std::string id;
  std::string report;
  std::string title;
  std::string txt;
  bool latest;
  std::string web_url;
  std::string financial_currency;
  std::string financial_name;
  std::string financial_region;
  std::string financial_report;
  std::vector<OperatingIndicator> indicators;
};
 
struct OperatingList
{
  std::vector<OperatingItem> list;
};
 
struct FinancialReports
{
  std::string list_json;
};
 
struct ConsensusDetail
{
  std::string key;
  std::string name;
  std::string description;
  std::string actual;
  std::string estimate;
  std::string comp_value;
  std::string comp_desc;
  std::string comp;
  bool is_released;
};
 
struct ConsensusReport
{
  int32_t fiscal_year;
  std::string fiscal_period;
  std::string period_text;
  std::vector<ConsensusDetail> details;
};
 
struct FinancialConsensus
{
  std::vector<ConsensusReport> list;
  int32_t current_index;
  std::string currency;
  std::vector<std::string> opt_periods;
  std::string current_period;
};
 
struct IndustryValuationHistory
{
  std::string date;
  std::string pe;
  std::string pb;
  std::string ps;
};
 
struct IndustryValuationItem
{
  std::string symbol;
  std::string name;
  std::string currency;
  std::string assets;
  std::string bps;
  std::string eps;
  std::string dps;
  std::string div_yld;
  std::string div_payout_ratio;
  std::string five_y_avg_dps;
  std::string pe;
  std::vector<IndustryValuationHistory> history;
};
 
struct IndustryValuationList
{
  std::vector<IndustryValuationItem> list;
};
 
struct ValuationDist
{
  std::string low;
  std::string high;
  std::string median;
  std::string value;
  std::string ranking;
  std::string rank_index;
  std::string rank_total;
};
 
struct IndustryValuationDist
{
  std::optional<ValuationDist> pe;
  std::optional<ValuationDist> pb;
  std::optional<ValuationDist> ps;
};
 
struct Professional
{
  std::string id;
  std::string name;
  std::string name_zhcn;
  std::string name_en;
  std::string title;
  std::string biography;
  std::string photo;
  std::string wiki_url;
};
 
struct ExecutiveGroup
{
  std::string symbol;
  std::string forward_url;
  int32_t total;
  std::vector<Professional> professionals;
};
 
struct ExecutiveList
{
  std::vector<ExecutiveGroup> professional_list;
};
 
struct RecentBuybacks
{
  std::string currency;
  std::string net_buyback_ttm;
  std::string net_buyback_yield_ttm;
};
 
struct BuybackHistoryItem
{
  std::string fiscal_year;
  std::string fiscal_year_range;
  std::string net_buyback;
  std::string net_buyback_yield;
  std::string net_buyback_growth_rate;
  std::string currency;
};
 
struct BuybackRatios
{
  std::string net_buyback_payout_ratio;
  std::string net_buyback_to_cashflow_ratio;
};
 
struct BuybackData
{
  std::optional<RecentBuybacks> recent_buybacks;
  std::vector<BuybackHistoryItem> buyback_history;
  std::vector<BuybackRatios> buyback_ratios;
};
 
struct RatingLeafIndicator
{
  std::string name;
  std::string value;
  std::string value_type;
  std::string score;
  std::string letter;
};
 
struct RatingIndicator
{
  std::string name;
  std::string score;
  std::string letter;
};
 
struct RatingSubIndicatorGroup
{
  RatingIndicator indicator;
  std::vector<RatingLeafIndicator> sub_indicators;
};
 
struct RatingCategory
{
  int32_t kind;
  std::vector<RatingSubIndicatorGroup> sub_indicators;
};
 
struct StockRatings
{
  std::string style_txt_name;
  std::string scale_txt_name;
  std::string report_period_txt;
  std::string multi_score;
  std::string multi_letter;
  int32_t multi_score_change;
  std::string industry_name;
  std::string industry_rank;
  std::string industry_total;
  std::string industry_mean_score;
  std::string industry_median_score;
  std::vector<RatingCategory> ratings;
};
 
struct BusinessSegmentItem
{
  std::string name;
  std::string percent;
};
 
struct BusinessSegments
{
  std::string date;
  std::string total;
  std::string currency;
  std::vector<BusinessSegmentItem> business;
};
 
struct BusinessSegmentHistoryItem
{
  std::string name;
  std::string percent;
  std::string value;
};
 
struct BusinessSegmentsHistoricalItem
{
  std::string date;
  std::string total;
  std::string currency;
  std::vector<BusinessSegmentHistoryItem> business;
  std::vector<BusinessSegmentHistoryItem> regionals;
};
 
struct BusinessSegmentsHistory
{
  std::vector<BusinessSegmentsHistoricalItem> historical;
};
 
struct InstitutionRatingViewItem
{
  std::string date;
  std::string buy;
  std::string over;
  std::string hold;
  std::string under;
  std::string sell;
  std::string total;
};
 
struct InstitutionRatingViews
{
  std::vector<InstitutionRatingViewItem> elist;
};
 
struct IndustryRankItem
{
  std::string name;
  std::string symbol;
  std::string chg;
  std::string leading_name;
  std::string leading_ticker;
  std::string leading_chg;
  std::string value_name;
  std::string value_data;
};
 
struct IndustryRankGroup
{
  std::vector<IndustryRankItem> lists;
};
 
struct IndustryRankResponse
{
  std::vector<IndustryRankGroup> items;
};
 
struct IndustryPeersTop
{
  std::string name;
  std::string market;
};
 
struct IndustryPeerNode
{
  std::string name;
  std::string symbol;
  int32_t stock_num;
  std::string chg;
  std::string ytd_chg;
  std::string next_json;
};
 
struct IndustryPeersResponse
{
  std::optional<IndustryPeersTop> top;
  std::optional<IndustryPeerNode> chain;
};
 
struct SnapshotForecastMetric
{
  std::string value;
  std::string yoy;
  std::string cmp_desc;
  std::string est_value;
};
 
struct SnapshotReportedMetric
{
  std::string value;
  std::string yoy;
};
 
struct FinancialReportSnapshot
{
  std::string name;
  std::string ticker;
  std::string fp_start;
  std::string fp_end;
  std::string currency;
  std::string report_desc;
  std::optional<SnapshotForecastMetric> fo_revenue;
  std::optional<SnapshotForecastMetric> fo_ebit;
  std::optional<SnapshotForecastMetric> fo_eps;
  std::optional<SnapshotReportedMetric> fr_revenue;
  std::optional<SnapshotReportedMetric> fr_profit;
  std::optional<SnapshotReportedMetric> fr_operate_cash;
  std::optional<SnapshotReportedMetric> fr_invest_cash;
  std::optional<SnapshotReportedMetric> fr_finance_cash;
  std::optional<SnapshotReportedMetric> fr_total_assets;
  std::optional<SnapshotReportedMetric> fr_total_liability;
  std::string fr_roe_ttm;
  std::string fr_profit_margin;
  std::string fr_profit_margin_ttm;
  std::string fr_asset_turn_ttm;
  std::string fr_leverage_ttm;
  std::string fr_debt_assets_ratio;
};
 
struct ValuationHistoryPoint
{
  std::string date;
  std::string pe;
  std::string pb;
  std::string ps;
};
 
struct ValuationComparisonItem
{
  std::string symbol;
  std::string name;
  std::string currency;
  std::string market_value;
  std::string price_close;
  std::string pe;
  std::string pb;
  std::string ps;
  std::string roe;
  std::string eps;
  std::string bps;
  std::string dps;
  std::string div_yld;
  std::string assets;
  std::vector<ValuationHistoryPoint> history;
};
 
struct ValuationComparisonResponse
{
  std::vector<ValuationComparisonItem> list;
};
 
enum class ElementType
{
  Unknown,
  Holdings,
  Regional,
  AssetClass,
  Industry,
};
 
struct HoldingDetail
{
  std::string industry_id;
  std::string industry_name;
  std::string index;
  std::string index_name;
  std::string holding_type;
  std::string holding_type_name;
};
 
struct AssetAllocationItem
{
  std::string name;
  std::string code;
  std::string position_ratio;
  std::string symbol;
  std::map<std::string, std::string> name_locales;
  std::optional<HoldingDetail> holding_detail;
};
 
struct AssetAllocationGroup
{
  std::string report_date;
  ElementType asset_type;
  std::vector<AssetAllocationItem> lists;
};
 
struct AssetAllocationResponse
{
  std::vector<AssetAllocationGroup> info;
};
 
} // namespace fundamental
 
namespace alert {
 
struct AlertValueMap
{
  std::string price;
  std::optional<double> chg;
};
 
struct AlertItem
{
  std::string id;
  std::string indicator_id;
  bool enabled;
  int32_t frequency;
  int32_t scope;
  std::string text;
  std::vector<int32_t> state;
  AlertValueMap value_map;
};
 
struct AlertSymbolGroup
{
  std::string symbol;
  std::string code;
  std::string market;
  std::string name;
  std::string price;
  std::string chg;
  std::string p_chg;
  std::string product;
  std::vector<AlertItem> indicators;
};
 
struct AlertList
{
  std::vector<AlertSymbolGroup> lists;
};
 
} // namespace alert
 
namespace dca {
 
enum class DCAFrequency
{
  Daily       = 0,
  Weekly      = 1,
  Fortnightly = 2,
  Monthly     = 3,
};
 
enum class DCAStatus
{
  Active    = 0,
  Suspended = 1,
  Finished  = 2,
};
 
struct DcaPlan
{
  std::string plan_id;
  DCAStatus status;
  std::string symbol;
  std::string member_id;
  std::string aaid;
  std::string account_channel;
  std::string display_account;
  longbridge::Market market;
  std::string per_invest_amount;
  DCAFrequency invest_frequency;
  std::string invest_day_of_week;
  std::string invest_day_of_month;
  bool allow_margin_finance;
  std::string alter_hours;
  std::string created_at;
  std::string updated_at;
  std::string next_trd_date;
  std::string stock_name;
  std::string cum_amount;
  int64_t issue_number;
  std::string average_cost;
  std::string cum_profit;
};
 
struct DcaList
{
  std::vector<DcaPlan> plans;
};
 
struct DcaStats
{
  std::string active_count;
  std::string finished_count;
  std::string suspended_count;
  std::vector<DcaPlan> nearest_plans;
  std::string rest_days;
  std::string total_amount;
  std::string total_profit;
};
 
struct DcaSupportInfo
{
  std::string symbol;
  bool support_regular_saving;
};
 
struct DcaSupportList
{
  std::vector<DcaSupportInfo> infos;
};
 
struct DcaCalcDateResult
{
  std::string trade_date;
};
 
struct DcaCreateResult
{
  std::string plan_id;
};
 
struct DcaHistoryRecord
{
  std::string created_at;
  std::string order_id;
  std::string status;
  std::string action;
  std::string order_type;
  std::string executed_qty;
  std::string executed_price;
  std::string executed_amount;
  std::string rejected_reason;
  std::string symbol;
};
 
struct DcaHistoryResponse
{
  std::vector<DcaHistoryRecord> records;
  bool has_more;
};
 
} // namespace dca
 
namespace sharelist {
 
struct SharelistStock
{
  std::string symbol;
  std::string name;
  std::string market;
  std::string code;
  std::string intro;
  std::string unread_change_log_category;
  std::optional<std::string> change;
  std::optional<std::string> last_done;
  std::optional<int32_t> trade_status;
};
 
struct SharelistScopes
{
  bool subscription;
  bool is_self;
};
 
struct SharelistInfo
{
  int64_t id;
  std::string name;
  std::string description;
  std::string cover;
  int64_t subscribers_count;
  int64_t created_at;
  int64_t edited_at;
  std::string this_year_chg;
  std::string creator;
  std::vector<SharelistStock> stocks;
  bool subscribed;
  std::string chg;
  int32_t sharelist_type;
  std::string industry_code;
};
 
struct SharelistList
{
  std::vector<SharelistInfo> sharelists;
  std::vector<SharelistInfo> subscribed_sharelists;
  std::string tail_mark;
};
 
struct SharelistDetail
{
  SharelistInfo sharelist;
  SharelistScopes scopes;
};
 
} // namespace sharelist
 
namespace agent {
 
struct Workspace
{
  std::string id;
  std::string name;
  int64_t created_at;
  int64_t updated_at;
};
 
struct WorkspacesResponse
{
  std::vector<Workspace> workspaces;
};
 
struct Agent
{
  std::string uid;
  std::string name;
  std::string description;
  std::string mode;
  std::string icon;
  bool is_published;
  int64_t published_at;
  int64_t created_at;
  int64_t updated_at;
};
 
struct AgentsResponse
{
  std::vector<Agent> agents;
  int32_t total;
};
 
struct GetAgentsOptions
{
  std::optional<int32_t> page;
  std::optional<int32_t> limit;
  std::optional<std::string> name;
};
 
struct Reference
{
  int32_t index;
  int32_t original_index;
  std::string ref_type;
  std::string id;
  std::string title;
  std::string url;
  std::string content_json;
};
 
struct QuestionOption
{
  std::string label;
  std::string description;
};
 
struct Question
{
  std::string question;
  std::vector<QuestionOption> options;
  bool multi_select;
};
 
struct HumanInteraction
{
  std::string tool_call_id;
  std::string interrupt_id;
  std::string interaction_type;
  std::string tool_name;
  std::vector<Question> questions;
  std::string tool_args_json;
};
 
struct Interrupt
{
  std::string node_id;
  std::string tool_call_id;
  std::vector<Question> questions;
  std::vector<HumanInteraction> interactions;
  int64_t message_id;
  int64_t chat_id;
};
 
struct AgentError
{
  int32_t code;
  std::string message;
};
 
enum class ConversationStatus
{
  Succeeded,
  Interrupted,
  Failed,
  Stopped,
};
 
struct ConversationResponse
{
  std::string chat_uid;
  std::string message_id;
  ConversationStatus status;
  std::string answer;
  std::vector<Reference> references;
  std::vector<std::string> further_questions;
  double elapsed_time;
  std::optional<Interrupt> interrupt;
  std::optional<AgentError> error;
};
 
struct ChatStartedPayload
{
  std::string chat_uid;
  int64_t chat_id;
  std::string message_id;
  std::string error;
  std::string error_message;
};
 
struct MessagePayload
{
  std::string text;
  std::string message_type;
  std::string key;
  int64_t started_at;
  std::string stage;
  std::string stage_title;
  std::string stage_finished_title;
  std::string outputs_json;
};
 
struct WorkflowStartedInputs
{
  int64_t chat_id;
  std::string chat_uid;
  std::string message_id;
  std::string query;
};
 
struct WorkflowStartedPayload
{
  bool hit_cache;
  WorkflowStartedInputs inputs;
  int64_t started_at;
  int64_t workflow_id;
};
 
struct ThinkingStartedPayload
{
  int64_t started_at;
};
 
struct ThinkingFinishedPayload
{
  int64_t finished_at;
  int32_t elapsed_time;
};
 
struct NodeToolUseStartedPayload
{
  std::string tool_use_id;
  std::string tool_name;
  std::string tool_func_name;
  std::string tool_args;
  std::string tips;
  std::vector<std::string> tip_chips;
  int32_t iteration;
  int64_t started_at;
};
 
struct NodeToolUseOutputs
{
  std::vector<Reference> references;
  std::vector<std::string> reference_domains;
  std::string query;
  std::string text;
  std::string tool_args_json;
  std::string data_json;
};
 
struct NodeToolUseFinishedPayload
{
  std::string tool_use_id;
  std::string status;
  std::string error;
  double elapsed_time;
  int64_t started_at;
  std::string tool_name;
  std::string tool_func_name;
  std::string tool_args;
  std::string tool_type;
  std::string tips;
  std::vector<std::string> tip_chips;
  int32_t iteration;
  bool is_thinking;
  NodeToolUseOutputs outputs;
};
 
struct SubagentStartedPayload
{
  std::string node_id;
  std::string tool_use_id;
  int64_t started_at;
  std::string goal;
  std::string prompt;
  std::string subagent_id;
  std::string tools_json;
};
 
struct SubagentProgressPayload
{
  std::string node_id;
  std::string parent_tool_call_id;
  std::string subagent_tool_name;
  std::string subagent_tool_args;
  std::string subagent_status;
  int64_t subagent_duration_ms;
  int32_t subagent_iteration;
  int64_t started_at;
};
 
struct SubagentOutputs
{
  std::string goal;
  std::string result;
  std::string subagent_tools_json;
};
 
struct SubagentFinishedPayload
{
  std::string node_id;
  std::string tool_use_id;
  std::string status;
  int64_t started_at;
  double elapsed_time;
  std::string error;
  SubagentOutputs outputs;
};
 
struct AgentToolStartedPayload
{
  std::string node_id;
  std::string tool_use_id;
  std::string agent_tool_name;
  std::string title;
  int64_t started_at;
  std::string tool_args;
  std::string tool_name;
  std::string tips;
  std::vector<std::string> tip_chips;
  bool is_thinking;
};
 
struct AgentToolProgressPayload
{
  std::string node_id;
  std::string parent_tool_call_id;
  std::string agent_tool_name;
  std::string inner_tool_name;
  std::string inner_tool_args;
  std::string status;
  int64_t duration_ms;
  int64_t started_at;
  bool is_thinking;
};
 
struct AgentToolFinishedPayload
{
  std::string node_id;
  std::string tool_use_id;
  std::string agent_tool_name;
  std::string status;
  int64_t started_at;
  double elapsed_time;
  std::string error;
  std::string tool_args;
  std::string outputs_json;
  std::string tool_type;
  std::string tips;
  std::vector<std::string> tip_chips;
  bool is_thinking;
};
 
struct QueryMaskedPayload
{
  std::string raw_query;
  std::string masked_query;
};
 
struct PlanChangedPayload
{
  std::string node_id;
  int64_t started_at;
  std::string outputs_json;
  std::string tool_name;
};
 
struct ContextCompressStartedPayload
{
  std::string started_at;
  std::string inputs_json;
};
 
struct ContextCompressFinishedPayload
{
  std::string created_at;
  std::string inputs_json;
  std::string outputs_json;
};
 
struct ChatFinishedPayload
{
  int64_t chat_id;
  std::string chat_uid;
  std::string message_id;
  std::string error;
  std::string error_message;
};
 
struct ChatTitleUpdatedPayload
{
  int64_t chat_id;
  std::string chat_uid;
  std::string source;
  std::string title;
  int64_t updated_at;
};
 
enum class ConversationStreamEventKind
{
  ChatStarted,
  WorkflowStarted,
  Message,
  Ping,
  ThinkingStarted,
  ThinkingFinished,
  NodeToolUseStarted,
  NodeToolUseFinished,
  SubagentStarted,
  SubagentProgress,
  SubagentFinished,
  AgentToolStarted,
  AgentToolProgress,
  AgentToolFinished,
  HumanInteractionRequired,
  QueryMasked,
  PlanChanged,
  ContextCompressStarted,
  ContextCompressFinished,
  ChatFinished,
  WorkflowFinished,
  ChatTitleUpdated,
  Other,
};
 
struct ConversationStreamEvent
{
  ConversationStreamEventKind kind;
  std::optional<ChatStartedPayload> chat_started;
  std::optional<WorkflowStartedPayload> workflow_started;
  std::optional<MessagePayload> message;
  std::optional<ThinkingStartedPayload> thinking_started;
  std::optional<ThinkingFinishedPayload> thinking_finished;
  std::optional<NodeToolUseStartedPayload> node_tool_use_started;
  std::optional<NodeToolUseFinishedPayload> node_tool_use_finished;
  std::optional<SubagentStartedPayload> subagent_started;
  std::optional<SubagentProgressPayload> subagent_progress;
  std::optional<SubagentFinishedPayload> subagent_finished;
  std::optional<AgentToolStartedPayload> agent_tool_started;
  std::optional<AgentToolProgressPayload> agent_tool_progress;
  std::optional<AgentToolFinishedPayload> agent_tool_finished;
  std::optional<ConversationResponse> human_interaction_required;
  std::optional<QueryMaskedPayload> query_masked;
  std::optional<PlanChangedPayload> plan_changed;
  std::optional<ContextCompressStartedPayload> context_compress_started;
  std::optional<ContextCompressFinishedPayload> context_compress_finished;
  std::optional<ChatFinishedPayload> chat_finished;
  std::optional<ConversationResponse> workflow_finished;
  std::optional<ChatTitleUpdatedPayload> chat_title_updated;
  std::optional<std::string> other_event;
  std::optional<std::string> other_json;
};
 
} // namespace agent
 
} // namespace longbridge