types.hpp

Go to the documentation of this file.

#pragma once
 
#include "decimal.hpp"
#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,
};
 
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 StrikePriceInfo
{
  Decimal price;
  std::string call_symbol;
  std::string put_symbol;
  bool standard;
};
 
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
{
  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;
  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;
};
 
} // namespace quote
 
namespace trade {
 
enum class TopicType
{
  Private,
};
 
struct Execution
{
  std::string order_id;
  std::string trade_id;
  std::string symbol;
  int64_t trade_done_at;
  Decimal quantity;
  Decimal price;
};
 
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;
};
 
enum class OrderStatus
{
  Unknown,
  NotReported,
  ReplacedNotReported,
  ProtectedNotReported,
  VarietiesNotReported,
  Filled,
  WaitToNew,
  New,
  WaitToReplace,
  PendingReplace,
  Replaced,
  PartialFilled,
  WaitToCancel,
  PendingCancel,
  Rejected,
  Canceled,
  Expired,
  PartialWithdrawal,
};
 
enum class OrderSide
{
  Unknown,
  Buy,
  Sell,
};
 
enum class OrderType
{
  Unknown,
  LO,
  ELO,
  MO,
  AO,
  ALO,
  ODD,
  LIT,
  MIT,
  TSLPAMT,
  TSLPPCT,
  TSMAMT,
  TSMPCT,
  SLO,
};
 
enum class OrderTag
{
  Unknown,
  Normal,
  LongTerm,
  Grey,
  MarginCall,
  Offline,
  Creditor,
  Debtor,
  NonExercise,
  AllocatedSub,
};
 
enum class TimeInForceType
{
  Unknown,
  Day,
  GoodTilCanceled,
  GoodTilDate,
};
 
enum class TriggerStatus
{
  Unknown,
  Deactive,
  Active,
  Released,
};
 
enum class OutsideRTH
{
  Unknown,
  RTHOnly,
  AnyTime,
  Overnight,
};
 
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;
};
 
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;
};
 
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;
};
 
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;
};
 
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;
};
 
struct SubmitOrderResponse
{
  std::string order_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;
  OrderChargeDetail charge_detail;
};
 
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;
};
 
} // namespace trade
 
} // namespace longbridge