futucli/cli/dispatch/

qot.rs

use anyhow::Result;

use super::super::commands::{
    BrokerArgs, CapitalFlowArgs, CompanyExecutiveBackgroundArgs, CompanyExecutivesArgs,
    CompanyOperationalEfficiencyArgs, CompanyProfileArgs, CorporateActionsBuybacksArgs,
    CorporateActionsDividendsArgs, CorporateActionsStockSplitsArgs, DailyShortVolumeArgs,
    DerivativeUnusualArgs, FinancialCalendarArgs, FinancialCalendarTargetArgs,
    FinancialUnusualArgs, FinancialsEarningsPriceHistoryArgs, FinancialsEarningsPriceMoveArgs,
    FinancialsRevenueBreakdownArgs, FinancialsStatementsArgs, IndicatorListArgs,
    InsiderHolderListArgs, InsiderTradeListArgs, IpoCalendarArgs, KlineArgs,
    OptionExerciseProbabilityArgs, OptionScreenArgs, OptionVolatilityArgs, OrderbookArgs,
    PlateListArgs, PlateStocksArgs, ProtoJsonArgs, QuoteArgs, ReferenceArgs,
    ResearchAnalystConsensusArgs, ResearchMorningstarReportArgs, ResearchRatingSummaryArgs, RtArgs,
    ShareholdersHolderDetailArgs, ShareholdersHoldingChangesArgs, ShareholdersInstitutionalArgs,
    ShareholdersOverviewArgs, ShortInterestArgs, SnapshotArgs, StaticArgs, StockScreenArgs,
    SubArgs, TechnicalUnusualArgs, TickerArgs, TopTenBuySellBrokersArgs, ValuationDetailArgs,
    ValuationPlateStockListArgs, WarrantScreenArgs,
};
use crate::cmd;
use crate::output::OutputFormat;

pub(super) async fn dispatch_quote(
    gateway: &str,
    output: OutputFormat,
    args: QuoteArgs,
) -> Result<()> {
    cmd::quote::run(gateway, &args.symbols, output).await
}

pub(super) async fn dispatch_snapshot(
    gateway: &str,
    output: OutputFormat,
    args: SnapshotArgs,
) -> Result<()> {
    cmd::snapshot::run(gateway, &args.symbols, output).await
}

pub(super) async fn dispatch_sub(gateway: &str, output: OutputFormat, args: SubArgs) -> Result<()> {
    cmd::sub::run(
        gateway,
        &args.symbols,
        &args.r#type,
        args.extended_time,
        args.session.as_deref(),
        args.orderbook_detail,
        output,
    )
    .await
}

pub(super) async fn dispatch_kline(
    gateway: &str,
    output: OutputFormat,
    args: KlineArgs,
) -> Result<()> {
    // v1.4.83 §10: positional 或 --symbol/--code/--stock flag 二选一
    let symbol = args.symbol_positional.or(args.symbol_arg).ok_or_else(|| {
        anyhow::anyhow!(
            "kline: 需要 positional <SYMBOL> 或 --symbol/--code/--stock \
             (如 `futucli kline US.AAPL` 或 `futucli kline --code US.AAPL`)"
        )
    })?;
    cmd::kline::run_with_format(
        gateway,
        &symbol,
        &args.r#type,
        args.count,
        &args.rehab_type,
        args.page_size,
        args.next_req_key.as_deref(),
        args.need_kl_fields_flag,
        args.extended_time,
        args.session.as_deref(),
        args.begin.as_deref(),
        args.end.as_deref(),
        output,
    )
    .await
}

pub(super) async fn dispatch_orderbook(
    gateway: &str,
    output: OutputFormat,
    args: OrderbookArgs,
) -> Result<()> {
    let symbol = args.symbol_positional.or(args.symbol_arg).ok_or_else(|| {
        anyhow::anyhow!("orderbook: 需要 positional <SYMBOL> 或 --symbol/--code/--stock")
    })?;
    cmd::orderbook::run(gateway, &symbol, args.depth, args.odd_lot, output).await
}

