@adaptic/utils 0.0.383 → 0.1.1

package/dist/types/alpaca/crypto/orders.d.ts

@@ -0,0 +1,221 @@
+/**
+ * Crypto Orders Module
+ * Create and manage cryptocurrency orders
+ * Crypto trading is available 24/7 on Alpaca
+ */
+import { AlpacaClient } from '../client';
+import { AlpacaOrder, OrderSide, OrderType, TimeInForce } from '../../types/alpaca-types';
+/**
+ * Error thrown when crypto order operations fail
+ */
+export declare class CryptoOrderError extends Error {
+    code: string;
+    symbol?: string | undefined;
+    details?: unknown | undefined;
+    constructor(message: string, code: string, symbol?: string | undefined, details?: unknown | undefined);
+}
+/**
+ * Parameters for creating a crypto order
+ * Crypto trading is available 24/7
+ */
+export interface CryptoOrderParams {
+    /** Crypto pair symbol (e.g., 'BTC/USD', 'ETH/USD') */
+    symbol: string;
+    /** Quantity to trade (mutually exclusive with notional) */
+    qty?: number;
+    /** Dollar amount to trade (mutually exclusive with qty) */
+    notional?: number;
+    /** Order side: 'buy' or 'sell' */
+    side: OrderSide;
+    /** Order type: 'market', 'limit', 'stop', 'stop_limit' */
+    type: OrderType;
+    /** Limit price for limit/stop_limit orders */
+    limitPrice?: number;
+    /** Stop price for stop/stop_limit orders */
+    stopPrice?: number;
+    /** Time in force - typically 'gtc' for crypto */
+    timeInForce?: TimeInForce;
+    /** Optional client-specified order ID */
+    clientOrderId?: string;
+}
+/**
+ * Create a crypto order
+ * Crypto trading is available 24/7 on Alpaca
+ *
+ * @param client - The AlpacaClient instance
+ * @param params - Crypto order parameters
+ * @returns The created order
+ * @throws CryptoOrderError if order creation fails
+ *
+ * @example
+ * // Buy 0.5 BTC at market price
+ * const order = await createCryptoOrder(client, {
+ *   symbol: 'BTC/USD',
+ *   qty: 0.5,
+ *   side: 'buy',
+ *   type: 'market',
+ * });
+ *
+ * @example
+ * // Buy $100 worth of ETH
+ * const order = await createCryptoOrder(client, {
+ *   symbol: 'ETH/USD',
+ *   notional: 100,
+ *   side: 'buy',
+ *   type: 'market',
+ * });
+ */
+export declare function createCryptoOrder(client: AlpacaClient, params: CryptoOrderParams): Promise<AlpacaOrder>;
+/**
+ * Create a crypto market order
+ * Executes immediately at the current market price
+ *
+ * @param client - The AlpacaClient instance
+ * @param symbol - Crypto pair symbol (e.g., 'BTC/USD')
+ * @param side - Order side: 'buy' or 'sell'
+ * @param qty - Quantity to trade
+ * @returns The created order
+ *
+ * @example
+ * const order = await createCryptoMarketOrder(client, 'BTC/USD', 'buy', 0.1);
+ */
+export declare function createCryptoMarketOrder(client: AlpacaClient, symbol: string, side: OrderSide, qty: number): Promise<AlpacaOrder>;
+/**
+ * Create a crypto limit order
+ * Executes only at the specified price or better
+ *
+ * @param client - The AlpacaClient instance
+ * @param symbol - Crypto pair symbol (e.g., 'BTC/USD')
+ * @param side - Order side: 'buy' or 'sell'
+ * @param qty - Quantity to trade
+ * @param limitPrice - Maximum (buy) or minimum (sell) price
+ * @returns The created order
+ *
+ * @example
+ * // Buy 0.5 BTC at $40,000 or lower
+ * const order = await createCryptoLimitOrder(client, 'BTC/USD', 'buy', 0.5, 40000);
+ */
+export declare function createCryptoLimitOrder(client: AlpacaClient, symbol: string, side: OrderSide, qty: number, limitPrice: number): Promise<AlpacaOrder>;
+/**
+ * Create a crypto stop order
+ * Becomes a market order when the stop price is reached
+ *
+ * @param client - The AlpacaClient instance
+ * @param symbol - Crypto pair symbol (e.g., 'BTC/USD')
+ * @param side - Order side: 'buy' or 'sell'
+ * @param qty - Quantity to trade
+ * @param stopPrice - Price at which to trigger the order
+ * @returns The created order
+ *
+ * @example
+ * // Sell 0.5 BTC if price drops to $35,000
+ * const order = await createCryptoStopOrder(client, 'BTC/USD', 'sell', 0.5, 35000);
+ */
+export declare function createCryptoStopOrder(client: AlpacaClient, symbol: string, side: OrderSide, qty: number, stopPrice: number): Promise<AlpacaOrder>;
+/**
+ * Create a crypto stop-limit order
+ * Becomes a limit order when the stop price is reached
+ *
+ * @param client - The AlpacaClient instance
+ * @param symbol - Crypto pair symbol (e.g., 'BTC/USD')
+ * @param side - Order side: 'buy' or 'sell'
+ * @param qty - Quantity to trade
+ * @param stopPrice - Price at which to trigger the limit order
+ * @param limitPrice - Limit price for the resulting order
+ * @returns The created order
+ *
+ * @example
+ * // Sell 0.5 BTC when price drops to $35,000, but not below $34,500
+ * const order = await createCryptoStopLimitOrder(client, 'BTC/USD', 'sell', 0.5, 35000, 34500);
+ */
+export declare function createCryptoStopLimitOrder(client: AlpacaClient, symbol: string, side: OrderSide, qty: number, stopPrice: number, limitPrice: number): Promise<AlpacaOrder>;
+/**
+ * Buy crypto with a dollar amount (notional order)
+ * Allows purchasing crypto with a specific USD amount
+ *
+ * @param client - The AlpacaClient instance
+ * @param symbol - Crypto pair symbol (e.g., 'BTC/USD')
+ * @param dollarAmount - Amount in USD to spend
+ * @returns The created order
+ *
+ * @example
+ * // Buy $500 worth of Bitcoin
+ * const order = await buyCryptoNotional(client, 'BTC/USD', 500);
+ */
+export declare function buyCryptoNotional(client: AlpacaClient, symbol: string, dollarAmount: number): Promise<AlpacaOrder>;
+/**
+ * Sell crypto for a dollar amount (notional order)
+ * Allows selling crypto for a specific USD amount
+ *
+ * @param client - The AlpacaClient instance
+ * @param symbol - Crypto pair symbol (e.g., 'BTC/USD')
+ * @param dollarAmount - Amount in USD to receive
+ * @returns The created order
+ *
+ * @example
+ * // Sell $200 worth of Ethereum
+ * const order = await sellCryptoNotional(client, 'ETH/USD', 200);
+ */
+export declare function sellCryptoNotional(client: AlpacaClient, symbol: string, dollarAmount: number): Promise<AlpacaOrder>;
+/**
+ * Sell all of a crypto position
+ * Closes the entire position for the specified crypto pair
+ *
+ * @param client - The AlpacaClient instance
+ * @param symbol - Crypto pair symbol (e.g., 'BTC/USD')
+ * @returns The close order
+ * @throws CryptoOrderError if no position exists or close fails
+ *
+ * @example
+ * const order = await sellAllCrypto(client, 'BTC/USD');
+ */
+export declare function sellAllCrypto(client: AlpacaClient, symbol: string): Promise<AlpacaOrder>;
+/**
+ * Get all open crypto orders
+ *
+ * @param client - The AlpacaClient instance
+ * @param symbols - Optional array of crypto symbols to filter by
+ * @returns Array of open crypto orders
+ *
+ * @example
+ * const orders = await getOpenCryptoOrders(client);
+ * const btcOrders = await getOpenCryptoOrders(client, ['BTC/USD']);
+ */
+export declare function getOpenCryptoOrders(client: AlpacaClient, symbols?: string[]): Promise<AlpacaOrder[]>;
+/**
+ * Cancel all open crypto orders
+ *
+ * @param client - The AlpacaClient instance
+ * @param symbol - Optional specific crypto symbol to cancel orders for
+ * @returns Number of orders canceled
+ *
+ * @example
+ * // Cancel all crypto orders
+ * const canceled = await cancelAllCryptoOrders(client);
+ *
+ * // Cancel only BTC orders
+ * const canceled = await cancelAllCryptoOrders(client, 'BTC/USD');
+ */
+export declare function cancelAllCryptoOrders(client: AlpacaClient, symbol?: string): Promise<number>;
+/**
+ * Check if a symbol is a valid crypto pair
+ *
+ * @param symbol - Symbol to check
+ * @returns true if the symbol appears to be a crypto pair
+ */
+export declare function isCryptoPair(symbol: string): boolean;
+declare const _default: {
+    createCryptoOrder: typeof createCryptoOrder;
+    createCryptoMarketOrder: typeof createCryptoMarketOrder;
+    createCryptoLimitOrder: typeof createCryptoLimitOrder;
+    createCryptoStopOrder: typeof createCryptoStopOrder;
+    createCryptoStopLimitOrder: typeof createCryptoStopLimitOrder;
+    buyCryptoNotional: typeof buyCryptoNotional;
+    sellCryptoNotional: typeof sellCryptoNotional;
+    sellAllCrypto: typeof sellAllCrypto;
+    getOpenCryptoOrders: typeof getOpenCryptoOrders;
+    cancelAllCryptoOrders: typeof cancelAllCryptoOrders;
+    isCryptoPair: typeof isCryptoPair;
+};
+export default _default;
+//# sourceMappingURL=orders.d.ts.map

