@fullstackcraftllc/floe 0.0.1 → 0.0.2

package/dist/client/brokers/TradierClient.js

@@ -0,0 +1,434 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TradierClient = void 0;
+const occ_1 = require("../../utils/occ");
+/**
+ * Regex pattern to identify OCC option symbols
+ * Matches both compact format (e.g., AAPL230120C00150000) and
+ * padded format (e.g., 'AAPL  230120C00150000')
+ * Pattern: 1-6 char root + YYMMDD + C/P + 8-digit strike
+ */
+const OCC_OPTION_PATTERN = /^.{1,6}\d{6}[CP]\d{8}$/;
+/**
+ * TradierClient handles real-time streaming connections to the Tradier API.
+ *
+ * @remarks
+ * This client manages WebSocket connections to Tradier's streaming API,
+ * normalizes incoming quote and trade data, and emits events for upstream
+ * consumption by the FloeClient.
+ *
+ * @example
+ * ```typescript
+ * const client = new TradierClient('your-api-key');
+ *
+ * client.on('tickerUpdate', (ticker) => {
+ *   console.log(`${ticker.symbol}: ${ticker.spot}`);
+ * });
+ *
+ * await client.connect();
+ * client.subscribe(['QQQ', 'AAPL  240119C00500000']);
+ * ```
+ */
+class TradierClient {
+    /**
+     * Creates a new TradierClient instance.
+     *
+     * @param authKey - Tradier API access token
+     */
+    constructor(authKey) {
+        /** Current streaming session */
+        this.streamSession = null;
+        /** WebSocket connection */
+        this.ws = null;
+        /** Connection state */
+        this.connected = false;
+        /** Currently subscribed symbols (tickers and options) */
+        this.subscribedSymbols = new Set();
+        /** Cached ticker data (for merging quote and trade events) */
+        this.tickerCache = new Map();
+        /** Cached option data (for merging quote and trade events) */
+        this.optionCache = new Map();
+        /** Event listeners */
+        this.eventListeners = new Map();
+        /** Reconnection attempt counter */
+        this.reconnectAttempts = 0;
+        /** Maximum reconnection attempts */
+        this.maxReconnectAttempts = 5;
+        /** Reconnection delay in ms (doubles with each attempt) */
+        this.baseReconnectDelay = 1000;
+        /** Tradier API base URL */
+        this.apiBaseUrl = 'https://api.tradier.com/v1';
+        /** Tradier WebSocket URL */
+        this.wsUrl = 'wss://ws.tradier.com/v1/markets/events';
+        this.authKey = authKey;
+        // Initialize event listener maps
+        this.eventListeners.set('tickerUpdate', new Set());
+        this.eventListeners.set('optionUpdate', new Set());
+        this.eventListeners.set('connected', new Set());
+        this.eventListeners.set('disconnected', new Set());
+        this.eventListeners.set('error', new Set());
+    }
+    // ==================== Public API ====================
+    /**
+     * Establishes a streaming connection to Tradier.
+     *
+     * @returns Promise that resolves when connected
+     * @throws {Error} If session creation or WebSocket connection fails
+     */
+    async connect() {
+        // Create streaming session
+        const session = await this.createStreamSession();
+        if (!session) {
+            throw new Error('Failed to create Tradier streaming session');
+        }
+        this.streamSession = session;
+        // Connect WebSocket
+        await this.connectWebSocket();
+    }
+    /**
+     * Disconnects from the Tradier streaming API.
+     */
+    disconnect() {
+        if (this.ws) {
+            this.ws.close(1000, 'Client disconnect');
+            this.ws = null;
+        }
+        this.connected = false;
+        this.streamSession = null;
+        this.subscribedSymbols.clear();
+    }
+    /**
+     * Subscribes to real-time updates for the specified symbols.
+     *
+     * @param symbols - Array of ticker symbols and/or OCC option symbols
+     */
+    subscribe(symbols) {
+        if (!this.connected || !this.ws || !this.streamSession) {
+            // Queue symbols for subscription when connected
+            symbols.forEach(s => this.subscribedSymbols.add(s));
+            return;
+        }
+        // Add to tracked symbols
+        symbols.forEach(s => this.subscribedSymbols.add(s));
+        // Send subscription message
+        const payload = {
+            sessionid: this.streamSession.sessionid,
+            symbols: symbols,
+        };
+        this.ws.send(JSON.stringify(payload));
+    }
+    /**
+     * Unsubscribes from real-time updates for the specified symbols.
+     *
+     * @param symbols - Array of symbols to unsubscribe from
+     *
+     * @remarks
+     * Note: Tradier's streaming API doesn't support unsubscription for individual
+     * symbols. This method removes them from local tracking. To fully unsubscribe,
+     * you would need to disconnect and reconnect with the new symbol list.
+     */
+    unsubscribe(symbols) {
+        symbols.forEach(s => this.subscribedSymbols.delete(s));
+        // Note: Tradier doesn't support selective unsubscribe
+        // Would need to reconnect with new symbol list for full effect
+    }
+    /**
+     * Returns whether the client is currently connected.
+     */
+    isConnected() {
+        return this.connected;
+    }
+    /**
+     * Registers an event listener.
+     *
+     * @param event - Event type to listen for
+     * @param listener - Callback function
+     */
+    on(event, listener) {
+        const listeners = this.eventListeners.get(event);
+        if (listeners) {
+            listeners.add(listener);
+        }
+        return this;
+    }
+    /**
+     * Removes an event listener.
+     *
+     * @param event - Event type
+     * @param listener - Callback function to remove
+     */
+    off(event, listener) {
+        const listeners = this.eventListeners.get(event);
+        if (listeners) {
+            listeners.delete(listener);
+        }
+        return this;
+    }
+    // ==================== Private Methods ====================
+    /**
+     * Creates a streaming session with Tradier API.
+     */
+    async createStreamSession() {
+        try {
+            const response = await fetch(`${this.apiBaseUrl}/markets/events/session`, {
+                method: 'POST',
+                headers: {
+                    'Authorization': `Bearer ${this.authKey}`,
+                    'Accept': 'application/json',
+                },
+            });
+            if (!response.ok) {
+                this.emit('error', new Error(`Failed to create stream session: ${response.statusText}`));
+                return null;
+            }
+            const data = await response.json();
+            return data.stream;
+        }
+        catch (error) {
+            this.emit('error', error instanceof Error ? error : new Error(String(error)));
+            return null;
+        }
+    }
+    /**
+     * Connects to the Tradier WebSocket.
+     */
+    connectWebSocket() {
+        return new Promise((resolve, reject) => {
+            this.ws = new WebSocket(this.wsUrl);
+            this.ws.onopen = () => {
+                this.connected = true;
+                this.reconnectAttempts = 0;
+                this.emit('connected', undefined);
+                // Subscribe to any queued symbols
+                if (this.subscribedSymbols.size > 0 && this.streamSession) {
+                    const payload = {
+                        sessionid: this.streamSession.sessionid,
+                        symbols: Array.from(this.subscribedSymbols),
+                    };
+                    this.ws.send(JSON.stringify(payload));
+                }
+                resolve();
+            };
+            this.ws.onmessage = (event) => {
+                this.handleMessage(event.data);
+            };
+            this.ws.onclose = (event) => {
+                this.connected = false;
+                this.emit('disconnected', { reason: event.reason });
+                // Attempt reconnection if not a clean close
+                if (event.code !== 1000) {
+                    this.attemptReconnect();
+                }
+            };
+            this.ws.onerror = (error) => {
+                this.emit('error', new Error('WebSocket error'));
+                reject(error);
+            };
+        });
+    }
+    /**
+     * Attempts to reconnect with exponential backoff.
+     */
+    async attemptReconnect() {
+        if (this.reconnectAttempts >= this.maxReconnectAttempts) {
+            this.emit('error', new Error('Max reconnection attempts reached'));
+            return;
+        }
+        this.reconnectAttempts++;
+        const delay = this.baseReconnectDelay * Math.pow(2, this.reconnectAttempts - 1);
+        await this.sleep(delay);
+        try {
+            await this.connect();
+        }
+        catch {
+            // Reconnect attempt failed, will try again via onclose
+        }
+    }
+    /**
+     * Handles incoming WebSocket messages.
+     */
+    handleMessage(data) {
+        try {
+            const event = JSON.parse(data);
+            if (event.type === 'quote') {
+                this.handleQuoteEvent(event);
+            }
+            else if (event.type === 'trade') {
+                this.handleTradeEvent(event);
+            }
+        }
+        catch (error) {
+            // Ignore parse errors for heartbeat/status messages
+        }
+    }
+    /**
+     * Handles quote events (bid/ask updates).
+     */
+    handleQuoteEvent(event) {
+        const { symbol } = event;
+        const timestamp = parseInt(event.biddate, 10) || Date.now();
+        const isOption = this.isOptionSymbol(symbol);
+        if (isOption) {
+            this.updateOptionFromQuote(symbol, event, timestamp);
+        }
+        else {
+            this.updateTickerFromQuote(symbol, event, timestamp);
+        }
+    }
+    /**
+     * Handles trade events (last price/volume updates).
+     */
+    handleTradeEvent(event) {
+        const { symbol } = event;
+        const timestamp = parseInt(event.date, 10) || Date.now();
+        const isOption = this.isOptionSymbol(symbol);
+        if (isOption) {
+            this.updateOptionFromTrade(symbol, event, timestamp);
+        }
+        else {
+            this.updateTickerFromTrade(symbol, event, timestamp);
+        }
+    }
+    /**
+     * Updates ticker data from a quote event.
+     */
+    updateTickerFromQuote(symbol, event, timestamp) {
+        const existing = this.tickerCache.get(symbol);
+        const ticker = {
+            symbol,
+            spot: (event.bid + event.ask) / 2,
+            bid: event.bid,
+            bidSize: event.bidsz,
+            ask: event.ask,
+            askSize: event.asksz,
+            last: existing?.last ?? 0,
+            volume: existing?.volume ?? 0,
+            timestamp,
+        };
+        this.tickerCache.set(symbol, ticker);
+        this.emit('tickerUpdate', ticker);
+    }
+    /**
+     * Updates ticker data from a trade event.
+     */
+    updateTickerFromTrade(symbol, event, timestamp) {
+        const existing = this.tickerCache.get(symbol);
+        const last = parseFloat(event.last);
+        const volume = parseInt(event.cvol, 10);
+        const ticker = {
+            symbol,
+            spot: existing?.spot ?? last,
+            bid: existing?.bid ?? 0,
+            bidSize: existing?.bidSize ?? 0,
+            ask: existing?.ask ?? 0,
+            askSize: existing?.askSize ?? 0,
+            last,
+            volume,
+            timestamp,
+        };
+        this.tickerCache.set(symbol, ticker);
+        this.emit('tickerUpdate', ticker);
+    }
+    /**
+     * Updates option data from a quote event.
+     */
+    updateOptionFromQuote(occSymbol, event, timestamp) {
+        const existing = this.optionCache.get(occSymbol);
+        // Parse OCC symbol to extract option details
+        let parsed;
+        try {
+            parsed = (0, occ_1.parseOCCSymbol)(occSymbol);
+        }
+        catch {
+            // Invalid OCC symbol, skip
+            return;
+        }
+        const option = {
+            occSymbol,
+            underlying: parsed.symbol,
+            strike: parsed.strike,
+            expiration: parsed.expiration.toISOString().split('T')[0],
+            expirationTimestamp: parsed.expiration.getTime(),
+            optionType: parsed.optionType,
+            bid: event.bid,
+            bidSize: event.bidsz,
+            ask: event.ask,
+            askSize: event.asksz,
+            mark: (event.bid + event.ask) / 2,
+            last: existing?.last ?? 0,
+            volume: existing?.volume ?? 0,
+            openInterest: existing?.openInterest ?? 0,
+            impliedVolatility: existing?.impliedVolatility ?? 0,
+            timestamp,
+        };
+        this.optionCache.set(occSymbol, option);
+        this.emit('optionUpdate', option);
+    }
+    /**
+     * Updates option data from a trade event.
+     */
+    updateOptionFromTrade(occSymbol, event, timestamp) {
+        const existing = this.optionCache.get(occSymbol);
+        // Parse OCC symbol to extract option details
+        let parsed;
+        try {
+            parsed = (0, occ_1.parseOCCSymbol)(occSymbol);
+        }
+        catch {
+            // Invalid OCC symbol, skip
+            return;
+        }
+        const last = parseFloat(event.last);
+        const volume = parseInt(event.cvol, 10);
+        const option = {
+            occSymbol,
+            underlying: parsed.symbol,
+            strike: parsed.strike,
+            expiration: parsed.expiration.toISOString().split('T')[0],
+            expirationTimestamp: parsed.expiration.getTime(),
+            optionType: parsed.optionType,
+            bid: existing?.bid ?? 0,
+            bidSize: existing?.bidSize ?? 0,
+            ask: existing?.ask ?? 0,
+            askSize: existing?.askSize ?? 0,
+            mark: existing?.mark ?? last,
+            last,
+            volume,
+            openInterest: existing?.openInterest ?? 0,
+            impliedVolatility: existing?.impliedVolatility ?? 0,
+            timestamp,
+        };
+        this.optionCache.set(occSymbol, option);
+        this.emit('optionUpdate', option);
+    }
+    /**
+     * Checks if a symbol is an OCC option symbol.
+     */
+    isOptionSymbol(symbol) {
+        return OCC_OPTION_PATTERN.test(symbol);
+    }
+    /**
+     * Emits an event to all registered listeners.
+     */
+    emit(event, data) {
+        const listeners = this.eventListeners.get(event);
+        if (listeners) {
+            listeners.forEach(listener => {
+                try {
+                    listener(data);
+                }
+                catch (error) {
+                    // Don't let listener errors break the stream
+                    console.error('Event listener error:', error);
+                }
+            });
+        }
+    }
+    /**
+     * Simple sleep utility.
+     */
+    sleep(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+}
+exports.TradierClient = TradierClient;

package/dist/index.d.ts

@@ -10,4 +10,8 @@ export { getIVSurfaces, getIVForStrike, } from './volatility';
 export { smoothTotalVarianceSmile, } from './volatility/smoothing';
 export { calculateGammaVannaCharmExposures, calculateSharesNeededToCover, } from './exposure';
 export { cumulativeNormalDistribution, normalPDF, } from './utils/statistics';
+export { buildOCCSymbol, parseOCCSymbol, generateStrikesAroundSpot, generateOCCSymbolsForStrikes, generateOCCSymbolsAroundSpot, } from './utils/occ';
+export type { OCCSymbolParams, ParsedOCCSymbol, StrikeGenerationParams, } from './utils/occ';
+export { FloeClient, Broker } from './client/FloeClient';
+export { TradierClient } from './client/brokers/TradierClient';
 export { genericAdapter, schwabAdapter, ibkrAdapter, tdaAdapter, brokerAdapters, getAdapter, createOptionChain, } from './adapters';

package/dist/index.js

@@ -20,7 +20,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createOptionChain = exports.getAdapter = exports.brokerAdapters = exports.tdaAdapter = exports.ibkrAdapter = exports.schwabAdapter = exports.genericAdapter = exports.normalPDF = exports.cumulativeNormalDistribution = exports.calculateSharesNeededToCover = exports.calculateGammaVannaCharmExposures = exports.smoothTotalVarianceSmile = exports.getIVForStrike = exports.getIVSurfaces = exports.getTimeToExpirationInYears = exports.getMillisecondsToExpiration = exports.calculateImpliedVolatility = exports.calculateGreeks = exports.blackScholes = void 0;
+exports.createOptionChain = exports.getAdapter = exports.brokerAdapters = exports.tdaAdapter = exports.ibkrAdapter = exports.schwabAdapter = exports.genericAdapter = exports.TradierClient = exports.Broker = exports.FloeClient = exports.generateOCCSymbolsAroundSpot = exports.generateOCCSymbolsForStrikes = exports.generateStrikesAroundSpot = exports.parseOCCSymbol = exports.buildOCCSymbol = exports.normalPDF = exports.cumulativeNormalDistribution = exports.calculateSharesNeededToCover = exports.calculateGammaVannaCharmExposures = exports.smoothTotalVarianceSmile = exports.getIVForStrike = exports.getIVSurfaces = exports.getTimeToExpirationInYears = exports.getMillisecondsToExpiration = exports.calculateImpliedVolatility = exports.calculateGreeks = exports.blackScholes = void 0;
 // Core types
 __exportStar(require("./types"), exports);
 // Black-Scholes pricing and Greeks
@@ -45,6 +45,19 @@ Object.defineProperty(exports, "calculateSharesNeededToCover", { enumerable: tru
 var statistics_1 = require("./utils/statistics");
 Object.defineProperty(exports, "cumulativeNormalDistribution", { enumerable: true, get: function () { return statistics_1.cumulativeNormalDistribution; } });
 Object.defineProperty(exports, "normalPDF", { enumerable: true, get: function () { return statistics_1.normalPDF; } });
+// OCC symbol utilities
+var occ_1 = require("./utils/occ");
+Object.defineProperty(exports, "buildOCCSymbol", { enumerable: true, get: function () { return occ_1.buildOCCSymbol; } });
+Object.defineProperty(exports, "parseOCCSymbol", { enumerable: true, get: function () { return occ_1.parseOCCSymbol; } });
+Object.defineProperty(exports, "generateStrikesAroundSpot", { enumerable: true, get: function () { return occ_1.generateStrikesAroundSpot; } });
+Object.defineProperty(exports, "generateOCCSymbolsForStrikes", { enumerable: true, get: function () { return occ_1.generateOCCSymbolsForStrikes; } });
+Object.defineProperty(exports, "generateOCCSymbolsAroundSpot", { enumerable: true, get: function () { return occ_1.generateOCCSymbolsAroundSpot; } });
+// Client
+var FloeClient_1 = require("./client/FloeClient");
+Object.defineProperty(exports, "FloeClient", { enumerable: true, get: function () { return FloeClient_1.FloeClient; } });
+Object.defineProperty(exports, "Broker", { enumerable: true, get: function () { return FloeClient_1.Broker; } });
+var TradierClient_1 = require("./client/brokers/TradierClient");
+Object.defineProperty(exports, "TradierClient", { enumerable: true, get: function () { return TradierClient_1.TradierClient; } });
 // Broker adapters
 var adapters_1 = require("./adapters");
 Object.defineProperty(exports, "genericAdapter", { enumerable: true, get: function () { return adapters_1.genericAdapter; } });

package/dist/types/index.d.ts

@@ -63,10 +63,37 @@ export interface Greeks {
     /** Ultima: Rate of change of volga with respect to volatility */
     ultima: number;
 }
+/**
+ * Normalized ticker data structure (broker-agnostic)
+ */
+export interface NormalizedTicker {
+    /** Underlying symbol */
+    symbol: string;
+    /** Current spot price of the underlying (mid of bid/ask, or last trade) */
+    spot: number;
+    /** Current bid price */
+    bid: number;
+    /** Current bid size */
+    bidSize: number;
+    /** Current ask price */
+    ask: number;
+    /** Current ask size */
+    askSize: number;
+    /** Last traded price */
+    last: number;
+    /** Cumulative volume for the day */
+    volume: number;
+    /** Timestamp of the quote in milliseconds */
+    timestamp: number;
+}
 /**
  * Normalized option data structure (broker-agnostic)
  */
 export interface NormalizedOption {
+    /** OCC-formatted option symbol (e.g., 'AAPL  230120C00150000') */
+    occSymbol: string;
+    /** Underlying ticker symbol */
+    underlying: string;
     /** Strike price */
     strike: number;
     /** Expiration date (ISO 8601) */
@@ -77,8 +104,12 @@ export interface NormalizedOption {
     optionType: OptionType;
     /** Current bid price */
     bid: number;
+    /** Current bid size */
+    bidSize: number;
     /** Current ask price */
     ask: number;
+    /** Current ask size */
+    askSize: number;
     /** Mark (mid) price */
     mark: number;
     /** Last traded price */
@@ -87,8 +118,12 @@ export interface NormalizedOption {
     volume: number;
     /** Open interest */
     openInterest: number;
+    /** Live open interest - calculated intraday by comparing using open interest as t=0 and comparing trades to the current NBBO for that option */
+    liveOpenInterest?: number;
     /** Implied volatility (as decimal) */
     impliedVolatility: number;
+    /** Timestamp of the quote in milliseconds */
+    timestamp: number;
     /** Pre-calculated Greeks (optional) */
     greeks?: Greeks;
 }

package/dist/utils/occ.d.ts

@@ -0,0 +1,164 @@
+/**
+ * OCC (Options Clearing Corporation) symbol utilities
+ *
+ * OCC symbols follow the format: ROOT + YYMMDD + C/P + STRIKE
+ * Example: AAPL230120C00150000 = AAPL $150 Call expiring Jan 20, 2023
+ */
+import { OptionType } from '../types';
+/**
+ * Parameters for building an OCC option symbol
+ */
+export interface OCCSymbolParams {
+    /** Underlying ticker symbol (e.g., 'AAPL', 'QQQ') */
+    symbol: string;
+    /** Expiration date (Date object or ISO string) */
+    expiration: Date | string;
+    /** Option type: 'call' or 'put' */
+    optionType: OptionType;
+    /** Strike price in dollars (e.g., 150.50) */
+    strike: number;
+    /**
+     * If true, pads the symbol to 6 characters with spaces (standard OCC format).
+     * If false (default), uses compact format without spaces (common for APIs).
+     * @default false
+     */
+    padded?: boolean;
+}
+/**
+ * Parsed components of an OCC option symbol
+ */
+export interface ParsedOCCSymbol {
+    /** Underlying ticker symbol */
+    symbol: string;
+    /** Expiration date */
+    expiration: Date;
+    /** Option type */
+    optionType: OptionType;
+    /** Strike price in dollars */
+    strike: number;
+}
+/**
+ * Parameters for generating strikes around a spot price
+ */
+export interface StrikeGenerationParams {
+    /** Current spot/underlying price */
+    spot: number;
+    /** Number of strikes above spot to include */
+    strikesAbove?: number;
+    /** Number of strikes below spot to include */
+    strikesBelow?: number;
+    /** Strike increment (e.g., 1 for $1 increments, 5 for $5) */
+    strikeIncrement?: number;
+}
+/**
+ * Builds an OCC-formatted option symbol.
+ *
+ * @param params - The option parameters
+ * @returns OCC-formatted symbol string
+ *
+ * @remarks
+ * OCC format: ROOT(6 chars, left-padded) + YYMMDD + C/P + STRIKE(8 digits, price × 1000)
+ *
+ * @example
+ * ```typescript
+ * const symbol = buildOCCSymbol({
+ *   symbol: 'AAPL',
+ *   expiration: new Date('2023-01-20'),
+ *   optionType: 'call',
+ *   strike: 150
+ * });
+ * // Returns: 'AAPL230120C00150000' (compact format, default)
+ *
+ * // With padded format (standard OCC)
+ * const symbol2 = buildOCCSymbol({
+ *   symbol: 'QQQ',
+ *   expiration: '2024-03-15',
+ *   optionType: 'put',
+ *   strike: 425.50,
+ *   padded: true
+ * });
+ * // Returns: 'QQQ   240315P00425500'
+ * ```
+ */
+export declare function buildOCCSymbol(params: OCCSymbolParams): string;
+/**
+ * Parses an OCC-formatted option symbol into its components.
+ * Supports both compact format (e.g., 'AAPL230120C00150000') and
+ * padded format (e.g., 'AAPL  230120C00150000').
+ *
+ * @param occSymbol - The OCC symbol to parse
+ * @returns Parsed symbol components
+ * @throws {Error} If the symbol format is invalid
+ *
+ * @example
+ * ```typescript
+ * // Compact format
+ * const parsed = parseOCCSymbol('AAPL230120C00150000');
+ * // Returns: { symbol: 'AAPL', expiration: Date, optionType: 'call', strike: 150 }
+ *
+ * // Padded format (21 chars)
+ * const parsed2 = parseOCCSymbol('AAPL  230120C00150000');
+ * // Returns: { symbol: 'AAPL', expiration: Date, optionType: 'call', strike: 150 }
+ * ```
+ */
+export declare function parseOCCSymbol(occSymbol: string): ParsedOCCSymbol;
+/**
+ * Generates an array of strike prices centered around a spot price.
+ *
+ * @param params - Strike generation parameters
+ * @returns Array of strike prices, sorted ascending
+ *
+ * @example
+ * ```typescript
+ * const strikes = generateStrikesAroundSpot({
+ *   spot: 450.25,
+ *   strikesAbove: 10,
+ *   strikesBelow: 10,
+ *   strikeIncrement: 5
+ * });
+ * // Returns: [405, 410, 415, 420, 425, 430, 435, 440, 445, 450, 455, 460, 465, 470, 475, 480, 485, 490, 495, 500]
+ * ```
+ */
+export declare function generateStrikesAroundSpot(params: StrikeGenerationParams): number[];
+/**
+ * Generates OCC symbols for calls and puts across multiple strikes.
+ *
+ * @param symbol - Underlying ticker symbol
+ * @param expiration - Option expiration date
+ * @param strikes - Array of strike prices
+ * @param includeTypes - Which option types to include (default: both)
+ * @returns Array of OCC symbol strings
+ *
+ * @example
+ * ```typescript
+ * const symbols = generateOCCSymbolsForStrikes(
+ *   'QQQ',
+ *   new Date('2024-01-19'),
+ *   [495, 500, 505],
+ *   ['call', 'put']
+ * );
+ * // Returns 6 symbols: 3 calls + 3 puts
+ * ```
+ */
+export declare function generateOCCSymbolsForStrikes(symbol: string, expiration: Date | string, strikes: number[], includeTypes?: OptionType[]): string[];
+/**
+ * Convenience function to generate OCC symbols around current spot price.
+ *
+ * @param symbol - Underlying ticker symbol
+ * @param expiration - Option expiration date
+ * @param spot - Current spot price
+ * @param options - Strike generation options
+ * @returns Array of OCC symbol strings for calls and puts
+ *
+ * @example
+ * ```typescript
+ * // Generate 20 calls + 20 puts around QQQ at $502.50
+ * const symbols = generateOCCSymbolsAroundSpot('QQQ', '2024-01-19', 502.50, {
+ *   strikesAbove: 10,
+ *   strikesBelow: 10,
+ *   strikeIncrement: 5
+ * });
+ * // Returns 42 symbols (21 strikes × 2 types)
+ * ```
+ */
+export declare function generateOCCSymbolsAroundSpot(symbol: string, expiration: Date | string, spot: number, options?: Omit<StrikeGenerationParams, 'spot'>): string[];