pub(super) async fn dispatch_ticker(
    gateway: &str,
    output: OutputFormat,
    args: TickerArgs,
) -> Result<()> {
    let symbol = args.symbol_positional.or(args.symbol_arg).ok_or_else(|| {
        anyhow::anyhow!("ticker: 需要 positional <SYMBOL> 或 --symbol/--code/--stock")
    })?;
    cmd::ticker::run(gateway, &symbol, args.count, output).await
}

pub(super) async fn dispatch_rt(gateway: &str, output: OutputFormat, args: RtArgs) -> Result<()> {
    let symbol = args.symbol_positional.or(args.symbol_arg).ok_or_else(|| {
        anyhow::anyhow!("rt: 需要 positional <SYMBOL> 或 --symbol/--code/--stock")
    })?;
    cmd::rt::run(gateway, &symbol, output).await
}

pub(super) async fn dispatch_static(
    gateway: &str,
    output: OutputFormat,
    args: StaticArgs,
) -> Result<()> {
    cmd::static_info::run(gateway, &args.symbols, output).await
}

pub(super) async fn dispatch_broker(
    gateway: &str,
    output: OutputFormat,
    args: BrokerArgs,
) -> Result<()> {
    let symbol = args.symbol_positional.or(args.symbol_arg).ok_or_else(|| {
        anyhow::anyhow!("broker: 需要 positional <SYMBOL> 或 --symbol/--code/--stock")
    })?;
    cmd::broker::run(gateway, &symbol, output).await
}

pub(super) async fn dispatch_plate_list(
    gateway: &str,
    output: OutputFormat,
    args: PlateListArgs,
) -> Result<()> {
    cmd::plate::list(gateway, &args.market, &args.set, output).await
}

pub(super) async fn dispatch_plate_stocks(
    gateway: &str,
    output: OutputFormat,
    args: PlateStocksArgs,
) -> Result<()> {
    let plate = args
        .plate
        .or(args.plate_arg)
        .ok_or_else(|| anyhow::anyhow!("plate-stocks: 需要位置参数 <PLATE> 或 --plate"))?;
    cmd::plate::stocks(gateway, &plate, output).await
}

pub(super) async fn dispatch_reference(
    gateway: &str,
    output: OutputFormat,
    args: ReferenceArgs,
) -> Result<()> {
    let symbol = args.symbol_positional.or(args.symbol_arg).ok_or_else(|| {
        anyhow::anyhow!("reference: 需要位置参数 <SYMBOL> 或 --symbol/--code/--stock")
    })?;
    cmd::analysis::run_reference(gateway, &symbol, &args.reference_type, output).await
}

pub(super) async fn dispatch_option_quote(
    gateway: &str,
    output: OutputFormat,
    args: ProtoJsonArgs,
) -> Result<()> {
    cmd::proto_json::run_option_quote(gateway, &args.c2s_json, output).await
}

pub(super) async fn dispatch_option_strategy(
    gateway: &str,
    output: OutputFormat,
    args: ProtoJsonArgs,
) -> Result<()> {
    cmd::proto_json::run_option_strategy(gateway, &args.c2s_json, output).await
}

pub(super) async fn dispatch_option_strategy_analysis(
    gateway: &str,
    output: OutputFormat,
    args: ProtoJsonArgs,
) -> Result<()> {
    cmd::proto_json::run_option_strategy_analysis(gateway, &args.c2s_json, output).await
}

pub(super) async fn dispatch_option_strategy_spread(
    gateway: &str,
    output: OutputFormat,
    args: ProtoJsonArgs,
) -> Result<()> {
    cmd::proto_json::run_option_strategy_spread(gateway, &args.c2s_json, output).await
}

macro_rules! qot_proto_json_dispatch {
    ($fn_name:ident, $runner:ident) => {
        pub(super) async fn $fn_name(
            gateway: &str,
            output: OutputFormat,
            args: ProtoJsonArgs,
        ) -> Result<()> {
            cmd::proto_json::$runner(gateway, &args.c2s_json, output).await
        }
    };
}