package/dist/types/alpaca/crypto/orders.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"orders.d.ts","sourceRoot":"","sources":["../../../../src/alpaca/crypto/orders.ts"],"names":[],"mappings":"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"}

package/dist/types/alpaca/index.d.ts

@@ -0,0 +1,201 @@
+/**
+ * Alpaca Module
+ * Unified export of all Alpaca functionality using official SDK
+ *
+ * @module @adaptic/utils/alpaca
+ */
+export * from './client';
+export * from './trading';
+export { getLatestQuote, getLatestQuotes, getSpread, getSpreads, hasGoodLiquidity as hasStockLiquidity, QuoteError, type SpreadInfo, } from './market-data/quotes';
+export { getBars, getLatestBars, getDailyPrices, getIntradayPrices, getPreviousClose, analyzeBars, getPriceRange, getAverageDailyVolume, hasSufficientVolume, BarError, type GetBarsParams, type BarAnalysis, } from './market-data/bars';
+export { getLatestTrade, getLatestTrades, getHistoricalTrades, getCurrentPrice, getCurrentPrices, getTradeVolume, TradeError, type GetHistoricalTradesParams, } from './market-data/trades';
+export { getNews, getLatestNews, searchNews, getNewsForSymbols, getSymbolSentiment, NewsError, type GetNewsParams, } from './market-data/news';
+export { getOptionContracts, getOptionContract, getOptionChain, getExpirationDates, getStrikePrices, findATMOptions, getGroupedOptionChain, findOptionsByDelta, findNearestExpiration, parseOCCSymbol, buildOCCSymbol, isContractTradable, getDaysToExpiration, isExpiringWithin, type GetOptionChainParams, type ATMOptionsResult, type GroupedOptionChain, } from './options/contracts';
+export { createOptionOrder, buyToOpen, sellToClose, sellToOpen, buyToClose, validateMultiLegOrder, createMultiLegOptionOrder, createVerticalSpread, createIronCondor, createStraddle, createStrangle, closeOptionPosition, closeAllOptionPositions, exerciseOption, isOptionOrderTerminal, isOptionOrderCancelable, type SingleLegOptionOrderParams, type CloseOptionPositionParams, type CloseAllOptionsResult, type ExerciseOptionParams, type MultiLegValidationResult, } from './options/orders';
+export { buildOptionSymbol, createVerticalSpread as createVerticalSpreadAdvanced, createIronCondor as createIronCondorAdvanced, createStraddle as createStraddleAdvanced, createCoveredCall, rollOptionPosition, createStrangle as createStrangleAdvanced, createButterflySpread, OptionStrategyError, type VerticalSpreadParams, type IronCondorParams, type StraddleParams, type CoveredCallParams, type RollPositionParams, type StrangleParams, type ButterflySpreadParams, } from './options/strategies';
+export { getOptionsChain, getLatestOptionsQuotes, getLatestOptionsTrades, getOptionsSnapshots, getHistoricalOptionsBars, approximateImpliedVolatility, calculateMoneyness, findATMStrikes, calculatePutCallRatio, extractGreeks, filterByExpiration, filterByStrike, filterByType, getOptionSpread, hasGoodLiquidity as hasOptionLiquidity, OptionsDataError, type OptionsFeed, type GetHistoricalOptionsBarsParams, } from './options/data';
+export { CryptoOrderError, CryptoOrderParams, createCryptoOrder, createCryptoMarketOrder, createCryptoLimitOrder, createCryptoStopOrder, createCryptoStopLimitOrder, buyCryptoNotional, sellCryptoNotional, sellAllCrypto, getOpenCryptoOrders, cancelAllCryptoOrders, isCryptoPair, } from './crypto/orders';
+export { CryptoDataError, CryptoTrade, CryptoQuote, GetCryptoBarsParams, CryptoSnapshot, getCryptoBars, getLatestCryptoTrades, getLatestCryptoQuotes, getCryptoPrice, getCryptoSpread, getCryptoSnapshots, getCryptoTrades, getCryptoDailyPrices, getCrypto24HourChange, getSupportedCryptoPairs, getCryptoPairsByQuote, isSupportedCryptoPair, getPopularCryptoPairs, BTC_PAIRS, USDT_PAIRS, USDC_PAIRS, USD_PAIRS, } from './crypto/data';
+export * from './streams';
+import { createAlpacaClient, AlpacaClient, AlpacaClientConfig, createClientFromEnv, clearClientCache } from './client';
+import * as trading from './trading/orders';
+import * as orderUtils from './trading/order-utils';
+import * as bracketOrders from './trading/bracket-orders';
+import * as ocoOrders from './trading/oco-orders';
+import * as otoOrders from './trading/oto-orders';
+import * as trailingStops from './trading/trailing-stops';
+import * as smartOrders from './trading/smart-orders';
+import * as positions from './trading/positions';
+import * as account from './trading/account';
+import * as quotes from './market-data/quotes';
+import * as bars from './market-data/bars';
+import * as trades from './market-data/trades';
+import * as news from './market-data/news';
+import * as optionContracts from './options/contracts';
+import * as optionOrders from './options/orders';
+import * as optionStrategies from './options/strategies';
+import * as optionData from './options/data';
+import * as cryptoOrders from './crypto/orders';
+import * as cryptoData from './crypto/data';
+import * as streams from './streams';
+/**
+ * Alpaca namespace for convenient access to all functionality
+ *
+ * @example
+ * ```typescript
+ * import { alpaca } from '@adaptic/utils';
+ *
+ * // Create client
+ * const client = alpaca.createClient({
+ *   apiKey: 'your-api-key',
+ *   apiSecret: 'your-api-secret',
+ *   accountType: 'PAPER',
+ * });
+ *
+ * // Use trading functions
+ * const order = await alpaca.orders.createOrder(client, { ... });
+ *
+ * // Use market data functions
+ * const quote = await alpaca.quotes.getLatestQuote(client, 'AAPL');
+ *
+ * // Use smart orders
+ * const bracket = await alpaca.smartOrders.createSmartOrder(client, { ... });
+ * ```
+ */
+export declare const alpaca: {
+    createClient: typeof createAlpacaClient;
+    createClientFromEnv: typeof createClientFromEnv;
+    clearClientCache: typeof clearClientCache;
+    orders: {
+        getOrdersBySymbol(client: AlpacaClient, symbol: string, params?: Omit<import("..").GetOrdersParams, "symbols">): Promise<import("..").AlpacaOrder[]>;
+        getOpenOrders(client: AlpacaClient, params?: Omit<import("..").GetOrdersParams, "status">): Promise<import("..").AlpacaOrder[]>;
+        getFilledOrders(client: AlpacaClient, params: orderUtils.GetFilledOrdersParams): Promise<import("..").AlpacaOrder[]>;
+        getOrderHistory(client: AlpacaClient, params?: orderUtils.GetOrderHistoryParams): Promise<orderUtils.OrderHistoryResult>;
+        getAllOrders(client: AlpacaClient, params?: orderUtils.GetAllOrdersParams): Promise<import("..").AlpacaOrder[]>;
+        waitForOrderFill(client: AlpacaClient, params: orderUtils.WaitForOrderFillParams): Promise<orderUtils.WaitForOrderFillResult>;
+        isOrderFillable(order: import("..").AlpacaOrder): boolean;
+        isOrderFilled(order: import("..").AlpacaOrder): boolean;
+        isOrderTerminal(order: import("..").AlpacaOrder): boolean;
+        isOrderOpen(order: import("..").AlpacaOrder): boolean;
+        calculateOrderValue(order: import("..").AlpacaOrder): number | null;
+        formatOrderSummary(order: import("..").AlpacaOrder): orderUtils.OrderSummary;
+        formatOrderForLog(order: import("..").AlpacaOrder): string;
+        roundPriceForAlpaca(price: number): string;
+        roundPriceForAlpacaNumber(price: number): number;
+        groupOrdersBySymbol(orders: import("..").AlpacaOrder[]): Map<string, import("..").AlpacaOrder[]>;
+        groupOrdersByStatus(orders: import("..").AlpacaOrder[]): Map<string, import("..").AlpacaOrder[]>;
+        calculateTotalFilledValue(orders: import("..").AlpacaOrder[]): number;
+        filterOrdersByDateRange(orders: import("..").AlpacaOrder[], startDate: Date, endDate: Date): import("..").AlpacaOrder[];
+        sortOrdersByDate(orders: import("..").AlpacaOrder[], direction?: "asc" | "desc"): import("..").AlpacaOrder[];
+        default: {
+            getOrdersBySymbol: typeof orderUtils.getOrdersBySymbol;
+            getOpenOrders: typeof orderUtils.getOpenOrders;
+            getFilledOrders: typeof orderUtils.getFilledOrders;
+            getOrderHistory: typeof orderUtils.getOrderHistory;
+            getAllOrders: typeof orderUtils.getAllOrders;
+            waitForOrderFill: typeof orderUtils.waitForOrderFill;
+            isOrderFillable: typeof orderUtils.isOrderFillable;
+            isOrderFilled: typeof orderUtils.isOrderFilled;
+            isOrderTerminal: typeof orderUtils.isOrderTerminal;
+            isOrderOpen: typeof orderUtils.isOrderOpen;
+            calculateOrderValue: typeof orderUtils.calculateOrderValue;
+            calculateTotalFilledValue: typeof orderUtils.calculateTotalFilledValue;
+            formatOrderSummary: typeof orderUtils.formatOrderSummary;
+            formatOrderForLog: typeof orderUtils.formatOrderForLog;
+            roundPriceForAlpaca: typeof orderUtils.roundPriceForAlpaca;
+            roundPriceForAlpacaNumber: typeof orderUtils.roundPriceForAlpacaNumber;
+            groupOrdersBySymbol: typeof orderUtils.groupOrdersBySymbol;
+            groupOrdersByStatus: typeof orderUtils.groupOrdersByStatus;
+            filterOrdersByDateRange: typeof orderUtils.filterOrdersByDateRange;
+            sortOrdersByDate: typeof orderUtils.sortOrdersByDate;
+        };
+        createOrder(client: AlpacaClient, params: import("..").CreateOrderParams): Promise<import("..").AlpacaOrder>;
+        getOrder(client: AlpacaClient, orderId: string): Promise<import("..").AlpacaOrder>;
+        getOrders(client: AlpacaClient, params?: import("..").GetOrdersParams): Promise<import("..").AlpacaOrder[]>;
+        cancelOrder(client: AlpacaClient, orderId: string): Promise<void>;
+        cancelAllOrders(client: AlpacaClient): Promise<trading.CancelAllOrdersResponse>;
+        replaceOrder(client: AlpacaClient, orderId: string, params: import("..").ReplaceOrderParams): Promise<import("..").AlpacaOrder>;
+        isOrderCancelable(status: import("..").OrderStatus): boolean;
+        getOrderByClientId(client: AlpacaClient, clientOrderId: string): Promise<import("..").AlpacaOrder>;
+    };
+    smartOrders: {
+        bracket: typeof bracketOrders;
+        oco: typeof ocoOrders;
+        oto: typeof otoOrders;
+        trailingStops: typeof trailingStops;
+        determineOrderType(params: smartOrders.SmartOrderParams): smartOrders.SmartOrderType;
+        createSmartOrder(client: AlpacaClient, params: smartOrders.SmartOrderParams): Promise<smartOrders.SmartOrderResult>;
+        createPercentageBracket(client: AlpacaClient, params: smartOrders.PercentageBracketParams): Promise<bracketOrders.BracketOrderResult>;
+        createRiskManagedPosition(client: AlpacaClient, params: smartOrders.RiskManagedPositionParams): Promise<bracketOrders.BracketOrderResult | otoOrders.OTOOrderResult>;
+        calculateRewardRiskRatio(entryPrice: number, takeProfitPrice: number, stopLossPrice: number, side: import("..").OrderSide): number;
+        calculatePositionSize(accountValue: number, riskPercent: number, entryPrice: number, stopPrice: number): number;
+        default: {
+            createSmartOrder: typeof smartOrders.createSmartOrder;
+            determineOrderType: typeof smartOrders.determineOrderType;
+            createPercentageBracket: typeof smartOrders.createPercentageBracket;
+            createRiskManagedPosition: typeof smartOrders.createRiskManagedPosition;
+            calculateRewardRiskRatio: typeof smartOrders.calculateRewardRiskRatio;
+            calculatePositionSize: typeof smartOrders.calculatePositionSize;
+            createBracketOrder: typeof bracketOrders.createBracketOrder;
+            createProtectiveBracket: typeof bracketOrders.createProtectiveBracket;
+            createExecutorFromTradingAPI: typeof bracketOrders.createExecutorFromTradingAPI;
+            createOCOOrder: typeof ocoOrders.createOCOOrder;
+            createOTOOrder: typeof otoOrders.createOTOOrder;
+            createTrailingStop: typeof trailingStops.createTrailingStop;
+            updateTrailingStop: typeof trailingStops.updateTrailingStop;
+        };
+        createBracketOrder(executor: bracketOrders.BracketOrderExecutor, params: bracketOrders.BracketOrderParams): Promise<bracketOrders.BracketOrderResult>;
+        createProtectiveBracket(executor: bracketOrders.BracketOrderExecutor, params: bracketOrders.ProtectiveBracketParams): Promise<bracketOrders.BracketOrderResult>;
+        createExecutorFromTradingAPI(api: {
+            makeRequest: (endpoint: string, method: string, body?: unknown) => Promise<import("..").AlpacaOrder>;
+        }): bracketOrders.BracketOrderExecutor;
+        createOCOOrder(client: AlpacaClient, params: ocoOrders.OCOOrderParams): Promise<ocoOrders.OCOOrderResult>;
+        cancelOCOOrder(client: AlpacaClient, parentOrderId: string): Promise<void>;
+        getOCOOrderStatus(client: AlpacaClient, parentOrderId: string): Promise<import("..").AlpacaOrder>;
+        protectLongPosition(client: AlpacaClient, symbol: string, qty: number, takeProfitPrice: number, stopLossPrice: number, stopLimitPrice?: number): Promise<ocoOrders.OCOOrderResult>;
+        protectShortPosition(client: AlpacaClient, symbol: string, qty: number, takeProfitPrice: number, stopLossPrice: number, stopLimitPrice?: number): Promise<ocoOrders.OCOOrderResult>;
+        createOTOOrder(client: AlpacaClient, params: otoOrders.OTOOrderParams): Promise<otoOrders.OTOOrderResult>;
+        cancelOTOOrder(client: AlpacaClient, parentOrderId: string): Promise<void>;
+        getOTOOrderStatus(client: AlpacaClient, parentOrderId: string): Promise<import("..").AlpacaOrder>;
+        buyWithStopLoss(client: AlpacaClient, symbol: string, qty: number, stopLossPrice: number, stopLimitPrice?: number): Promise<otoOrders.OTOOrderResult>;
+        buyWithTrailingStop(client: AlpacaClient, symbol: string, qty: number, trailPercent: number): Promise<otoOrders.OTOOrderResult>;
+        limitBuyWithTakeProfit(client: AlpacaClient, symbol: string, qty: number, entryPrice: number, takeProfitPrice: number): Promise<otoOrders.OTOOrderResult>;
+        shortWithStopLoss(client: AlpacaClient, symbol: string, qty: number, entryPrice: number, stopLossPrice: number): Promise<otoOrders.OTOOrderResult>;
+        entryWithPercentStopLoss(client: AlpacaClient, symbol: string, qty: number, entryPrice: number | null, stopLossPercent: number, side?: import("..").OrderSide): Promise<otoOrders.OTOOrderResult>;
+        createTrailingStop(client: AlpacaClient, params: trailingStops.TrailingStopParams): Promise<import("..").AlpacaOrder>;
+        updateTrailingStop(client: AlpacaClient, orderId: string, updates: {
+            trailPercent?: number;
+            trailPrice?: number;
+        }): Promise<import("..").AlpacaOrder>;
+        getTrailingStopHWM(client: AlpacaClient, orderId: string): Promise<trailingStops.TrailingStopHWMResult>;
+        cancelTrailingStop(client: AlpacaClient, orderId: string): Promise<void>;
+        createPortfolioTrailingStops(client: AlpacaClient, params: trailingStops.PortfolioTrailingStopParams): Promise<Map<string, import("..").AlpacaOrder>>;
+        getOpenTrailingStops(client: AlpacaClient, symbol?: string): Promise<import("..").AlpacaOrder[]>;
+        hasActiveTrailingStop(client: AlpacaClient, symbol: string): Promise<boolean>;
+        cancelTrailingStopsForSymbol(client: AlpacaClient, symbol: string): Promise<number>;
+        TrailingStopValidationError: typeof trailingStops.TrailingStopValidationError;
+    };
+    positions: typeof positions;
+    account: typeof account;
+    quotes: typeof quotes;
+    bars: typeof bars;
+    trades: typeof trades;
+    news: typeof news;
+    options: {
+        contracts: typeof optionContracts;
+        orders: typeof optionOrders;
+        strategies: typeof optionStrategies;
+        data: typeof optionData;
+    };
+    crypto: {
+        orders: typeof cryptoOrders;
+        data: typeof cryptoData;
+    };
+    streams: typeof streams;
+};
+/**
+ * Re-export type definitions for external use
+ */
+export type { AlpacaClient, AlpacaClientConfig };
+export default alpaca;
+//# sourceMappingURL=index.d.ts.map

