@fullstackcraftllc/floe 0.0.4 → 0.0.6

package/dist/client/brokers/TradeStationClient.js

@@ -0,0 +1,880 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TradeStationClient = void 0;
+const occ_1 = require("../../utils/occ");
+/**
+ * Regex pattern to identify TradeStation option symbols
+ * TradeStation uses space-padded format: "MSFT 220916C305"
+ */
+const TS_OPTION_PATTERN = /^[A-Z]+\s+\d{6}[CP]\d+(\.\d+)?$/;
+/**
+ * Regex pattern to identify OCC option symbols
+ * Format: ROOT + YYMMDD + C/P + 8-digit strike
+ */
+const OCC_OPTION_PATTERN = /^.{1,6}\d{6}[CP]\d{8}$/;
+/**
+ * TradeStationClient handles real-time streaming connections to the TradeStation API
+ * via HTTP chunked transfer encoding.
+ *
+ * @remarks
+ * This client manages HTTP streaming connections to TradeStation's market data API,
+ * normalizes incoming quote data, and emits events for upstream consumption by
+ * the FloeClient.
+ *
+ * TradeStation uses HTTP streaming (chunked transfer encoding) instead of WebSockets.
+ * Each stream is a long-lived HTTP connection that returns JSON objects separated
+ * by newlines.
+ *
+ * @example
+ * ```typescript
+ * const client = new TradeStationClient({
+ *   accessToken: 'your-oauth-access-token'
+ * });
+ *
+ * client.on('tickerUpdate', (ticker) => {
+ *   console.log(`${ticker.symbol}: ${ticker.spot}`);
+ * });
+ *
+ * await client.connect();
+ * client.subscribe(['MSFT', 'AAPL']);
+ * ```
+ */
+class TradeStationClient {
+    /**
+     * Creates a new TradeStationClient instance.
+     *
+     * @param options - Client configuration options
+     * @param options.accessToken - TradeStation OAuth access token (required)
+     * @param options.refreshToken - OAuth refresh token for automatic token renewal
+     * @param options.simulation - Whether to use simulation environment (default: false)
+     * @param options.onTokenRefresh - Callback when token is refreshed
+     * @param options.verbose - Whether to log verbose debug information (default: false)
+     */
+    constructor(options) {
+        /** Connection state */
+        this.connected = false;
+        /** Currently subscribed ticker symbols */
+        this.subscribedTickers = new Set();
+        /** Currently subscribed option symbols */
+        this.subscribedOptions = new Set();
+        /** Active AbortControllers for streams */
+        this.activeStreams = new Map();
+        /** Cached ticker data */
+        this.tickerCache = new Map();
+        /** Cached option data */
+        this.optionCache = new Map();
+        /** Base open interest from REST API */
+        this.baseOpenInterest = new Map();
+        /** Cumulative estimated OI change from intraday trades */
+        this.cumulativeOIChange = new Map();
+        /** History of intraday trades */
+        this.intradayTrades = new Map();
+        /** Event listeners */
+        this.eventListeners = new Map();
+        /** Reconnection attempt counter */
+        this.reconnectAttempts = 0;
+        /** Maximum reconnection attempts */
+        this.maxReconnectAttempts = 5;
+        /** Reconnection delay in ms */
+        this.baseReconnectDelay = 1000;
+        /** TradeStation API base URL */
+        this.apiBaseUrl = 'https://api.tradestation.com/v3';
+        /** Refresh token for token refresh */
+        this.refreshToken = null;
+        /** Token refresh callback */
+        this.onTokenRefresh = null;
+        this.accessToken = options.accessToken;
+        this.refreshToken = options.refreshToken ?? null;
+        this.simulation = options.simulation ?? false;
+        this.onTokenRefresh = options.onTokenRefresh ?? null;
+        this.verbose = options.verbose ?? false;
+        // Initialize event listener maps
+        this.eventListeners.set('tickerUpdate', new Set());
+        this.eventListeners.set('optionUpdate', new Set());
+        this.eventListeners.set('optionTrade', new Set());
+        this.eventListeners.set('connected', new Set());
+        this.eventListeners.set('disconnected', new Set());
+        this.eventListeners.set('error', new Set());
+    }
+    // ==================== Public API ====================
+    /**
+     * Establishes connection state for TradeStation streaming.
+     *
+     * @returns Promise that resolves when ready to stream
+     * @throws {Error} If token validation fails
+     *
+     * @remarks
+     * Unlike WebSocket-based clients, TradeStation uses HTTP streaming.
+     * This method validates the access token by making a test API call.
+     */
+    async connect() {
+        try {
+            // Validate token by making a simple API call
+            const response = await fetch(`${this.apiBaseUrl}/brokerage/accounts`, {
+                method: 'GET',
+                headers: this.getAuthHeaders(),
+            });
+            if (!response.ok) {
+                if (response.status === 401) {
+                    throw new Error('TradeStation authentication failed - invalid or expired token');
+                }
+                throw new Error(`TradeStation connection failed: ${response.statusText}`);
+            }
+            this.connected = true;
+            this.reconnectAttempts = 0;
+            if (this.verbose) {
+                console.log('[TradeStation:HTTP] Connected to streaming API');
+            }
+            this.emit('connected', undefined);
+        }
+        catch (error) {
+            this.emit('error', error instanceof Error ? error : new Error(String(error)));
+            throw error;
+        }
+    }
+    /**
+     * Disconnects from all TradeStation streaming APIs.
+     */
+    disconnect() {
+        // Abort all active streams
+        for (const [streamId, controller] of this.activeStreams) {
+            controller.abort();
+        }
+        this.activeStreams.clear();
+        this.connected = false;
+        this.subscribedTickers.clear();
+        this.subscribedOptions.clear();
+        this.emit('disconnected', { reason: 'Client disconnect' });
+    }
+    /**
+     * Subscribes to real-time updates for the specified symbols.
+     *
+     * @param symbols - Array of ticker symbols and/or option symbols
+     *
+     * @remarks
+     * TradeStation uses different streaming endpoints for equities and options.
+     * This method automatically routes symbols to the appropriate endpoint.
+     *
+     * Option symbols can be in either:
+     * - TradeStation format: "MSFT 220916C305"
+     * - OCC format: "MSFT220916C00305000"
+     */
+    subscribe(symbols) {
+        const tickers = [];
+        const options = [];
+        for (const symbol of symbols) {
+            if (this.isOptionSymbol(symbol)) {
+                options.push(symbol);
+                this.subscribedOptions.add(symbol);
+            }
+            else {
+                tickers.push(symbol);
+                this.subscribedTickers.add(symbol);
+            }
+        }
+        if (tickers.length > 0) {
+            this.startQuoteStream(tickers);
+        }
+        if (options.length > 0) {
+            this.startOptionQuoteStream(options);
+        }
+    }
+    /**
+     * Unsubscribes from real-time updates for the specified symbols.
+     *
+     * @param symbols - Array of symbols to unsubscribe from
+     *
+     * @remarks
+     * For TradeStation, unsubscribing requires stopping the stream and
+     * restarting with the remaining symbols.
+     */
+    unsubscribe(symbols) {
+        const tickersToRemove = [];
+        const optionsToRemove = [];
+        for (const symbol of symbols) {
+            if (this.isOptionSymbol(symbol)) {
+                this.subscribedOptions.delete(symbol);
+                optionsToRemove.push(symbol);
+            }
+            else {
+                this.subscribedTickers.delete(symbol);
+                tickersToRemove.push(symbol);
+            }
+        }
+        // Restart streams with remaining symbols
+        if (tickersToRemove.length > 0 && this.subscribedTickers.size > 0) {
+            this.stopStream('quotes');
+            this.startQuoteStream(Array.from(this.subscribedTickers));
+        }
+        else if (tickersToRemove.length > 0) {
+            this.stopStream('quotes');
+        }
+        if (optionsToRemove.length > 0 && this.subscribedOptions.size > 0) {
+            this.stopStream('options');
+            this.startOptionQuoteStream(Array.from(this.subscribedOptions));
+        }
+        else if (optionsToRemove.length > 0) {
+            this.stopStream('options');
+        }
+    }
+    /**
+     * Returns whether the client is currently connected.
+     */
+    isConnected() {
+        return this.connected;
+    }
+    /**
+     * Fetches quote snapshots for the specified symbols.
+     *
+     * @param symbols - Array of symbols (max 100)
+     * @returns Array of normalized tickers
+     */
+    async fetchQuotes(symbols) {
+        try {
+            const symbolList = symbols.slice(0, 100).join(',');
+            const url = `${this.apiBaseUrl}/marketdata/quotes/${encodeURIComponent(symbolList)}`;
+            const response = await fetch(url, {
+                method: 'GET',
+                headers: this.getAuthHeaders(),
+            });
+            if (!response.ok) {
+                this.emit('error', new Error(`Failed to fetch quotes: ${response.statusText}`));
+                return [];
+            }
+            const data = await response.json();
+            const tickers = [];
+            for (const quote of data.Quotes) {
+                if (!quote.Error) {
+                    const ticker = this.normalizeQuote(quote);
+                    this.tickerCache.set(ticker.symbol, ticker);
+                    tickers.push(ticker);
+                }
+            }
+            return tickers;
+        }
+        catch (error) {
+            this.emit('error', error instanceof Error ? error : new Error(String(error)));
+            return [];
+        }
+    }
+    /**
+     * Fetches option expirations for an underlying symbol.
+     *
+     * @param underlying - Underlying symbol (e.g., 'AAPL')
+     * @returns Array of expiration dates
+     */
+    async fetchOptionExpirations(underlying) {
+        try {
+            const url = `${this.apiBaseUrl}/marketdata/options/expirations/${encodeURIComponent(underlying)}`;
+            const response = await fetch(url, {
+                method: 'GET',
+                headers: this.getAuthHeaders(),
+            });
+            if (!response.ok) {
+                this.emit('error', new Error(`Failed to fetch option expirations: ${response.statusText}`));
+                return [];
+            }
+            const data = await response.json();
+            return data.Expirations.map(exp => exp.Date);
+        }
+        catch (error) {
+            this.emit('error', error instanceof Error ? error : new Error(String(error)));
+            return [];
+        }
+    }
+    /**
+     * Streams option chain data for an underlying symbol.
+     *
+     * @param underlying - Underlying symbol (e.g., 'AAPL')
+     * @param options - Stream options
+     * @returns Promise that resolves when stream is established
+     */
+    async streamOptionChain(underlying, options) {
+        const params = new URLSearchParams();
+        if (options?.expiration)
+            params.set('expiration', options.expiration);
+        if (options?.strikeProximity)
+            params.set('strikeProximity', options.strikeProximity.toString());
+        if (options?.enableGreeks !== undefined)
+            params.set('enableGreeks', options.enableGreeks.toString());
+        if (options?.optionType)
+            params.set('optionType', options.optionType);
+        const url = `${this.apiBaseUrl}/marketdata/stream/options/chains/${encodeURIComponent(underlying)}?${params.toString()}`;
+        const streamId = `chain_${underlying}`;
+        await this.startHttpStream(streamId, url, (data) => {
+            this.handleOptionChainData(underlying, data);
+        });
+    }
+    /**
+     * Fetches symbol details for the specified symbols.
+     *
+     * @param symbols - Array of symbols (max 50)
+     * @returns Symbol details response
+     */
+    async fetchSymbolDetails(symbols) {
+        try {
+            const symbolList = symbols.slice(0, 50).join(',');
+            const url = `${this.apiBaseUrl}/marketdata/symbols/${encodeURIComponent(symbolList)}`;
+            const response = await fetch(url, {
+                method: 'GET',
+                headers: this.getAuthHeaders(),
+            });
+            if (!response.ok) {
+                this.emit('error', new Error(`Failed to fetch symbol details: ${response.statusText}`));
+                return { Symbols: [], Errors: [] };
+            }
+            return await response.json();
+        }
+        catch (error) {
+            this.emit('error', error instanceof Error ? error : new Error(String(error)));
+            return { Symbols: [], Errors: [] };
+        }
+    }
+    /**
+     * Returns cached option data for a symbol.
+     */
+    getOption(occSymbol) {
+        return this.optionCache.get(occSymbol);
+    }
+    /**
+     * Returns all cached options.
+     */
+    getAllOptions() {
+        return new Map(this.optionCache);
+    }
+    /**
+     * Returns cached ticker data for a symbol.
+     */
+    getTicker(symbol) {
+        return this.tickerCache.get(symbol);
+    }
+    /**
+     * Returns all cached tickers.
+     */
+    getAllTickers() {
+        return new Map(this.tickerCache);
+    }
+    /**
+     * Registers an event listener.
+     */
+    on(event, listener) {
+        const listeners = this.eventListeners.get(event);
+        if (listeners) {
+            listeners.add(listener);
+        }
+        return this;
+    }
+    /**
+     * Removes an event listener.
+     */
+    off(event, listener) {
+        const listeners = this.eventListeners.get(event);
+        if (listeners) {
+            listeners.delete(listener);
+        }
+        return this;
+    }
+    /**
+     * Returns intraday trades for an option.
+     */
+    getIntradayTrades(occSymbol) {
+        return this.intradayTrades.get(occSymbol) ?? [];
+    }
+    /**
+     * Returns flow summary for an option.
+     */
+    getFlowSummary(occSymbol) {
+        const trades = this.intradayTrades.get(occSymbol) ?? [];
+        let buyVolume = 0;
+        let sellVolume = 0;
+        let unknownVolume = 0;
+        for (const trade of trades) {
+            switch (trade.aggressorSide) {
+                case 'buy':
+                    buyVolume += trade.size;
+                    break;
+                case 'sell':
+                    sellVolume += trade.size;
+                    break;
+                case 'unknown':
+                    unknownVolume += trade.size;
+                    break;
+            }
+        }
+        return {
+            buyVolume,
+            sellVolume,
+            unknownVolume,
+            netOIChange: this.cumulativeOIChange.get(occSymbol) ?? 0,
+            tradeCount: trades.length,
+        };
+    }
+    /**
+     * Resets intraday tracking data.
+     */
+    resetIntradayData(occSymbols) {
+        const symbolsToReset = occSymbols ?? Array.from(this.intradayTrades.keys());
+        for (const symbol of symbolsToReset) {
+            this.intradayTrades.delete(symbol);
+            this.cumulativeOIChange.set(symbol, 0);
+        }
+    }
+    /**
+     * Updates the access token (for token refresh scenarios).
+     */
+    updateAccessToken(newToken) {
+        this.accessToken = newToken;
+    }
+    // ==================== Private Methods ====================
+    /**
+     * Gets authorization headers for API requests.
+     */
+    getAuthHeaders() {
+        return {
+            'Authorization': `Bearer ${this.accessToken}`,
+            'Accept': 'application/json',
+        };
+    }
+    /**
+     * Gets headers for streaming requests.
+     */
+    getStreamHeaders() {
+        return {
+            'Authorization': `Bearer ${this.accessToken}`,
+            'Accept': 'application/vnd.tradestation.streams.v2+json',
+        };
+    }
+    /**
+     * Starts a quote stream for ticker symbols.
+     */
+    async startQuoteStream(symbols) {
+        if (symbols.length === 0)
+            return;
+        const symbolList = symbols.slice(0, 100).join(',');
+        const url = `${this.apiBaseUrl}/marketdata/stream/quotes/${encodeURIComponent(symbolList)}`;
+        await this.startHttpStream('quotes', url, (data) => {
+            this.handleQuoteData(data);
+        });
+    }
+    /**
+     * Starts an option quote stream.
+     */
+    async startOptionQuoteStream(symbols) {
+        if (symbols.length === 0)
+            return;
+        // TradeStation option streaming uses legs parameter
+        // Build URL with legs for each option
+        const params = new URLSearchParams();
+        symbols.forEach((symbol, index) => {
+            const tsSymbol = this.toTradeStationOptionSymbol(symbol);
+            params.set(`legs[${index}].Symbol`, tsSymbol);
+            params.set(`legs[${index}].Ratio`, '1');
+        });
+        params.set('enableGreeks', 'true');
+        const url = `${this.apiBaseUrl}/marketdata/stream/options/quotes?${params.toString()}`;
+        await this.startHttpStream('options', url, (data) => {
+            this.handleOptionQuoteData(data);
+        });
+    }
+    /**
+     * Starts an HTTP streaming connection.
+     */
+    async startHttpStream(streamId, url, onData) {
+        // Stop any existing stream with this ID
+        this.stopStream(streamId);
+        const controller = new AbortController();
+        this.activeStreams.set(streamId, controller);
+        try {
+            const response = await fetch(url, {
+                method: 'GET',
+                headers: this.getStreamHeaders(),
+                signal: controller.signal,
+            });
+            if (!response.ok) {
+                if (response.status === 401) {
+                    this.emit('error', new Error('TradeStation stream authentication failed'));
+                    return;
+                }
+                this.emit('error', new Error(`TradeStation stream failed: ${response.statusText}`));
+                return;
+            }
+            if (!response.body) {
+                this.emit('error', new Error('TradeStation stream response has no body'));
+                return;
+            }
+            // Process the stream
+            this.processStream(streamId, response.body, onData);
+        }
+        catch (error) {
+            if (error instanceof Error && error.name === 'AbortError') {
+                // Stream was intentionally aborted
+                return;
+            }
+            this.emit('error', error instanceof Error ? error : new Error(String(error)));
+        }
+    }
+    /**
+     * Processes an HTTP chunked stream.
+     */
+    async processStream(streamId, body, onData) {
+        const reader = body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = '';
+        try {
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done) {
+                    // Stream ended
+                    this.handleStreamEnd(streamId);
+                    break;
+                }
+                // Decode chunk and add to buffer
+                buffer += decoder.decode(value, { stream: true });
+                // Process complete JSON objects
+                // TradeStation separates objects with newlines
+                const lines = buffer.split('\n');
+                buffer = lines.pop() ?? ''; // Keep incomplete line in buffer
+                for (const line of lines) {
+                    const trimmed = line.trim();
+                    if (!trimmed)
+                        continue;
+                    try {
+                        const data = JSON.parse(trimmed);
+                        onData(data);
+                    }
+                    catch {
+                        // May be chunk boundary or malformed JSON, skip
+                    }
+                }
+            }
+        }
+        catch (error) {
+            if (error instanceof Error && error.name === 'AbortError') {
+                return;
+            }
+            this.emit('error', error instanceof Error ? error : new Error(String(error)));
+            this.handleStreamEnd(streamId);
+        }
+        finally {
+            reader.releaseLock();
+        }
+    }
+    /**
+     * Handles stream end/disconnect.
+     */
+    handleStreamEnd(streamId) {
+        this.activeStreams.delete(streamId);
+        if (this.activeStreams.size === 0) {
+            this.emit('disconnected', { reason: 'All streams ended' });
+        }
+    }
+    /**
+     * Stops a stream by ID.
+     */
+    stopStream(streamId) {
+        const controller = this.activeStreams.get(streamId);
+        if (controller) {
+            controller.abort();
+            this.activeStreams.delete(streamId);
+        }
+    }
+    /**
+     * Handles incoming quote stream data.
+     */
+    handleQuoteData(data) {
+        // Check for stream status
+        if (data.StreamStatus) {
+            if (data.StreamStatus === 'GoAway') {
+                // Server is terminating stream, need to reconnect
+                this.handleStreamGoAway('quotes');
+            }
+            return;
+        }
+        // Check for errors
+        if (data.Error) {
+            this.emit('error', new Error(`TradeStation quote error: ${data.Error}`));
+            return;
+        }
+        if (!data.Symbol)
+            return;
+        const ticker = this.normalizeQuote(data);
+        this.tickerCache.set(ticker.symbol, ticker);
+        this.emit('tickerUpdate', ticker);
+    }
+    /**
+     * Handles incoming option quote stream data.
+     */
+    handleOptionQuoteData(data) {
+        // Check for stream status
+        if (data.StreamStatus) {
+            if (data.StreamStatus === 'GoAway') {
+                this.handleStreamGoAway('options');
+            }
+            return;
+        }
+        if (data.Error) {
+            this.emit('error', new Error(`TradeStation option error: ${data.Error}`));
+            return;
+        }
+        if (!data.Legs || data.Legs.length === 0)
+            return;
+        // Process each leg
+        for (const leg of data.Legs) {
+            if (!leg.Symbol)
+                continue;
+            const option = this.normalizeOptionQuote(data, leg);
+            if (option) {
+                this.optionCache.set(option.occSymbol, option);
+                this.emit('optionUpdate', option);
+            }
+        }
+    }
+    /**
+     * Handles option chain stream data.
+     */
+    handleOptionChainData(underlying, data) {
+        if (data.StreamStatus) {
+            if (data.StreamStatus === 'GoAway') {
+                this.handleStreamGoAway(`chain_${underlying}`);
+            }
+            return;
+        }
+        if (data.Error) {
+            this.emit('error', new Error(`TradeStation chain error: ${data.Error}`));
+            return;
+        }
+        if (!data.Legs || data.Legs.length === 0)
+            return;
+        for (const leg of data.Legs) {
+            if (!leg.Symbol)
+                continue;
+            const option = this.normalizeOptionQuote(data, leg);
+            if (option) {
+                // Store base OI
+                if (leg.OpenInterest !== undefined) {
+                    this.baseOpenInterest.set(option.occSymbol, leg.OpenInterest);
+                    if (this.verbose) {
+                        console.log(`[TradeStation:OI] Base OI set for ${option.occSymbol}: ${leg.OpenInterest}`);
+                    }
+                }
+                if (!this.cumulativeOIChange.has(option.occSymbol)) {
+                    this.cumulativeOIChange.set(option.occSymbol, 0);
+                }
+                this.optionCache.set(option.occSymbol, option);
+                this.emit('optionUpdate', option);
+            }
+        }
+    }
+    /**
+     * Handles GoAway stream status - server is terminating stream.
+     */
+    handleStreamGoAway(streamId) {
+        // Remove the stream and attempt to restart after a delay
+        this.stopStream(streamId);
+        setTimeout(() => {
+            if (!this.connected)
+                return;
+            if (streamId === 'quotes' && this.subscribedTickers.size > 0) {
+                this.startQuoteStream(Array.from(this.subscribedTickers));
+            }
+            else if (streamId === 'options' && this.subscribedOptions.size > 0) {
+                this.startOptionQuoteStream(Array.from(this.subscribedOptions));
+            }
+            else if (streamId.startsWith('chain_')) {
+                const underlying = streamId.replace('chain_', '');
+                this.streamOptionChain(underlying);
+            }
+        }, this.baseReconnectDelay);
+    }
+    /**
+     * Normalizes TradeStation quote to NormalizedTicker.
+     */
+    normalizeQuote(quote) {
+        const bid = this.parseNumber(quote.Bid);
+        const ask = this.parseNumber(quote.Ask);
+        const last = this.parseNumber(quote.Last);
+        return {
+            symbol: quote.Symbol,
+            spot: bid > 0 && ask > 0 ? (bid + ask) / 2 : last,
+            bid,
+            bidSize: this.parseNumber(quote.BidSize),
+            ask,
+            askSize: this.parseNumber(quote.AskSize),
+            last,
+            volume: this.parseNumber(quote.Volume),
+            timestamp: quote.TradeTime ? new Date(quote.TradeTime).getTime() : Date.now(),
+        };
+    }
+    /**
+     * Normalizes TradeStation option quote to NormalizedOption.
+     */
+    normalizeOptionQuote(data, leg) {
+        // Convert TradeStation symbol to OCC format
+        const occSymbol = this.toOCCSymbol(leg.Symbol);
+        if (!occSymbol)
+            return null;
+        // Parse OCC symbol for details
+        let parsed;
+        try {
+            parsed = (0, occ_1.parseOCCSymbol)(occSymbol);
+        }
+        catch {
+            // Try to extract from leg data
+            if (!leg.Underlying || !leg.ExpirationDate || !leg.StrikePrice || !leg.OptionType) {
+                return null;
+            }
+            parsed = {
+                symbol: leg.Underlying,
+                expiration: new Date(leg.ExpirationDate),
+                optionType: leg.OptionType.toLowerCase(),
+                strike: parseFloat(leg.StrikePrice),
+            };
+        }
+        const bid = this.parseNumber(data.Bid);
+        const ask = this.parseNumber(data.Ask);
+        const last = this.parseNumber(data.Last);
+        const existingOI = this.baseOpenInterest.get(occSymbol) ?? 0;
+        return {
+            occSymbol,
+            underlying: leg.Underlying ?? parsed.symbol,
+            strike: parseFloat(leg.StrikePrice ?? parsed.strike.toString()),
+            expiration: leg.ExpirationDate ?? parsed.expiration.toISOString().split('T')[0],
+            expirationTimestamp: parsed.expiration.getTime(),
+            optionType: (leg.OptionType?.toLowerCase() ?? parsed.optionType),
+            bid,
+            bidSize: data.BidSize ?? 0,
+            ask,
+            askSize: data.AskSize ?? 0,
+            mark: bid > 0 && ask > 0 ? (bid + ask) / 2 : last,
+            last,
+            volume: data.Volume ?? 0,
+            openInterest: data.DailyOpenInterest ?? leg.OpenInterest ?? existingOI,
+            liveOpenInterest: this.calculateLiveOpenInterest(occSymbol),
+            impliedVolatility: this.parseNumber(data.ImpliedVolatility),
+            timestamp: Date.now(),
+        };
+    }
+    /**
+     * Converts TradeStation option symbol to OCC format.
+     * TradeStation format: "MSFT 220916C305" or "MSFT 220916C305.00"
+     * OCC format: "MSFT220916C00305000"
+     */
+    toOCCSymbol(tsSymbol) {
+        if (!tsSymbol)
+            return null;
+        // Already in OCC format?
+        if (OCC_OPTION_PATTERN.test(tsSymbol.replace(/\s+/g, ''))) {
+            return tsSymbol.replace(/\s+/g, '');
+        }
+        // Parse TradeStation format
+        const match = tsSymbol.match(/^([A-Z]+)\s+(\d{6})([CP])(\d+(?:\.\d+)?)$/);
+        if (!match)
+            return null;
+        const [, root, dateStr, optType, strikeStr] = match;
+        const strike = parseFloat(strikeStr);
+        const strikeFormatted = Math.round(strike * 1000).toString().padStart(8, '0');
+        return `${root}${dateStr}${optType}${strikeFormatted}`;
+    }
+    /**
+     * Converts OCC symbol to TradeStation format.
+     * OCC format: "MSFT220916C00305000"
+     * TradeStation format: "MSFT 220916C305"
+     */
+    toTradeStationOptionSymbol(symbol) {
+        // If already in TradeStation format, return as-is
+        if (TS_OPTION_PATTERN.test(symbol)) {
+            return symbol;
+        }
+        // Parse OCC format
+        try {
+            const parsed = (0, occ_1.parseOCCSymbol)(symbol);
+            const dateStr = [
+                parsed.expiration.getFullYear().toString().slice(-2),
+                (parsed.expiration.getMonth() + 1).toString().padStart(2, '0'),
+                parsed.expiration.getDate().toString().padStart(2, '0'),
+            ].join('');
+            const optType = parsed.optionType === 'call' ? 'C' : 'P';
+            // Format strike - remove trailing zeros
+            let strikeStr = parsed.strike.toString();
+            if (parsed.strike % 1 === 0) {
+                strikeStr = parsed.strike.toFixed(0);
+            }
+            return `${parsed.symbol} ${dateStr}${optType}${strikeStr}`;
+        }
+        catch {
+            return symbol;
+        }
+    }
+    /**
+     * Determines aggressor side from trade price vs NBBO.
+     */
+    determineAggressorSide(tradePrice, bid, ask) {
+        if (bid <= 0 || ask <= 0)
+            return 'unknown';
+        const spread = ask - bid;
+        const tolerance = spread > 0 ? spread * 0.001 : 0.001;
+        if (tradePrice >= ask - tolerance) {
+            return 'buy';
+        }
+        else if (tradePrice <= bid + tolerance) {
+            return 'sell';
+        }
+        return 'unknown';
+    }
+    /**
+     * Calculates estimated OI change from trade.
+     */
+    calculateOIChangeFromTrade(aggressorSide, size, _optionType) {
+        if (aggressorSide === 'unknown')
+            return 0;
+        return aggressorSide === 'buy' ? size : -size;
+    }
+    /**
+     * Calculates live open interest.
+     */
+    calculateLiveOpenInterest(occSymbol) {
+        const baseOI = this.baseOpenInterest.get(occSymbol) ?? 0;
+        const cumulativeChange = this.cumulativeOIChange.get(occSymbol) ?? 0;
+        return Math.max(0, baseOI + cumulativeChange);
+    }
+    /**
+     * Checks if a symbol is an option symbol.
+     */
+    isOptionSymbol(symbol) {
+        return TS_OPTION_PATTERN.test(symbol) || OCC_OPTION_PATTERN.test(symbol);
+    }
+    /**
+     * Parses a numeric string value.
+     */
+    parseNumber(value) {
+        if (value === undefined || value === null)
+            return 0;
+        if (typeof value === 'number')
+            return isNaN(value) ? 0 : value;
+        const num = parseFloat(value);
+        return isNaN(num) ? 0 : num;
+    }
+    /**
+     * Emits an event to all listeners.
+     */
+    emit(event, data) {
+        const listeners = this.eventListeners.get(event);
+        if (listeners) {
+            listeners.forEach(listener => {
+                try {
+                    listener(data);
+                }
+                catch (error) {
+                    console.error('Event listener error:', error);
+                }
+            });
+        }
+    }
+    /**
+     * Sleep utility.
+     */
+    sleep(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+}
+exports.TradeStationClient = TradeStationClient;