qot_proto_json_dispatch!(dispatch_earnings_calendar, run_earnings_calendar);
qot_proto_json_dispatch!(dispatch_macro_indicator_list, run_macro_indicator_list);
qot_proto_json_dispatch!(
    dispatch_security_trading_sessions,
    run_security_trading_sessions
);
qot_proto_json_dispatch!(
    dispatch_market_trading_sessions,
    run_market_trading_sessions
);
qot_proto_json_dispatch!(dispatch_kline_pattern, run_kline_pattern);
qot_proto_json_dispatch!(
    dispatch_kline_pattern_statistics,
    run_kline_pattern_statistics
);
qot_proto_json_dispatch!(dispatch_kline_pattern_stocks, run_kline_pattern_stocks);
qot_proto_json_dispatch!(
    dispatch_kline_pattern_performance,
    run_kline_pattern_performance
);
qot_proto_json_dispatch!(dispatch_kline_pattern_catalog, run_kline_pattern_catalog);
qot_proto_json_dispatch!(dispatch_hot_news, run_hot_news);
qot_proto_json_dispatch!(dispatch_latest_news, run_latest_news);
qot_proto_json_dispatch!(dispatch_watchlist_news, run_watchlist_news);
qot_proto_json_dispatch!(dispatch_watchlist_announcement, run_watchlist_announcement);
qot_proto_json_dispatch!(dispatch_watchlist_rating, run_watchlist_rating);
qot_proto_json_dispatch!(dispatch_stock_news, run_stock_news);
qot_proto_json_dispatch!(dispatch_etf_screen, run_etf_screen);
qot_proto_json_dispatch!(dispatch_fund_screen, run_fund_screen);
qot_proto_json_dispatch!(dispatch_future_screen, run_future_screen);
qot_proto_json_dispatch!(dispatch_bond_screen, run_bond_screen);

pub(super) async fn dispatch_indicator_list(
    gateway: &str,
    output: OutputFormat,
    args: IndicatorListArgs,
) -> Result<()> {
    cmd::proto_json::run_indicator_list(gateway, &args.c2s_json, output).await
}

