Market Data

use tigeropen::client::http_client::HttpClient;
use tigeropen::config::ClientConfig;
use tigeropen::quote::QuoteClient;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let config = ClientConfig::builder().build()?;
    let http = HttpClient::with_quote_server(config);
    let qc = QuoteClient::new(&http);

    // Get US market status
    let states = qc.get_market_state("US").await?;
    println!("US market state: {:?}", states);

    // Get real-time quotes (v0.4.0: Request struct)
    let briefs = qc.get_brief(BriefRequest {
        symbols: Some(vec!["AAPL".to_string(), "TSLA".to_string()]),
        ..Default::default()
    }).await?;
    for b in &briefs {
        println!("{} latest_price={}", b.symbol, b.latest_price);
    }

    // Get daily candlestick data
    let klines = qc.get_kline("AAPL", "day").await?;
    for k in &klines {
        println!("{} bars={}", k.symbol, k.items.len());
    }

    Ok(())
}

pub async fn get_market_state(&self, market: &str) -> Result<Vec<MarketState>, TigerError>

let states = qc.get_market_state("US").await?;
for s in &states {
    println!("{}: {} openTime={}", s.market, s.market_status, s.open_time);
}

{ "market": "US" }

[
  {
    "market": "US",
    "status": "trading",
    "openTime": 1735020600000,
    "closeTime": 1735044000000,
    "timezone": "America/New_York"
  }
]

pub async fn get_brief(&self, req: BriefRequest) -> Result<Vec<Brief>, TigerError>

use tigeropen::model::quote_requests::BriefRequest;

let briefs = qc.get_brief(BriefRequest {
    symbols: Some(vec!["AAPL".to_string(), "TSLA".to_string()]),
    ..Default::default()
}).await?;
for b in &briefs {
    println!("{}: latest_price={}", b.symbol, b.latest_price);
}

{ "symbols": ["AAPL", "TSLA"] }

[
  {
    "symbol": "AAPL",
    "market": "US",
    "name": "Apple Inc.",
    "latestPrice": 227.52,
    "preClose": 225.01,
    "change": 2.51,
    "changePercentage": 1.115,
    "volume": 62345678,
    "amount": 14189233280.0,
    "open": 225.50,
    "high": 228.10,
    "low": 224.80,
    "timestamp": 1735042800000
  },
  {
    "symbol": "TSLA",
    "market": "US",
    "name": "Tesla Inc.",
    "latestPrice": 410.44,
    "preClose": 403.84,
    "change": 6.60,
    "changePercentage": 1.634,
    "volume": 98765432,
    "amount": 40542123456.0,
    "open": 405.00,
    "high": 415.20,
    "low": 402.30,
    "timestamp": 1735042800000
  }
]

pub async fn get_kline(&self, symbol: &str, period: &str) -> Result<Vec<Kline>, TigerError>

let daily = qc.get_kline("AAPL", "day").await?;
for k in &daily {
    for bar in &k.items {
        println!("O={} H={} L={} C={}", bar.open, bar.high, bar.low, bar.close);
    }
}

{ "symbols": ["AAPL"], "period": "day" }

[
  {
    "symbol": "AAPL",
    "period": "day",
    "items": [
      {
        "time": 1734912000000,
        "open": 222.56,
        "high": 225.72,
        "low": 222.11,
        "close": 225.01,
        "volume": 55234100
      },
      {
        "time": 1734998400000,
        "open": 225.50,
        "high": 228.10,
        "low": 224.80,
        "close": 227.52,
        "volume": 62345678
      }
    ]
  }
]

pub async fn get_timeline(&self, symbols: &[&str]) -> Result<Vec<Timeline>, TigerError>

let timelines = qc.get_timeline(&["AAPL"]).await?;
for tl in &timelines {
    let count = tl.intraday.as_ref().map(|b| b.items.len()).unwrap_or(0);
    println!("{} intraday_points={} preClose={}", tl.symbol, count, tl.pre_close);
}

{ "symbols": ["AAPL"] }

{
  "symbol": "AAPL",
  "items": [
    {
      "time": 1735020600000,
      "price": 225.50,
      "volume": 3021456,
      "avgPrice": 225.48
    },
    {
      "time": 1735020660000,
      "price": 225.80,
      "volume": 1234567,
      "avgPrice": 225.55
    }
  ]
}

pub async fn get_trade_tick(&self, req: TradeTickRequest) -> Result<Vec<TradeTick>, TigerError>

use tigeropen::model::quote_requests::TradeTickRequest;

let ticks = qc.get_trade_tick(TradeTickRequest {
    symbols: Some(vec!["AAPL".to_string()]),
    ..Default::default()
}).await?;
for t in &ticks {
    println!("{} ticks={}", t.symbol, t.items.len());
}

**Data Example**