package/dist/types/alpaca/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/alpaca/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,cAAc,UAAU,CAAC;AAGzB,cAAc,WAAW,CAAC;AAG1B,OAAO,EAEL,cAAc,EACd,eAAe,EACf,SAAS,EACT,UAAU,EACV,gBAAgB,IAAI,iBAAiB,EACrC,UAAU,EAEV,KAAK,UAAU,GAChB,MAAM,sBAAsB,CAAC;AAE9B,OAAO,EAEL,OAAO,EACP,aAAa,EACb,cAAc,EACd,iBAAiB,EACjB,gBAAgB,EAChB,WAAW,EACX,aAAa,EACb,qBAAqB,EACrB,mBAAmB,EACnB,QAAQ,EAER,KAAK,aAAa,EAClB,KAAK,WAAW,GACjB,MAAM,oBAAoB,CAAC;AAE5B,OAAO,EAEL,cAAc,EACd,eAAe,EACf,mBAAmB,EACnB,eAAe,EACf,gBAAgB,EAChB,cAAc,EACd,UAAU,EAEV,KAAK,yBAAyB,GAC/B,MAAM,sBAAsB,CAAC;AAE9B,OAAO,EAEL,OAAO,EACP,aAAa,EACb,UAAU,EACV,iBAAiB,EACjB,kBAAkB,EAClB,SAAS,EAET,KAAK,aAAa,GACnB,MAAM,oBAAoB,CAAC;AAG5B,OAAO,EAEL,kBAAkB,EAClB,iBAAiB,EACjB,cAAc,EACd,kBAAkB,EAClB,eAAe,EACf,cAAc,EACd,qBAAqB,EACrB,kBAAkB,EAClB,qBAAqB,EACrB,cAAc,EACd,cAAc,EACd,kBAAkB,EAClB,mBAAmB,EACnB,gBAAgB,EAEhB,KAAK,oBAAoB,EACzB,KAAK,gBAAgB,EACrB,KAAK,kBAAkB,GACxB,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EAEL,iBAAiB,EACjB,SAAS,EACT,WAAW,EACX,UAAU,EACV,UAAU,EACV,qBAAqB,EACrB,yBAAyB,EACzB,oBAAoB,EACpB,gBAAgB,EAChB,cAAc,EACd,cAAc,EACd,mBAAmB,EACnB,uBAAuB,EACvB,cAAc,EACd,qBAAqB,EACrB,uBAAuB,EAEvB,KAAK,0BAA0B,EAC/B,KAAK,yBAAyB,EAC9B,KAAK,qBAAqB,EAC1B,KAAK,oBAAoB,EACzB,KAAK,wBAAwB,GAC9B,MAAM,kBAAkB,CAAC;AAE1B,OAAO,EAEL,iBAAiB,EACjB,oBAAoB,IAAI,4BAA4B,EACpD,gBAAgB,IAAI,wBAAwB,EAC5C,cAAc,IAAI,sBAAsB,EACxC,iBAAiB,EACjB,kBAAkB,EAClB,cAAc,IAAI,sBAAsB,EACxC,qBAAqB,EACrB,mBAAmB,EAEnB,KAAK,oBAAoB,EACzB,KAAK,gBAAgB,EACrB,KAAK,cAAc,EACnB,KAAK,iBAAiB,EACtB,KAAK,kBAAkB,EACvB,KAAK,cAAc,EACnB,KAAK,qBAAqB,GAC3B,MAAM,sBAAsB,CAAC;AAE9B,OAAO,EAEL,eAAe,EACf,sBAAsB,EACtB,sBAAsB,EACtB,mBAAmB,EACnB,wBAAwB,EACxB,4BAA4B,EAC5B,kBAAkB,EAClB,cAAc,EACd,qBAAqB,EACrB,aAAa,EACb,kBAAkB,EAClB,cAAc,EACd,YAAY,EACZ,eAAe,EACf,gBAAgB,IAAI,kBAAkB,EACtC,gBAAgB,EAEhB,KAAK,WAAW,EAChB,KAAK,8BAA8B,GACpC,MAAM,gBAAgB,CAAC;AAGxB,OAAO,EAEL,gBAAgB,EAChB,iBAAiB,EACjB,iBAAiB,EACjB,uBAAuB,EACvB,sBAAsB,EACtB,qBAAqB,EACrB,0BAA0B,EAC1B,iBAAiB,EACjB,kBAAkB,EAClB,aAAa,EACb,mBAAmB,EACnB,qBAAqB,EACrB,YAAY,GACb,MAAM,iBAAiB,CAAC;AAEzB,OAAO,EAEL,eAAe,EACf,WAAW,EACX,WAAW,EACX,mBAAmB,EACnB,cAAc,EACd,aAAa,EACb,qBAAqB,EACrB,qBAAqB,EACrB,cAAc,EACd,eAAe,EACf,kBAAkB,EAClB,eAAe,EACf,oBAAoB,EACpB,qBAAqB,EACrB,uBAAuB,EACvB,qBAAqB,EACrB,qBAAqB,EACrB,qBAAqB,EACrB,SAAS,EACT,UAAU,EACV,UAAU,EACV,SAAS,GACV,MAAM,eAAe,CAAC;AAGvB,cAAc,WAAW,CAAC;AAG1B,OAAO,EAAE,kBAAkB,EAAE,YAAY,EAAE,kBAAkB,EAAE,mBAAmB,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAGvH,OAAO,KAAK,OAAO,MAAM,kBAAkB,CAAC;AAC5C,OAAO,KAAK,UAAU,MAAM,uBAAuB,CAAC;AACpD,OAAO,KAAK,aAAa,MAAM,0BAA0B,CAAC;AAC1D,OAAO,KAAK,SAAS,MAAM,sBAAsB,CAAC;AAClD,OAAO,KAAK,SAAS,MAAM,sBAAsB,CAAC;AAClD,OAAO,KAAK,aAAa,MAAM,0BAA0B,CAAC;AAC1D,OAAO,KAAK,WAAW,MAAM,wBAAwB,CAAC;AACtD,OAAO,KAAK,SAAS,MAAM,qBAAqB,CAAC;AACjD,OAAO,KAAK,OAAO,MAAM,mBAAmB,CAAC;AAG7C,OAAO,KAAK,MAAM,MAAM,sBAAsB,CAAC;AAC/C,OAAO,KAAK,IAAI,MAAM,oBAAoB,CAAC;AAC3C,OAAO,KAAK,MAAM,MAAM,sBAAsB,CAAC;AAC/C,OAAO,KAAK,IAAI,MAAM,oBAAoB,CAAC;AAG3C,OAAO,KAAK,eAAe,MAAM,qBAAqB,CAAC;AACvD,OAAO,KAAK,YAAY,MAAM,kBAAkB,CAAC;AACjD,OAAO,KAAK,gBAAgB,MAAM,sBAAsB,CAAC;AACzD,OAAO,KAAK,UAAU,MAAM,gBAAgB,CAAC;AAG7C,OAAO,KAAK,YAAY,MAAM,iBAAiB,CAAC;AAChD,OAAO,KAAK,UAAU,MAAM,eAAe,CAAC;AAG5C,OAAO,KAAK,OAAO,MAAM,WAAW,CAAC;AAErC;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gEAyDk9L,CAAC;;;;;;;;;;;;;;;;;wBAA5nL,CAAC;sBAAwB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;CARnY,CAAC;AAEF;;GAEG;AACH,YAAY,EAAE,YAAY,EAAE,kBAAkB,EAAE,CAAC;AAEjD,eAAe,MAAM,CAAC"}