qot_proto_json_dispatch!(
    dispatch_macro_indicator_history,
    run_macro_indicator_history
);
qot_proto_json_dispatch!(dispatch_fed_watch_target_rate, run_fed_watch_target_rate);
qot_proto_json_dispatch!(dispatch_fed_watch_dot_plot, run_fed_watch_dot_plot);
qot_proto_json_dispatch!(dispatch_earnings_beat_rank, run_earnings_beat_rank);
qot_proto_json_dispatch!(dispatch_dividend_rank, run_dividend_rank);
qot_proto_json_dispatch!(dispatch_dividend_calendar, run_dividend_calendar);
qot_proto_json_dispatch!(dispatch_economic_calendar, run_economic_calendar);
qot_proto_json_dispatch!(dispatch_us_pre_market_rank, run_us_pre_market_rank);
qot_proto_json_dispatch!(dispatch_us_after_hours_rank, run_us_after_hours_rank);
qot_proto_json_dispatch!(dispatch_us_overnight_rank, run_us_overnight_rank);
qot_proto_json_dispatch!(dispatch_top_movers_rank, run_top_movers_rank);
qot_proto_json_dispatch!(dispatch_hot_list, run_hot_list);
qot_proto_json_dispatch!(dispatch_short_selling_rank, run_short_selling_rank);
qot_proto_json_dispatch!(dispatch_period_change_rank, run_period_change_rank);
qot_proto_json_dispatch!(dispatch_high_dividend_soe_rank, run_high_dividend_soe_rank);
qot_proto_json_dispatch!(dispatch_institution_list, run_institution_list);
qot_proto_json_dispatch!(dispatch_institution_profile, run_institution_profile);
qot_proto_json_dispatch!(
    dispatch_institution_distribution,
    run_institution_distribution
);
qot_proto_json_dispatch!(
    dispatch_institution_holding_change,
    run_institution_holding_change
);
qot_proto_json_dispatch!(
    dispatch_institution_holding_list,
    run_institution_holding_list
);
qot_proto_json_dispatch!(dispatch_ark_fund_holding, run_ark_fund_holding);
qot_proto_json_dispatch!(dispatch_ark_stock_dynamic, run_ark_stock_dynamic);
qot_proto_json_dispatch!(dispatch_ark_active_transaction, run_ark_active_transaction);
qot_proto_json_dispatch!(dispatch_rating_change, run_rating_change);
qot_proto_json_dispatch!(dispatch_search_quote, run_search_quote);
qot_proto_json_dispatch!(dispatch_search_news, run_search_news);
qot_proto_json_dispatch!(
    dispatch_option_market_statistic,
    run_option_market_statistic
);
qot_proto_json_dispatch!(
    dispatch_option_underlying_his_statistic,
    run_option_underlying_his_statistic
);
qot_proto_json_dispatch!(
    dispatch_option_underlying_overview,
    run_option_underlying_overview
);
qot_proto_json_dispatch!(
    dispatch_option_underlying_his_volatility,
    run_option_underlying_his_volatility
);
qot_proto_json_dispatch!(dispatch_option_underlying_rank, run_option_underlying_rank);
qot_proto_json_dispatch!(dispatch_option_rank, run_option_rank);
qot_proto_json_dispatch!(dispatch_option_event, run_option_event);
qot_proto_json_dispatch!(dispatch_option_event_alert, run_option_event_alert);
qot_proto_json_dispatch!(dispatch_set_option_event_alert, run_set_option_event_alert);
qot_proto_json_dispatch!(
    dispatch_option_zero_dte_screener,
    run_option_zero_dte_screener
);
qot_proto_json_dispatch!(
    dispatch_option_zero_dte_contract,
    run_option_zero_dte_contract
);
qot_proto_json_dispatch!(
    dispatch_option_earnings_screener,
    run_option_earnings_screener
);
qot_proto_json_dispatch!(dispatch_option_seller_screener, run_option_seller_screener);
qot_proto_json_dispatch!(dispatch_industrial_chain_list, run_industrial_chain_list);
qot_proto_json_dispatch!(
    dispatch_industrial_chain_detail,
    run_industrial_chain_detail
);
qot_proto_json_dispatch!(
    dispatch_industrial_chain_by_plate,
    run_industrial_chain_by_plate
);
qot_proto_json_dispatch!(dispatch_industrial_plate_info, run_industrial_plate_info);
qot_proto_json_dispatch!(dispatch_industrial_plate_stock, run_industrial_plate_stock);
qot_proto_json_dispatch!(dispatch_heat_map_data, run_heat_map_data);
qot_proto_json_dispatch!(dispatch_rise_fall_distribution, run_rise_fall_distribution);

pub(super) async fn dispatch_capital_flow(
    gateway: &str,
    output: OutputFormat,
    args: CapitalFlowArgs,
) -> Result<()> {
    cmd::analysis::run_capital_flow(
        gateway,
        &args.symbol,
        args.period_type,
        args.begin.as_deref(),
        args.end.as_deref(),
        output,
    )
    .await
}

pub(super) async fn dispatch_company_profile(
    gateway: &str,
    output: OutputFormat,
    args: CompanyProfileArgs,
) -> Result<()> {
    cmd::analysis::run_company_profile(gateway, &args.symbol, output).await
}

pub(super) async fn dispatch_company_executives(
    gateway: &str,
    output: OutputFormat,
    args: CompanyExecutivesArgs,
) -> Result<()> {
    cmd::analysis::run_company_executives(gateway, &args.symbol, output).await
}

pub(super) async fn dispatch_company_executive_background(
    gateway: &str,
    output: OutputFormat,
    args: CompanyExecutiveBackgroundArgs,
) -> Result<()> {
    cmd::analysis::run_company_executive_background(
        gateway,
        &args.symbol,
        &args.leader_name,
        output,
    )
    .await
}