Request parameters:
```json
{ "symbols": ["AAPL"] }

{
  "symbol": "AAPL",
  "items": [
    {
      "time": 1735042780000,
      "price": 227.52,
      "volume": 100,
      "type": "BUY"
    },
    {
      "time": 1735042781000,
      "price": 227.50,
      "volume": 200,
      "type": "SELL"
    }
  ]
}

pub async fn get_quote_depth(&self, req: DepthQuoteRequest) -> Result<Vec<Depth>, TigerError>

use tigeropen::model::quote_requests::DepthQuoteRequest;

let depths = qc.get_quote_depth(DepthQuoteRequest {
    symbols: Some(vec!["AAPL".to_string()]),
    market: Some("US".to_string()),
    ..Default::default()
}).await?;
if let Some(d) = depths.first() {
    println!("{}: asks={} bids={}", d.symbol, d.asks.len(), d.bids.len());
}

pub async fn get_option_expiration(&self, symbol: &str) -> Result<Vec<OptionExpiration>, TigerError>

let exps = qc.get_option_expiration("AAPL").await?;
if let Some(e) = exps.first() {
    for date in &e.dates {
        println!("Expiry: {}", date);
    }
}

{ "symbols": ["AAPL"] }

[
  {
    "symbol": "AAPL",
    "dates": ["2025-01-17", "2025-02-21", "2025-03-21"],
    "timestamps": [1737081600000, 1740096000000, 1742515200000],
    "periods": ["weekly", "monthly", "monthly"]
  }
]

pub async fn get_option_chain(&self, symbol: &str, expiry: &str) -> Result<Vec<OptionChain>, TigerError>

let chain = qc.get_option_chain("AAPL", "2025-01-17").await?;
if let Some(c) = chain.first() {
    println!("{} rows={}", c.symbol, c.items.len());
    for row in &c.items {
        if let Some(call) = &row.call {
            println!("call {} strike={}", call.identifier, call.strike);
        }
    }
}

{ "option_basic": [{ "symbol": "AAPL", "expiry": 1737081600000 }] }

[
  {
    "strike": 220.0,
    "callSymbol": "AAPL  250117C00220000",
    "putSymbol": "AAPL  250117P00220000",
    "callLatestPrice": 9.50,
    "putLatestPrice": 2.10,
    "callImpliedVolatility": 0.285,
    "putImpliedVolatility": 0.312
  }
]

pub async fn get_option_brief(&self, identifiers: &[&str]) -> Result<Vec<OptionBrief>, TigerError>

let briefs = qc.get_option_brief(&["AAPL  250117C00150000"]).await?;
for b in &briefs {
    println!("{} latest_price={}", b.symbol, b.latest_price);
}

{
  "option_basic": [
    { "symbol": "AAPL", "expiry": 1737081600000, "right": "CALL", "strike": 150.0 }
  ]
}

[
  {
    "identifier": "AAPL  250117C00220000",
    "latestPrice": 9.50,
    "preClose": 9.10,
    "change": 0.40,
    "impliedVolatility": 0.285,
    "delta": 0.612,
    "gamma": 0.028,
    "theta": -0.085,
    "vega": 0.156,
    "openInterest": 12540,
    "volume": 3820
  }
]

pub async fn get_option_kline(&self, identifier: &str, period: &str) -> Result<Vec<OptionKline>, TigerError>

let klines = qc.get_option_kline("AAPL  250117C00150000", "day").await?;
for k in &klines {
    println!("bars={}", k.items.len());
}

{
  "option_query": [
    { "symbol": "AAPL", "expiry": 1737081600000, "right": "CALL", "strike": 150.0, "period": "day" }
  ]
}

[
  {
    "symbol": "AAPL  250117C00150000",
    "period": "day",
    "items": [
      { "time": 1734912000000, "open": 8.80, "high": 9.60, "low": 8.70, "close": 9.10, "volume": 2100 },
      { "time": 1734998400000, "open": 9.10, "high": 9.80, "low": 9.00, "close": 9.50, "volume": 3820 }
    ]
  }
]

pub async fn get_future_exchange(&self) -> Result<Vec<FutureExchange>, TigerError>

let exchanges = qc.get_future_exchange().await?;
for ex in &exchanges {
    println!("{}: {}", ex.code, ex.name);
}

[
  { "code": "CME", "name": "Chicago Mercantile Exchange", "zoneId": "America/Chicago" },
  { "code": "CBOT", "name": "Chicago Board of Trade", "zoneId": "America/Chicago" },
  { "code": "NYMEX", "name": "New York Mercantile Exchange", "zoneId": "America/New_York" },
  { "code": "HKEX", "name": "Hong Kong Exchanges and Clearing", "zoneId": "Asia/Hong_Kong" }
]

pub async fn get_future_contracts(&self, exchange_code: &str) -> Result<Vec<FutureContractInfo>, TigerError>

let contracts = qc.get_future_contracts("CME").await?;
for c in &contracts {
    println!("{} {}", c.contract_code, c.name);
}

{ "exchange_code": "CME" }

[
  {
    "contractCode": "ES2506",
    "name": "E-mini S&P 500",
    "multiplier": 50,
    "currency": "USD",
    "minTick": 0.25,
    "exchange": "CME"
  }
]

pub async fn get_future_real_time_quote(&self, req: FutureBriefRequest) -> Result<Vec<FutureQuote>, TigerError>

use tigeropen::model::quote_requests::FutureBriefRequest;

let quotes = qc.get_future_real_time_quote(FutureBriefRequest {
    contract_codes: Some(vec!["ES2506".to_string(), "NQ2506".to_string()]),
    ..Default::default()
}).await?;
for q in &quotes {
    println!("{} latest_price={}", q.contract_code, q.latest_price);
}

pub async fn get_future_kline(&self, req: FutureKlineRequest) -> Result<Vec<FutureKline>, TigerError>

use tigeropen::model::quote::FutureKlineRequest;

let klines = qc.get_future_kline(FutureKlineRequest {
    contract_codes: vec!["ES2506".into()],
    period: "day".into(),
    begin_time: -1,
    end_time: -1,
    limit: None,
    page_token: None,
}).await?;

for k in &klines {
    println!("bars={}", k.items.len());
}

{ "contract_codes": ["ES2506"], "period": "day", "begin_time": -1, "end_time": -1 }

[
  {
    "items": [
      { "time": 1734912000000, "open": 5870.00, "high": 5900.00, "low": 5860.00, "close": 5895.25, "volume": 1023456 },
      { "time": 1734998400000, "open": 5900.00, "high": 5935.00, "low": 5895.00, "close": 5920.50, "volume": 1234567 }
    ]
  }
]

pub async fn get_financial_daily(&self, req: FinancialDailyRequest) -> Result<Vec<FinancialDailyItem>, TigerError>

use tigeropen::model::quote::FinancialDailyRequest;

let items = qc.get_financial_daily(FinancialDailyRequest {
    symbols: vec!["AAPL".into()],
    market: "US".into(),
    fields: vec!["shares_outstanding".into()],
    begin_date: "2025-01-01".into(),
    end_date: "2025-01-31".into(),
}).await?;
println!("rows={}", items.len());

pub async fn get_capital_flow(
    &self,
    symbol: &str,
    market: &str,
    period: &str,
) -> Result<Option<CapitalFlow>, TigerError>

if let Some(cf) = qc.get_capital_flow("AAPL", "US", "day").await? {
    println!("{} period={} rows={}", cf.symbol, cf.period, cf.items.len());
}

{ "symbol": "AAPL", "market": "US", "period": "day" }

{
  "symbol": "AAPL",
  "inflow": 8234567890,
  "outflow": 7123456789,
  "netInflow": 1111111101,
  "largeOrderInflow": 5123456789,
  "largeOrderOutflow": 4012345678,
  "mediumOrderInflow": 2012345678,
  "smallOrderInflow": 1098765432,
  "timestamp": 1735042800000
}

pub async fn get_capital_distribution(
    &self,
    symbol: &str,
    market: &str,
) -> Result<Option<CapitalDistribution>, TigerError>

if let Some(cd) = qc.get_capital_distribution("AAPL", "US").await? {
    println!("{} netInflow={}", cd.symbol, cd.net_inflow);
}

{ "symbol": "AAPL", "market": "US" }

{
  "symbol": "AAPL",
  "netInflow": 1111111101,
  "inAll": 8234567890,
  "inBig": 5123456789,
  "inMid": 2012345678,
  "inSmall": 1098765432,
  "outAll": 7123456789,
  "outBig": 4012345678,
  "outMid": 1912345678,
  "outSmall": 1198765432
}

pub async fn market_scanner(&self, req: MarketScannerRequest) -> Result<Option<ScannerResult>, TigerError>

use tigeropen::model::quote::MarketScannerRequest;

if let Some(r) = qc.market_scanner(MarketScannerRequest {
    market: "US".into(),
    page: Some(0),
    page_size: Some(10),
    ..Default::default()
}).await? {
    println!("page={}/{} total={} items={}", r.page, r.total_page, r.total_count, r.items.len());
}

{ "market": "US", "page": 0, "page_size": 10 }

[
  {
    "symbol": "AAPL",
    "name": "Apple Inc.",
    "latestPrice": 227.52,
    "changePercentage": 1.115,
    "marketCap": 3420000000000,
    "volume": 62345678
  },
  {
    "symbol": "NVDA",
    "name": "NVIDIA Corporation",
    "latestPrice": 138.85,
    "changePercentage": 3.240,
    "marketCap": 3390000000000,
    "volume": 185432100
  }
]

pub async fn grab_quote_permission(&self) -> Result<Vec<QuotePermission>, TigerError>

let perms = qc.grab_quote_permission().await?;
for p in &perms {
    println!("{} expires_at={}", p.name, p.expire_at);
}

[
  { "name": "usStockQuote", "expireAt": 1735042800000 },
  { "name": "hkStockQuote", "expireAt": 1735042800000 }
]

use tigeropen::model::quote_requests::TradingCalendarRequest;

let calendar = qc.get_trading_calendar(TradingCalendarRequest {
    market: Some("US".to_string()),
    begin_date: Some("2025-01-01".to_string()),
    end_date: Some("2025-12-31".to_string()),
    ..Default::default()
}).await?;