package/dist/types/alpaca/market-data/bars.d.ts

@@ -0,0 +1,142 @@
+/**
+ * Bars Module
+ * Historical and real-time OHLCV data using Alpaca SDK
+ */
+import { AlpacaClient } from '../client';
+import { Bar, TimeFrame } from '../../types/alpaca-types';
+/**
+ * Error thrown when bar operations fail
+ */
+export declare class BarError extends Error {
+    code: string;
+    symbol?: string | undefined;
+    details?: unknown | undefined;
+    constructor(message: string, code: string, symbol?: string | undefined, details?: unknown | undefined);
+}
+/**
+ * Parameters for fetching bars
+ */
+export interface GetBarsParams {
+    /** Symbols to fetch bars for */
+    symbols: string[];
+    /** Bar timeframe (e.g., '1Min', '5Min', '1Hour', '1Day') */
+    timeframe: TimeFrame;
+    /** Start date/time for the data range */
+    start?: Date | string;
+    /** End date/time for the data range */
+    end?: Date | string;
+    /** Maximum number of bars to return per symbol */
+    limit?: number;
+    /** Price adjustment type */
+    adjustment?: 'raw' | 'split' | 'dividend' | 'all';
+    /** Data feed (sip for premium, iex for free tier) */
+    feed?: 'sip' | 'iex';
+}
+/**
+ * Bar analysis summary
+ */
+export interface BarAnalysis {
+    /** Opening price of the period */
+    open: number;
+    /** Highest price during the period */
+    high: number;
+    /** Lowest price during the period */
+    low: number;
+    /** Closing price of the period */
+    close: number;
+    /** Total volume traded */
+    volume: number;
+    /** Volume-weighted average price */
+    vwap: number;
+    /** Price change (close - open) */
+    change: number;
+    /** Price change as percentage */
+    changePercent: number;
+    /** Number of bars analyzed */
+    barCount: number;
+    /** Total number of trades */
+    totalTrades: number;
+}
+/**
+ * Get historical bars with automatic pagination
+ * @param client - AlpacaClient instance
+ * @param params - Parameters for fetching bars
+ * @returns Map of symbol to array of bars
+ */
+export declare function getBars(client: AlpacaClient, params: GetBarsParams): Promise<Map<string, Bar[]>>;
+/**
+ * Get latest bars for symbols
+ * @param client - AlpacaClient instance
+ * @param symbols - Array of stock symbols
+ * @returns Map of symbol to latest bar
+ */
+export declare function getLatestBars(client: AlpacaClient, symbols: string[]): Promise<Map<string, Bar>>;
+/**
+ * Get daily prices for a symbol
+ * @param client - AlpacaClient instance
+ * @param symbol - Stock symbol
+ * @param days - Number of days of history to fetch
+ * @returns Array of daily bars
+ */
+export declare function getDailyPrices(client: AlpacaClient, symbol: string, days: number): Promise<Bar[]>;
+/**
+ * Get intraday prices for a symbol
+ * @param client - AlpacaClient instance
+ * @param symbol - Stock symbol
+ * @param timeframe - Bar timeframe
+ * @param start - Start date/time
+ * @param end - Optional end date/time (defaults to now)
+ * @returns Array of intraday bars
+ */
+export declare function getIntradayPrices(client: AlpacaClient, symbol: string, timeframe: TimeFrame, start: Date, end?: Date): Promise<Bar[]>;
+/**
+ * Get previous close price for a symbol
+ * @param client - AlpacaClient instance
+ * @param symbol - Stock symbol
+ * @returns Previous close price
+ */
+export declare function getPreviousClose(client: AlpacaClient, symbol: string): Promise<number>;
+/**
+ * Analyze bars and return summary statistics
+ * @param bars - Array of bars to analyze
+ * @returns Analysis summary with OHLCV stats and price change
+ */
+export declare function analyzeBars(bars: Bar[]): BarAnalysis;
+/**
+ * Get price range statistics for a symbol over a period
+ * @param client - AlpacaClient instance
+ * @param symbol - Stock symbol
+ * @param days - Number of days to analyze
+ * @returns Analysis of the price range
+ */
+export declare function getPriceRange(client: AlpacaClient, symbol: string, days: number): Promise<BarAnalysis>;
+/**
+ * Calculate average daily volume for a symbol
+ * @param client - AlpacaClient instance
+ * @param symbol - Stock symbol
+ * @param days - Number of days to average (default 20)
+ * @returns Average daily volume
+ */
+export declare function getAverageDailyVolume(client: AlpacaClient, symbol: string, days?: number): Promise<number>;
+/**
+ * Check if a symbol has sufficient trading volume
+ * @param client - AlpacaClient instance
+ * @param symbol - Stock symbol
+ * @param minAvgVolume - Minimum average daily volume required (default 100,000)
+ * @param days - Number of days to check (default 20)
+ * @returns true if average volume meets minimum requirement
+ */
+export declare function hasSufficientVolume(client: AlpacaClient, symbol: string, minAvgVolume?: number, days?: number): Promise<boolean>;
+declare const _default: {
+    getBars: typeof getBars;
+    getLatestBars: typeof getLatestBars;
+    getDailyPrices: typeof getDailyPrices;
+    getIntradayPrices: typeof getIntradayPrices;
+    getPreviousClose: typeof getPreviousClose;
+    analyzeBars: typeof analyzeBars;
+    getPriceRange: typeof getPriceRange;
+    getAverageDailyVolume: typeof getAverageDailyVolume;
+    hasSufficientVolume: typeof hasSufficientVolume;
+};
+export default _default;
+//# sourceMappingURL=bars.d.ts.map