pub(super) async fn dispatch_company_operational_efficiency(
    gateway: &str,
    output: OutputFormat,
    args: CompanyOperationalEfficiencyArgs,
) -> Result<()> {
    cmd::analysis::run_company_operational_efficiency(
        gateway,
        &args.symbol,
        args.next_key.as_deref(),
        args.num,
        args.currency_code.as_deref(),
        args.financial_type,
        output,
    )
    .await
}

pub(super) async fn dispatch_financials_earnings_price_move(
    gateway: &str,
    output: OutputFormat,
    args: FinancialsEarningsPriceMoveArgs,
) -> Result<()> {
    cmd::analysis::run_financials_earnings_price_move(
        gateway,
        &args.symbol,
        args.period_count,
        output,
    )
    .await
}

pub(super) async fn dispatch_financials_earnings_price_history(
    gateway: &str,
    output: OutputFormat,
    args: FinancialsEarningsPriceHistoryArgs,
) -> Result<()> {
    cmd::analysis::run_financials_earnings_price_history(gateway, &args.symbol, output).await
}

pub(super) async fn dispatch_financial_calendar(
    gateway: &str,
    output: OutputFormat,
    args: FinancialCalendarArgs,
) -> Result<()> {
    cmd::analysis::run_financial_calendar(
        gateway,
        cmd::analysis::FinancialCalendarCommand {
            begin_date: &args.begin_date,
            end_date: &args.end_date,
            markets: &args.markets,
            pub_types: &args.pub_types,
            stock_types: &args.stock_types,
            count: Some(args.count),
            ranking_type: args.ranking_type,
            estimate_types: &args.estimate_types,
            custom_filters: &args.custom_filters,
            watchlist_only: args.watchlist_only,
            positions_only: args.positions_only,
            watchlist_stock_ids: &args.watchlist_stock_ids,
            holding_stock_ids: &args.holding_stock_ids,
        },
        output,
    )
    .await
}

pub(super) async fn dispatch_financial_calendar_target(
    gateway: &str,
    output: OutputFormat,
    args: FinancialCalendarTargetArgs,
) -> Result<()> {
    cmd::analysis::run_financial_calendar_target(
        gateway,
        cmd::analysis::FinancialCalendarTargetCommand {
            stock_ids: &args.stock_ids,
            markets: &args.markets,
            size: args.size,
            start: args.start,
        },
        output,
    )
    .await
}

pub(super) async fn dispatch_ipo_calendar(
    gateway: &str,
    output: OutputFormat,
    args: IpoCalendarArgs,
) -> Result<()> {
    cmd::analysis::run_ipo_calendar(
        gateway,
        &args.market,
        &args.events,
        args.begin_date.as_deref(),
        args.end_date.as_deref(),
        output,
    )
    .await
}

pub(super) async fn dispatch_financials_statements(
    gateway: &str,
    output: OutputFormat,
    args: FinancialsStatementsArgs,
) -> Result<()> {
    cmd::analysis::run_financials_statements(
        gateway,
        &args.symbol,
        args.statement_type,
        args.financial_type,
        args.currency_code.as_deref(),
        args.next_key.as_deref(),
        args.num,
        output,
    )
    .await
}

pub(super) async fn dispatch_financials_revenue_breakdown(
    gateway: &str,
    output: OutputFormat,
    args: FinancialsRevenueBreakdownArgs,
) -> Result<()> {
    cmd::analysis::run_financials_revenue_breakdown(
        gateway,
        &args.symbol,
        args.date,
        args.financial_type,
        args.currency_code.as_deref(),
        output,
    )
    .await
}

pub(super) async fn dispatch_research_analyst_consensus(
    gateway: &str,
    output: OutputFormat,
    args: ResearchAnalystConsensusArgs,
) -> Result<()> {
    cmd::analysis::run_research_analyst_consensus(gateway, &args.symbol, output).await
}

pub(super) async fn dispatch_research_rating_summary(
    gateway: &str,
    output: OutputFormat,
    args: ResearchRatingSummaryArgs,
) -> Result<()> {
    cmd::analysis::run_research_rating_summary(
        gateway,
        &args.symbol,
        args.rating_dimension_type,
        args.uid.as_deref(),
        args.next_key.as_deref(),
        args.num,
        output,
    )
    .await
}

