@tigeropenapi/tigeropen 0.5.3 → 0.5.5

package/dist/esm/push/tick-util.js

@@ -0,0 +1,165 @@
+const PART_CODE_NAME_MAP = {
+    a: 'NYSE American, LLC (NYSE American)',
+    b: 'NASDAQ OMX BX, Inc. (NASDAQ OMX BX)',
+    c: 'NYSE National, Inc. (NYSE National)',
+    d: 'FINRA Alternative Display Facility (ADF)',
+    h: 'MIAX Pearl Exchange, LLC (MIAX)',
+    i: 'International Securities Exchange, LLC (ISE)',
+    j: 'Cboe EDGA Exchange, Inc. (Cboe EDGA)',
+    k: 'Cboe EDGX Exchange, Inc. (Cboe EDGX)',
+    l: 'Long-Term Stock Exchange, Inc. (LTSE)',
+    m: 'NYSE Chicago, Inc. (NYSE Chicago)',
+    n: 'New York Stock Exchange, LLC (NYSE)',
+    p: 'NYSE Arca, Inc. (NYSE Arca)',
+    s: 'Consolidated Tape System (CTS)',
+    t: 'NASDAQ Stock Market, LLC (NASDAQ)',
+    u: 'Members Exchange, LLC (MEMX)',
+    v: "Investors' Exchange, LLC. (IEX)",
+    w: 'CBOE Stock Exchange, Inc. (CBSX)',
+    x: 'NASDAQ OMX PSX, Inc. (NASDAQ OMX PSX)',
+    y: 'Cboe BYX Exchange, Inc. (Cboe BYX)',
+    z: 'Cboe BZX Exchange, Inc. (Cboe BZX)',
+};
+const PART_CODE_SHORT_NAME_MAP = {
+    a: 'AMEX',
+    b: 'BX',
+    c: 'NSX',
+    d: 'ADF',
+    h: 'MIAX',
+    i: 'ISE',
+    j: 'EDGA',
+    k: 'EDGX',
+    l: 'LTSE',
+    m: 'CHO',
+    n: 'NYSE',
+    p: 'ARCA',
+    s: 'CTS',
+    t: 'NSDQ',
+    u: 'MEMX',
+    v: 'IEX',
+    w: 'CBSX',
+    x: 'PSX',
+    y: 'BYX',
+    z: 'BZX',
+};
+const US_TRADE_COND = {
+    ' ': 'US_REGULAR_SALE',
+    B: 'US_BUNCHED_TRADE',
+    C: 'US_CASH_TRADE',
+    F: 'US_INTERMARKET_SWEEP',
+    G: 'US_BUNCHED_SOLD_TRADE',
+    H: 'US_PRICE_VARIATION_TRADE',
+    I: 'US_ODD_LOT_TRADE',
+    K: 'US_RULE_127_OR_155_TRADE',
+    L: 'US_SOLD_LAST',
+    M: 'US_MARKET_CENTER_CLOSE_PRICE',
+    N: 'US_NEXT_DAY_TRADE',
+    O: 'US_MARKET_CENTER_OPENING_TRADE',
+    P: 'US_PRIOR_REFERENCE_PRICE',
+    Q: 'US_MARKET_CENTER_OPEN_PRICE',
+    R: 'US_SELLER',
+    T: 'US_FORM_T',
+    U: 'US_EXTENDED_TRADING_HOURS',
+    V: 'US_CONTINGENT_TRADE',
+    W: 'US_AVERAGE_PRICE_TRADE',
+    X: 'US_CROSS_TRADE',
+    Z: 'US_SOLD_OUT_OF_SEQUENCE',
+    '0': 'US_ODD_LOST_CROSS_TRADE',
+    '4': 'US_DERIVATIVELY_PRICED',
+    '5': 'US_MARKET_CENTER_RE_OPENING_TRADE',
+    '6': 'US_MARKET_CENTER_CLOSING_TRADE',
+    '7': 'US_QUALIFIED_CONTINGENT_TRADE',
+    '9': 'US_CONSOLIDATED_LAST_PRICE_PER_LISTING_PACKET',
+};
+const HK_TRADE_COND = {
+    ' ': 'HK_AUTOMATCH_NORMAL',
+    D: 'HK_ODD_LOT_TRADE',
+    U: 'HK_AUCTION_TRADE',
+    '*': 'HK_OVERSEAS_TRADE',
+    P: 'HK_LATE_TRADE_OFF_EXCHG',
+    M: 'HK_NON_DIRECT_OFF_EXCHG_TRADE',
+    X: 'HK_DIRECT_OFF_EXCHG_TRADE',
+    Y: 'HK_AUTOMATIC_INTERNALIZED',
+};
+/** Returns the full exchange name for a partCode letter, or the raw code if unknown. */
+export function getPartNameByCode(code) {
+    if (!code)
+        return code;
+    return PART_CODE_NAME_MAP[code] ?? code;
+}
+/** Returns the short exchange name for a partCode letter, or the raw code if unknown. */
+export function getPartShortNameByCode(code) {
+    if (!code)
+        return code;
+    return PART_CODE_SHORT_NAME_MAP[code] ?? code;
+}
+/** Resolves a raw cond character to a readable string. */
+export function getTradeCondByCode(isUs, ch) {
+    const map = isUs ? US_TRADE_COND : HK_TRADE_COND;
+    return map[ch] ?? ch;
+}
+const US_SYMBOL_RE = /^[A-Z]+(\.[A-Z0-9]+)?$/;
+/** Reports whether symbol is a US stock (uppercase letters, optional dot suffix). */
+export function isUsStockSymbol(symbol) {
+    return US_SYMBOL_RE.test(symbol);
+}
+function isUsSymbol(symbol) {
+    return US_SYMBOL_RE.test(symbol);
+}
+function getTradeCond(isUs, ch) {
+    const map = isUs ? US_TRADE_COND : HK_TRADE_COND;
+    return map[ch] ?? ch;
+}
+/** Decodes a TradeTickData pb message into a PushTradeTick with resolved partCode/partName. */
+export function convertTradeTick(src) {
+    if (src.secType === 'FUT')
+        return convertFutureTick(src);
+    return convertStockTick(src);
+}
+function convertStockTick(src) {
+    const isUs = isUsSymbol(src.symbol);
+    const denominator = Math.pow(10, src.priceOffset);
+    const ticks = [];
+    let currentTime = 0;
+    for (let i = 0; i < src.time.length; i++) {
+        currentTime += src.time[i];
+        const condCh = src.cond.length > i ? src.cond[i] : ' ';
+        const rawCode = i < src.partCode.length ? src.partCode[i] : '';
+        ticks.push({
+            sn: src.sn + i,
+            time: currentTime,
+            price: (src.priceBase + src.price[i]) / denominator,
+            volume: src.volume[i],
+            tickType: src.type.length > i ? src.type[i] : '',
+            cond: getTradeCond(isUs, condCh),
+            partCode: getPartShortNameByCode(rawCode),
+            partName: getPartNameByCode(rawCode),
+        });
+    }
+    return { symbol: src.symbol, secType: src.secType, quoteLevel: src.quoteLevel, timestamp: src.timestamp, ticks };
+}
+function convertFutureTick(src) {
+    const denominator = Math.pow(10, src.priceOffset);
+    const ticks = [];
+    let currentTime = 0;
+    let startSn = src.sn;
+    for (let i = 0; i < src.time.length; i++) {
+        currentTime += src.time[i];
+        const curPrice = (src.priceBase + src.price[i]) / denominator;
+        const mv = src.mergedVols[i];
+        for (let j = 0; j < mv.vol.length; j++) {
+            ticks.push({
+                sn: startSn * 10 + j,
+                time: currentTime,
+                price: curPrice,
+                volume: mv.vol[j],
+                tickType: '',
+                cond: '',
+                partCode: '',
+                partName: '',
+            });
+        }
+        startSn++;
+    }
+    return { symbol: src.symbol, secType: src.secType, quoteLevel: '', timestamp: src.timestamp, ticks };
+}