package/dist/types/alpaca/market-data/bars.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bars.d.ts","sourceRoot":"","sources":["../../../../src/alpaca/market-data/bars.ts"],"names":[],"mappings":"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"}

package/dist/types/alpaca/market-data/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Market Data Module
+ * Exports quotes, bars, trades, and news functionality for market data access
+ */
+export { getLatestQuote, getLatestQuotes, getSpread, getSpreads, hasGoodLiquidity, QuoteError, } from './quotes';
+export type { SpreadInfo } from './quotes';
+export { getBars, getLatestBars, getDailyPrices, getIntradayPrices, getPreviousClose, analyzeBars, getPriceRange, getAverageDailyVolume, hasSufficientVolume, BarError, } from './bars';
+export type { GetBarsParams, BarAnalysis } from './bars';
+export { getLatestTrade, getLatestTrades, getHistoricalTrades, getCurrentPrice, getCurrentPrices, getTradeVolume, TradeError, } from './trades';
+export type { GetHistoricalTradesParams } from './trades';
+export { getNews, getLatestNews, searchNews, getNewsForSymbols, getSymbolSentiment, NewsError, } from './news';
+export type { GetNewsParams } from './news';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/alpaca/market-data/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/alpaca/market-data/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,EACL,cAAc,EACd,eAAe,EACf,SAAS,EACT,UAAU,EACV,gBAAgB,EAChB,UAAU,GACX,MAAM,UAAU,CAAC;AAElB,YAAY,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAG3C,OAAO,EACL,OAAO,EACP,aAAa,EACb,cAAc,EACd,iBAAiB,EACjB,gBAAgB,EAChB,WAAW,EACX,aAAa,EACb,qBAAqB,EACrB,mBAAmB,EACnB,QAAQ,GACT,MAAM,QAAQ,CAAC;AAEhB,YAAY,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,QAAQ,CAAC;AAGzD,OAAO,EACL,cAAc,EACd,eAAe,EACf,mBAAmB,EACnB,eAAe,EACf,gBAAgB,EAChB,cAAc,EACd,UAAU,GACX,MAAM,UAAU,CAAC;AAElB,YAAY,EAAE,yBAAyB,EAAE,MAAM,UAAU,CAAC;AAG1D,OAAO,EACL,OAAO,EACP,aAAa,EACb,UAAU,EACV,iBAAiB,EACjB,kBAAkB,EAClB,SAAS,GACV,MAAM,QAAQ,CAAC;AAEhB,YAAY,EAAE,aAAa,EAAE,MAAM,QAAQ,CAAC"}