pub(super) async fn dispatch_research_morningstar_report(
    gateway: &str,
    output: OutputFormat,
    args: ResearchMorningstarReportArgs,
) -> Result<()> {
    cmd::analysis::run_research_morningstar_report(gateway, &args.symbol, output).await
}

pub(super) async fn dispatch_valuation_detail(
    gateway: &str,
    output: OutputFormat,
    args: ValuationDetailArgs,
) -> Result<()> {
    cmd::analysis::run_valuation_detail(
        gateway,
        &args.symbol,
        args.valuation_type,
        args.interval_type,
        output,
    )
    .await
}

pub(super) async fn dispatch_valuation_plate_stock_list(
    gateway: &str,
    output: OutputFormat,
    args: ValuationPlateStockListArgs,
) -> Result<()> {
    cmd::analysis::run_valuation_plate_stock_list(
        gateway,
        &args.symbol,
        args.valuation_type,
        args.next_key.as_deref(),
        args.num,
        args.sort_type,
        args.sort_id,
        args.filter_security.as_deref(),
        output,
    )
    .await
}

pub(super) async fn dispatch_stock_screen(
    gateway: &str,
    output: OutputFormat,
    args: StockScreenArgs,
) -> Result<()> {
    cmd::analysis::run_stock_screen(gateway, &args.c2s_json, output).await
}

pub(super) async fn dispatch_option_screen(
    gateway: &str,
    output: OutputFormat,
    args: OptionScreenArgs,
) -> Result<()> {
    cmd::analysis::run_option_screen(gateway, &args.c2s_json, output).await
}

pub(super) async fn dispatch_warrant_screen(
    gateway: &str,
    output: OutputFormat,
    args: WarrantScreenArgs,
) -> Result<()> {
    cmd::analysis::run_warrant_screen(gateway, &args.c2s_json, output).await
}

pub(super) async fn dispatch_technical_unusual(
    gateway: &str,
    output: OutputFormat,
    args: TechnicalUnusualArgs,
) -> Result<()> {
    cmd::analysis::run_technical_unusual(
        gateway,
        &args.stock_symbol,
        args.time_range,
        args.indicator_filters,
        args.language_id,
        output,
    )
    .await
}

pub(super) async fn dispatch_financial_unusual(
    gateway: &str,
    output: OutputFormat,
    args: FinancialUnusualArgs,
) -> Result<()> {
    cmd::analysis::run_financial_unusual(
        gateway,
        &args.stock_symbol,
        args.time_range,
        args.analysis_dimensions,
        args.language_id,
        output,
    )
    .await
}

pub(super) async fn dispatch_derivative_unusual(
    gateway: &str,
    output: OutputFormat,
    args: DerivativeUnusualArgs,
) -> Result<()> {
    cmd::analysis::run_derivative_unusual(
        gateway,
        &args.stock_symbol,
        args.time_range,
        args.analysis_dimensions,
        args.language_id,
        output,
    )
    .await
}

pub(super) async fn dispatch_corporate_actions_buybacks(
    gateway: &str,
    output: OutputFormat,
    args: CorporateActionsBuybacksArgs,
) -> Result<()> {
    cmd::analysis::run_corporate_actions_buybacks(
        gateway,
        &args.symbol,
        args.next_key.as_deref(),
        args.num,
        output,
    )
    .await
}

pub(super) async fn dispatch_corporate_actions_dividends(
    gateway: &str,
    output: OutputFormat,
    args: CorporateActionsDividendsArgs,
) -> Result<()> {
    cmd::analysis::run_corporate_actions_dividends(gateway, &args.symbol, output).await
}

pub(super) async fn dispatch_corporate_actions_stock_splits(
    gateway: &str,
    output: OutputFormat,
    args: CorporateActionsStockSplitsArgs,
) -> Result<()> {
    cmd::analysis::run_corporate_actions_stock_splits(
        gateway,
        &args.symbol,
        args.next_key.as_deref(),
        args.num,
        output,
    )
    .await
}