package/dist/esm/quote/quote-client.js

@@ -8,6 +8,8 @@
 import { HttpClient } from '../client/http-client.js';
 import { createApiRequest } from '../client/api-request.js';
 import { unmarshalData } from '../client/api-response.js';
+import * as tokenMethods from '../client/token-methods.js';
+import { getTradeCondByCode, isUsStockSymbol } from '../push/tick-util.js';
 /**
  * resolveOptionTimezone returns the timezone string to use for expiry conversion.
  * Explicit tz takes precedence; otherwise infer from symbol (.HK suffix → Asia/Hong_Kong, else America/New_York).
@@ -90,6 +92,25 @@ export class QuoteClient {
     static fromConfig(config) {
         return new QuoteClient(new HttpClient(config, undefined, { useQuoteServerUrl: true }));
     }
+    // ── Token management ──────────────────────────────────────────────────────
+    /** Call the `user_token_refresh` API and return the new token. Read-only. */
+    async queryToken() {
+        return tokenMethods.queryToken(this.httpClient);
+    }
+    /** Refresh the token and update the in-memory config token. */
+    async refreshToken(tokenManager) {
+        return tokenMethods.refreshToken(this.httpClient, tokenManager);
+    }
+    /**
+     * Start background token auto-refresh. Returns a TokenManager to stop with `tm.stopAutoRefresh()`.
+     *
+     * @param refreshDurationSecs - Refresh threshold in seconds (minimum 30).
+     * @param checkIntervalMs - How often to check, in milliseconds (default 300 000 / 5 min).
+     * @param tokenWriter - Optional callback invoked after each successful refresh.
+     */
+    startTokenAutoRefresh(refreshDurationSecs, checkIntervalMs, tokenWriter) {
+        return tokenMethods.startTokenAutoRefresh(this.httpClient, refreshDurationSecs, checkIntervalMs, tokenWriter);
+    }
     async callInto(method, bizParams, version) {
         const request = createApiRequest(method, bizParams, version);
         const response = await this.httpClient.executeRequest(request);
@@ -128,12 +149,22 @@ export class QuoteClient {
     async getKline(req) {
         return this.callInto('kline', req);
     }
-    async getTimeline(symbols) {
-        return this.callInto('timeline', { symbols });
+    async getTimeline(symbolsOrRequest) {
+        const req = Array.isArray(symbolsOrRequest) ? { symbols: symbolsOrRequest } : symbolsOrRequest;
+        return this.callInto('timeline', req, req.secType === 'CC' ? '3.0' : undefined);
     }
     /** Tick-by-tick trades. wire: trade_tick */
     async getTradeTick(req) {
-        return this.callInto('trade_tick', req);
+        const out = await this.callInto('trade_tick', req);
+        for (const tick of out) {
+            const isUs = isUsStockSymbol(tick.symbol);
+            for (const item of tick.items) {
+                if (item.cond && item.cond.length > 0) {
+                    item.cond = getTradeCondByCode(isUs, item.cond[0]);
+                }
+            }
+        }
+        return out;
     }
     /** Depth snapshot. wire: quote_depth */
     async getQuoteDepth(req) {
@@ -299,6 +330,7 @@ export class QuoteClient {
         while (acc.length < totalSize) {
             const sub = {
                 symbols: req.symbol ? [req.symbol] : undefined,
+                secType: req.secType,
                 period: req.period,
                 right: req.right,
                 beginTime,
@@ -349,7 +381,7 @@ export class QuoteClient {
     async getStockIndustry(req) {
         return this.callInto('stock_industry', req);
     }
-    /** Quote permission detail. wire: get_quote_permission */
+    /** Market data permission entries. wire: get_quote_permission */
     async getQuotePermission(req) {
         return this.callInto('get_quote_permission', req);
     }
@@ -360,9 +392,16 @@ export class QuoteClient {
     // ==========================================================================
     // Batch 4: option / future extensions
     // ==========================================================================
-    /** Option tick trades. wire: option_trade_tick */
+    /** Option tick trades. wire: option_trade_tick
+     *
+     * Server expects `biz_content` as a top-level JSON array (matches Java's
+     * `BatchApiModel` and Python's `MultipleContractParams.to_openapi_dict`).
+     * We unwrap the request here so the array is emitted directly instead of
+     * `{"contracts": [...]}`. Sending it as an object triggers
+     * `biz param error(failed to parse parameters in 'biz_content')`.
+     */
     async getOptionTradeTicks(req) {
-        return this.callInto('option_trade_tick', req);
+        return this.callInto('option_trade_tick', req.contracts ?? []);
     }
     /** Option intraday timeline. wire: option_timeline */
     async getOptionTimeline(req) {
@@ -401,10 +440,16 @@ export class QuoteClient {
         return this.callInto('future_main_contract', req);
     }
     /** Futures K-line. wire: future_kline
-     * beginTime / endTime default to -1 when unset (server requires them present). */
+     * beginTime / endTime default to -1 when unset (server requires them present).
+     * Server expects `contract_codes` (plural) — normalize singular `contractCode`
+     * to the plural form so callers can pass either shape. */
     async getFutureKline(req) {
+        const contractCodes = req.contractCodes
+            ?? (req.contractCode ? [req.contractCode] : undefined);
+        const { contractCode: _drop, ...rest } = req;
         const body = {
-            ...req,
+            ...rest,
+            ...(contractCodes ? { contractCodes } : {}),
             beginTime: req.beginTime ?? -1,
             endTime: req.endTime ?? -1,
         };
@@ -422,8 +467,9 @@ export class QuoteClient {
             endTime = -1;
         const acc = [];
         while (acc.length < totalSize) {
+            // Server rejects singular `contract_code` — send the plural form.
             const sub = {
-                contractCode: req.contractCode,
+                contractCodes: req.contractCode ? [req.contractCode] : undefined,
                 period: req.period,
                 beginTime,
                 endTime,
@@ -502,9 +548,30 @@ export class QuoteClient {
     async getWarrantFilter(req) {
         return this.callInto('warrant_filter', req);
     }
-    /** Industry list. wire: industry_list */
-    async getIndustryList(req) {
-        return this.callInto('industry_list', req);
+    /** Industry list. wire: industry_list
+     *
+     * `industryLevel` is required by the server — omitting it returns
+     * `industry level error, all supported is: [GSECTOR, GGROUP, GIND, GSUBIND]`.
+     * Defaults to `GGROUP` when unset, matching Python SDK's
+     * `IndustryLevel.GGROUP` default.
+     *
+     * Wire fields differ from other endpoints (see `IndustryItem`): server sends
+     * `nameCN` / `nameEN` / `industryLevel`. This method hydrates the
+     * backwards-compat `name` (from `nameEN || nameCN`) and mirrors
+     * `industryLevel` to `level` so existing callers keep working.
+     */
+    async getIndustryList(req = {}) {
+        const payload = { industryLevel: 'GGROUP', ...req };
+        const items = await this.callInto('industry_list', payload);
+        if (!Array.isArray(items))
+            return [];
+        for (const it of items) {
+            if (it.name === undefined)
+                it.name = it.nameEN || it.nameCN;
+            if (it.level === undefined)
+                it.level = it.industryLevel;
+        }
+        return items;
     }
     /** Stocks inside an industry. wire: industry_stock_list */
     async getIndustryStocks(req) {

package/dist/esm/trade/trade-client.js

@@ -10,6 +10,7 @@
 import { HttpClient } from '../client/http-client.js';
 import { createApiRequest } from '../client/api-request.js';
 import { unmarshalData } from '../client/api-response.js';
+import * as tokenMethods from '../client/token-methods.js';
 import { normalizeOrderStatus } from '../model/order-status.js';
 /** Normalize `Order.status` field in-place (handles int → string). */
 function normalizeOrderInPlace(o) {
@@ -41,6 +42,31 @@ export class TradeClient {
     static fromConfig(config, account, secretKey) {
         return new TradeClient(new HttpClient(config), account, secretKey);
     }
+    // ── Token management ──────────────────────────────────────────────────────
+    /** Call the `user_token_refresh` API and return the new token. Read-only. */
+    async queryToken() {
+        return tokenMethods.queryToken(this.httpClient);
+    }
+    /**
+     * Refresh the token: call the API, update the in-memory config token, and
+     * optionally persist via the provided TokenManager (file + writer callback).
+     *
+     * @param tokenManager - optional TokenManager for file persistence and writer callback
+     */
+    async refreshToken(tokenManager) {
+        return tokenMethods.refreshToken(this.httpClient, tokenManager);
+    }
+    /**
+     * Start background token auto-refresh. Returns a TokenManager that can be
+     * used to stop the background task via `tm.stopAutoRefresh()`.
+     *
+     * @param refreshDurationSecs - Refresh threshold in seconds (minimum 30).
+     * @param checkIntervalMs - How often to check, in milliseconds (default 300 000 / 5 min).
+     * @param tokenWriter - Optional callback invoked after each successful refresh.
+     */
+    startTokenAutoRefresh(refreshDurationSecs, checkIntervalMs, tokenWriter) {
+        return tokenMethods.startTokenAutoRefresh(this.httpClient, refreshDurationSecs, checkIntervalMs, tokenWriter);
+    }
     async callInto(method, bizParams) {
         // Inject secretKey into every request when available (institution accounts require it).
         // Individual methods that already set secretKey will not be overwritten (|| not &&).
@@ -83,14 +109,54 @@ export class TradeClient {
         });
     }
     // === Order operations ===
+    /**
+     * Prepare an order request for the wire.
+     *
+     * The gateway expects `algo_params` as a `[{tag, value}, ...]` array
+     * (matching the Python SDK's AlgoParams.to_dict serialization), not the
+     * plain object shape that reads naturally in TypeScript. This helper
+     * normalizes the object form into the array form on outbound payloads
+     * so callers can pass the natural object and TWAP/VWAP orders work end
+     * to end without wire-format workarounds.
+     *
+     * Fields with undefined/null values are dropped; empty algoParams
+     * becomes an empty array rather than being stripped, matching the
+     * Python SDK behavior when the user passes an empty AlgoParams().
+     */
+    marshalOrderForWire(order) {
+        const { algoParams, ...rest } = order;
+        const withAccount = { ...rest, account: this.account };
+        if (algoParams === undefined)
+            return withAccount;
+        // Already a tag/value array (advanced callers who want raw control)
+        if (Array.isArray(algoParams)) {
+            withAccount.algoParams = algoParams;
+            return withAccount;
+        }
+        // Object shape → tag/value array.
+        // Keys are converted to snake_case explicitly here (e.g. `startTime` →
+        // `start_time`) so they land correctly in the `tag` string that the
+        // gateway reads. `keysToSnakeCase` only rewrites object *keys*, not
+        // string *values*, so `tag` would be left camelCase if we didn't do
+        // this conversion ourselves.
+        const tagValues = [];
+        for (const [key, value] of Object.entries(algoParams)) {
+            if (value === undefined || value === null)
+                continue;
+            const snakeKey = key.replace(/[A-Z]/g, (c) => '_' + c.toLowerCase());
+            tagValues.push({ tag: snakeKey, value });
+        }
+        withAccount.algoParams = tagValues;
+        return withAccount;
+    }
     async placeOrder(order) {
-        return this.callInto('place_order', { ...order, account: this.account });
+        return this.callInto('place_order', this.marshalOrderForWire(order));
     }
     async previewOrder(order) {
-        return this.callInto('preview_order', { ...order, account: this.account });
+        return this.callInto('preview_order', this.marshalOrderForWire(order));
     }
     async modifyOrder(id, order) {
-        return this.callInto('modify_order', { ...order, account: this.account, id });
+        return this.callInto('modify_order', { ...this.marshalOrderForWire(order), id });
     }
     async cancelOrder(id, secretKey) {
         const params = { account: this.account, id };

package/dist/types/client/token-methods.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Shared token management methods for TradeClient and QuoteClient.
+ * Both clients delegate to the underlying HttpClient; this module
+ * centralises the JSDoc so each client stays in sync automatically.
+ */
+import type { HttpClient } from './http-client';
+import type { TokenManager } from '../config/token-manager';
+/**
+ * Call the `user_token_refresh` API and return the new token string.
+ * Read-only: does NOT update the stored token.
+ * Use `refreshToken()` to also update the in-memory config and optionally persist.
+ */
+export declare function queryToken(httpClient: HttpClient): Promise<string>;
+/**
+ * Refresh the token: call the API, update the in-memory config token, and
+ * optionally persist via the provided TokenManager (file + writer callback).
+ *
+ * @param httpClient - The underlying HTTP client
+ * @param tokenManager - optional TokenManager for file persistence and writer callback
+ */
+export declare function refreshToken(httpClient: HttpClient, tokenManager?: TokenManager | null): Promise<void>;
+/**
+ * Start background token auto-refresh. Returns a TokenManager that can be
+ * used to stop the background task via `tm.stopAutoRefresh()`.
+ *
+ * @param httpClient - The underlying HTTP client
+ * @param refreshDurationSecs - Refresh threshold in seconds (minimum 30).
+ *   When the token age exceeds this value the refresh is triggered.
+ * @param checkIntervalMs - How often to check whether a refresh is needed,
+ *   in milliseconds. Defaults to 300 000 ms (5 minutes).
+ * @param tokenWriter - Optional callback invoked with the new token string
+ *   after each successful refresh.
+ */
+export declare function startTokenAutoRefresh(httpClient: HttpClient, refreshDurationSecs: number, checkIntervalMs?: number, tokenWriter?: (token: string) => void): TokenManager;

package/dist/types/index.d.ts

@@ -35,5 +35,5 @@ export type { Position } from './model/position';
 export type { Asset, AssetSegment, PrimeAsset, PreviewResult, PlaceOrderResult, OrderIdResult, Transaction, ManagedAccount, AnalyticsAsset, AggregateAssets, EstimateTradableQuantity, ForexOrderResult, SegmentFund, SegmentFundAvailableItem, SegmentFundHistoryItem, FundDetails, FundingHistoryItem, PositionTransferRecord, PositionTransferDetail, PositionTransferExternalRecord, OptionExerciseCheckResult, OptionExercisePositionPageResult, OptionExerciseRecordPageResult, } from './model/trade';
 export type { OrdersRequest, GetOrderRequest, OrderTransactionsRequest, PositionsRequest, AssetsRequest, ManagedAccountsRequest, DerivativeContractsRequest, AnalyticsAssetRequest, AggregateAssetsRequest, EstimateTradableQuantityRequest, ForexOrderRequest, SegmentFundRequest, FundDetailsRequest, FundingHistoryRequest, PositionTransferRequest, PositionTransferRecordsRequest, PositionTransferDetailRequest, PositionTransferExternalRecordsRequest, OptionExerciseCheckRequest, OptionExercisePositionRequest, OptionExerciseSubmitRequest, OptionExerciseRecordsRequest, OptionExerciseCancelRequest, } from './model/trade-requests';
 export type { MarketState, Brief, Kline, KlineItem, Timeline, TimelineItem, TradeTick, TradeTickItem, Depth, DepthLevel, OptionExpiration, OptionChain, OptionChainRow, OptionSymbol, OptionChainFilter, OptionChainFilterGreeks, Range, FutureExchange, FutureContractInfo, FutureQuote, FutureKline, FutureKlineItem, FutureDepth, FutureTradeTickItem, FutureTradingTime, FinancialDailyItem, FinancialReportItem, CorporateAction, CorporateSymbolChange, CorporateDelisting, CorporateIPO, CapitalFlow, CapitalFlowItem, CapitalDistribution, ScannerResult, ScannerResultItem, QuotePermission, SymbolName, TradeMeta, StockDetail, StockBroker, StockBrokerItem, ShortInterest, StockIndustry, IndustryItem, IndustryStock, WarrantBrief, WarrantFilterResult, FundContractInfo, FundQuote, FundHistoryQuote, QuoteOvernight, KlineQuota, MarketScannerTag, MarketScannerTags, OptionAnalysis, OptionLeg, OptionVolatilityPoint, ExchangeRate, FinancialCurrency, BrokerDetail, TradingCalendarItem, FutureMainContractHistory, } from './model/quote';
-export type { BriefRequest, DepthQuoteRequest, TradeTickRequest, KlineRequest, KlineByPageRequest, FutureBriefRequest, FutureKlineRequest, FutureKlineByPageRequest, FutureTradeTicksRequest, FutureDepthRequest, FutureContractSingleRequest, FutureContinuousContractsRequest, FutureHistoryMainContractRequest, FutureTradingTimesRequest, AllFutureContractsRequest, OptionTradeTicksRequest, OptionTimelineRequest, OptionDepthRequest, OptionSymbolsRequest, OptionAnalysisRequest, OptionQueryItem, ShortInterestRequest, StockBrokerRequest, StockDetailsRequest, StockFundamentalRequest, StockIndustryRequest, StockDelayBriefsRequest, SymbolsRequest, TradeMetasRequest, TradeRankRequest, TimelineHistoryRequest, TradingCalendarRequest, KlineQuotaRequest, QuotePermissionRequest, QuoteOvernightRequest, IndustryListRequest, IndustryStocksRequest, FundSymbolsRequest, FundContractsRequest, FundQuoteRequest, FundHistoryQuoteRequest, WarrantBriefsRequest, WarrantFilterRequest, MarketScannerTagsRequest, FinancialCurrencyRequest, FinancialExchangeRateRequest, } from './model/quote-requests';
+export type { BriefRequest, DepthQuoteRequest, TradeTickRequest, KlineRequest, KlineByPageRequest, TimelineRequest, FutureBriefRequest, FutureKlineRequest, FutureKlineByPageRequest, FutureTradeTicksRequest, FutureDepthRequest, FutureContractSingleRequest, FutureContinuousContractsRequest, FutureHistoryMainContractRequest, FutureTradingTimesRequest, AllFutureContractsRequest, OptionTradeTicksRequest, OptionTimelineRequest, OptionDepthRequest, OptionSymbolsRequest, OptionAnalysisRequest, OptionQueryItem, ShortInterestRequest, StockBrokerRequest, StockDetailsRequest, StockFundamentalRequest, StockIndustryRequest, StockDelayBriefsRequest, SymbolsRequest, TradeMetasRequest, TradeRankRequest, TimelineHistoryRequest, TradingCalendarRequest, KlineQuotaRequest, QuotePermissionRequest, QuoteOvernightRequest, IndustryListRequest, IndustryStocksRequest, FundSymbolsRequest, FundContractsRequest, FundQuoteRequest, FundHistoryQuoteRequest, WarrantBriefsRequest, WarrantFilterRequest, MarketScannerTagsRequest, FinancialCurrencyRequest, FinancialExchangeRateRequest, } from './model/quote-requests';
 export { OrderStatus, SecurityType, OrderType, TimeInForce, Market, Currency, QuoteRight, SegmentType, OrderSortBy, CorporateActionType, IndustryLevel, SortDirection, OptionAnalysisPeriod, FinancialReportPeriod, Language, License, BarPeriod, orderStatusCode, } from './model/enums';

package/dist/types/model/order-helpers.d.ts

@@ -2,7 +2,7 @@
  * Order construction helpers.
  * All helpers return an `OrderRequest` with sensible defaults.
  */
-import type { OrderRequest, OrderLegRequest, AlgoParamsRequest } from './order';
+import type { OrderRequest, OrderLegRequest, AlgoParamsRequest, ContractLegRequest } from './order';
 import { PriceType } from './enums';
 /** Market order */
 export declare function marketOrder(account: string, symbol: string, secType: string, action: string, quantity: number): OrderRequest;
@@ -21,14 +21,54 @@ export declare function auctionMarketOrder(account: string, symbol: string, secT
 /** Algo order (TWAP / VWAP) */
 export declare function algoOrder(account: string, symbol: string, secType: string, action: string, quantity: number, limitPrice: number, algoType: string, params: AlgoParamsRequest): OrderRequest;
 /**
- * Iceberg order (basic) — only displaySize required.
- */
-export declare function icebergOrder(account: string, symbol: string, secType: string, action: string, quantity: number, limitPrice: number, displaySize: number): OrderRequest;
-/**
- * Iceberg order (full params).
- * Pass `priceType` as empty string to use server default (LIMIT_PRICE).
+ * Iceberg order. `displaySize` is required; all other parameters are optional.
+ * Pass `priceType` as empty string to use the server default (LIMIT_PRICE).
  * Pass `startTime` / `endTime` as 0 to omit the time window.
  */
-export declare function icebergOrderFull(account: string, symbol: string, secType: string, action: string, quantity: number, limitPrice: number, displaySize: number, minDisplaySize?: number, checkIntervals?: number, priceType?: PriceType | string, startTime?: number, endTime?: number): OrderRequest;
+export declare function icebergOrder(account: string, symbol: string, secType: string, action: string, quantity: number, limitPrice: number, displaySize: number, minDisplaySize?: number, checkIntervals?: number, priceType?: PriceType | string, startTime?: number, endTime?: number): OrderRequest;
 /** Attached profit / loss leg */
 export declare function orderLeg(legType: string, price: number, timeInForce: string): OrderLegRequest;
+/**
+ * Market order by cash amount (instead of quantity).
+ * Server uses `isQuantityByAmount=true` + `amount` field.
+ */
+export declare function marketOrderByAmount(account: string, symbol: string, secType: string, action: string, amount: number): OrderRequest;
+/**
+ * Limit order by cash amount (instead of quantity).
+ */
+export declare function limitOrderByAmount(account: string, symbol: string, secType: string, action: string, amount: number, limitPrice: number): OrderRequest;
+/**
+ * Trailing stop order using a fixed price offset (auxPrice) instead of a percentage.
+ * Use `trailOrder()` for percentage-based trailing stops.
+ */
+export declare function trailOrderByPrice(account: string, symbol: string, secType: string, action: string, quantity: number, auxPrice: number): OrderRequest;
+/**
+ * Limit order with attached profit/loss legs (bracket order).
+ * At most 2 legs are supported.
+ *
+ * @param orderLegs - Array of `OrderLegRequest` (use `orderLeg()` helper)
+ */
+export declare function limitOrderWithLegs(account: string, symbol: string, secType: string, action: string, quantity: number, limitPrice: number, orderLegs: OrderLegRequest[]): OrderRequest;
+/**
+ * Multi-leg (combo/MLEG) order for options combos.
+ *
+ * @param contractLegs - Array of `ContractLegRequest` (use `contractLeg()` helper)
+ * @param comboType - e.g. `'MLEG'`
+ */
+export declare function comboOrder(account: string, action: string, quantity: number, orderType: string, contractLegs: ContractLegRequest[], comboType?: string, limitPrice?: number, auxPrice?: number, trailingPercent?: number): OrderRequest;
+/**
+ * OCA (One-Cancels-All) order.
+ * Server expects `orderType: 'OCA'` and an `ocaOrders` list.
+ *
+ * @param ocaOrders - The contained orders (use any order helper to build each)
+ */
+export declare function ocaOrder(account: string, symbol: string, secType: string, action: string, quantity: number, ocaOrders: OrderRequest[]): OrderRequest;
+/**
+ * Build a single leg for a multi-leg (MLEG / combo) order.
+ *
+ * @param symbol   - Underlying symbol
+ * @param secType  - Security type (e.g. `'OPT'`)
+ * @param action   - `'BUY'` or `'SELL'`
+ * @param ratio    - Number of contracts for this leg
+ */
+export declare function contractLeg(symbol: string, secType: string, action: string, ratio: number, expiry?: string, strike?: string, right?: string): ContractLegRequest;

package/dist/types/model/order.d.ts

@@ -12,11 +12,28 @@ export interface OrderLeg {
     timeInForce?: string;
     quantity?: number;
 }
-/** Algo order parameters — response side */
+/**
+ * Algo order parameters — response side.
+ *
+ * The response shape flattens the [{tag, value}, ...] wire form into an
+ * object, and the server historically emits `startTime` / `endTime` as
+ * epoch-ms numbers (matching what the request side sends). Some legacy
+ * paths still return the raw string; accept both.
+ *
+ * Note: `algoStrategy` on the response side is server-echoed; on the
+ * request side it lives on `OrderRequest`, not `AlgoParamsRequest`.
+ */
 export interface AlgoParams {
     algoStrategy?: string;
-    startTime?: string;
-    endTime?: string;
+    /** Epoch-ms; server may echo as string on legacy paths */
+    startTime?: number | string;
+    /** Epoch-ms; server may echo as string on legacy paths */
+    endTime?: number | string;
+    /** Whether to minimize trade count (VWAP) */
+    noTakeLiq?: boolean;
+    /** Whether to allow completion after end_time (TWAP / VWAP) */
+    allowPastEndTime?: boolean;
+    /** Participation rate 0.01–0.5 (VWAP only) */
     participationRate?: number;
 }
 /** Order response model (returned by order query methods). */
@@ -135,10 +152,18 @@ export interface OrderRequest {
     checkIntervals?: number;
     /** 冰山单：价格类型（LIMIT_PRICE / ASK_PRICE / BID_PRICE / LATEST_PRICE） */
     priceType?: string;
-    /** 冰山单：生效开始时间（epoch ms） */
-    startTime?: number;
-    /** 冰山单：生效结束时间（epoch ms） */
-    endTime?: number;
+    /**
+     * 冰山单：生效开始时间（epoch ms）。
+     * Wire note: the gateway accepts both `number` (epoch ms) and `string`
+     * (epoch ms as string) for ICEBERG orders; `number | string` keeps
+     * TypeScript callers who pass `String(now)` from hitting a compile error.
+     */
+    startTime?: number | string;
+    /**
+     * 冰山单：生效结束时间（epoch ms）。
+     * Same dual-type note as `startTime` above.
+     */
+    endTime?: number | string;
     /** GTD 到期时间（epoch ms） */
     expireTime?: number;
     /** 盘后委托价格 */
@@ -149,7 +174,12 @@ export interface OrderRequest {
     segType?: string;
     /** 按金额下单：委托金额 */
     amount?: number;
-    /** 是否按金额下单 */
+    /** 按金额下单：现金金额（wire: cash_amount，与 amount 二选一） */
+    cashAmount?: number;
+    /**
+     * @deprecated 服务端不再需要此字段，by-amount 订单直接设置 `cashAmount`。
+     * 保留仅为向前兼容，新代码勿使用。
+     */
     isQuantityByAmount?: boolean;
     /** 账户分配列表（机构账户） */
     allocAccounts?: string[];
@@ -173,6 +203,19 @@ export interface OrderRequest {
     ocaOrders?: OrderRequest[];
     /** 多腿期权各腿（MLEG） */
     contractLegs?: ContractLegRequest[];
+    /** 组合单类型（如 MLEG） */
+    comboType?: string;
+    /**
+     * Algo strategy name for TWAP / VWAP orders (e.g. `'TWAP'`, `'VWAP'`).
+     * Lives on `OrderRequest`, not inside `algoParams` — the Python SDK
+     * places it at the top-level order object, and the gateway expects
+     * `algo_strategy` as a sibling of `algo_params`.
+     *
+     * Note: `AlgoParamsRequest` intentionally omits this field (see its
+     * doc-comment). Pass `algoStrategy` here and `algoParams` as the
+     * companion object.
+     */
+    algoStrategy?: string;
 }
 /** Single leg of a multi-leg option order (MLEG) */
 export interface ContractLegRequest {
@@ -191,10 +234,25 @@ export interface OrderLegRequest {
     timeInForce?: string;
     quantity?: number;
 }
-/** Algo parameters for request side */
+/**
+ * Algo parameters for request side (TWAP / VWAP).
+ *
+ * Fields match the Python SDK's AlgoParams. On the wire, the SDK marshals
+ * this object into the `[{tag, value}, ...]` array shape the gateway
+ * expects — callers should just pass the natural object.
+ *
+ * `algoStrategy` is intentionally not here: it lives on the parent
+ * `OrderRequest`, not inside `algoParams`.
+ */
 export interface AlgoParamsRequest {
-    algoStrategy?: string;
-    startTime?: string;
-    endTime?: string;
+    /** Epoch-ms start time (TWAP / VWAP only) */
+    startTime?: number;
+    /** Epoch-ms end time (TWAP / VWAP only) */
+    endTime?: number;
+    /** Try to minimize trade count (VWAP only) */
+    noTakeLiq?: boolean;
+    /** Allow completing after end_time (TWAP / VWAP only) */
+    allowPastEndTime?: boolean;
+    /** Participation rate 0.01–0.5 (VWAP only) */
     participationRate?: number;
 }