pub(super) async fn dispatch_daily_short_volume(
    gateway: &str,
    output: OutputFormat,
    args: DailyShortVolumeArgs,
) -> Result<()> {
    cmd::analysis::run_daily_short_volume(
        gateway,
        &args.symbol,
        args.next_key.as_deref(),
        args.num,
        output,
    )
    .await
}

pub(super) async fn dispatch_short_interest(
    gateway: &str,
    output: OutputFormat,
    args: ShortInterestArgs,
) -> Result<()> {
    cmd::analysis::run_short_interest(
        gateway,
        &args.symbol,
        args.next_key.as_deref(),
        args.num,
        output,
    )
    .await
}

pub(super) async fn dispatch_top_ten_buy_sell_brokers(
    gateway: &str,
    output: OutputFormat,
    args: TopTenBuySellBrokersArgs,
) -> Result<()> {
    cmd::analysis::run_top_ten_buy_sell_brokers(gateway, &args.symbol, args.days_before, output)
        .await
}

pub(super) async fn dispatch_shareholders_overview(
    gateway: &str,
    output: OutputFormat,
    args: ShareholdersOverviewArgs,
) -> Result<()> {
    cmd::analysis::run_shareholders_overview(gateway, &args.symbol, args.period_id, output).await
}

pub(super) async fn dispatch_shareholders_holding_changes(
    gateway: &str,
    output: OutputFormat,
    args: ShareholdersHoldingChangesArgs,
) -> Result<()> {
    cmd::analysis::run_shareholders_holding_changes(
        cmd::analysis::ShareholdersHoldingChangesCommand {
            gateway,
            symbol: &args.symbol,
            next_key: args.next_key,
            num: args.num,
            sort_type: args.sort_type,
            sort_column: args.sort_column,
            filter_type: args.filter_type,
            format: output,
        },
    )
    .await
}

pub(super) async fn dispatch_shareholders_holder_detail(
    gateway: &str,
    output: OutputFormat,
    args: ShareholdersHolderDetailArgs,
) -> Result<()> {
    cmd::analysis::run_shareholders_holder_detail(cmd::analysis::ShareholdersHolderDetailCommand {
        gateway,
        symbol: &args.symbol,
        request_type: args.request_type,
        next_key: args.next_key,
        num: args.num,
        sort_column: args.sort_column,
        sort_type: args.sort_type,
        period_id: args.period_id,
        holder_id: args.holder_id,
        format: output,
    })
    .await
}

pub(super) async fn dispatch_shareholders_institutional(
    gateway: &str,
    output: OutputFormat,
    args: ShareholdersInstitutionalArgs,
) -> Result<()> {
    cmd::analysis::run_shareholders_institutional(
        gateway,
        &args.symbol,
        args.next_key,
        args.num,
        output,
    )
    .await
}

pub(super) async fn dispatch_insider_holder_list(
    gateway: &str,
    output: OutputFormat,
    args: InsiderHolderListArgs,
) -> Result<()> {
    cmd::analysis::run_insider_holder_list(gateway, &args.symbol, args.next_key, args.num, output)
        .await
}

pub(super) async fn dispatch_insider_trade_list(
    gateway: &str,
    output: OutputFormat,
    args: InsiderTradeListArgs,
) -> Result<()> {
    cmd::analysis::run_insider_trade_list(
        gateway,
        &args.symbol,
        args.holder_id,
        args.next_key,
        args.num,
        output,
    )
    .await
}

pub(super) async fn dispatch_option_volatility(
    gateway: &str,
    output: OutputFormat,
    args: OptionVolatilityArgs,
) -> Result<()> {
    cmd::analysis::run_option_volatility(
        gateway,
        &args.symbol,
        args.query_time_period,
        args.hv_time_period,
        output,
    )
    .await
}

pub(super) async fn dispatch_option_exercise_probability(
    gateway: &str,
    output: OutputFormat,
    args: OptionExerciseProbabilityArgs,
) -> Result<()> {
    cmd::analysis::run_option_exercise_probability(gateway, &args.symbol, output).await
}