@adaptic/utils 0.0.383 → 0.0.900

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

@@ -0,0 +1,75 @@
+/**
+ * Crypto Module Index
+ * Exports all crypto trading and market data functions
+ * Crypto trading is available 24/7 on Alpaca
+ */
+export { CryptoOrderError, CryptoOrderParams, createCryptoOrder, createCryptoMarketOrder, createCryptoLimitOrder, createCryptoStopOrder, createCryptoStopLimitOrder, buyCryptoNotional, sellCryptoNotional, sellAllCrypto, getOpenCryptoOrders, cancelAllCryptoOrders, isCryptoPair, } from "./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 "./data";
+export declare const orders: {
+    createCryptoOrder: typeof import("./orders").createCryptoOrder;
+    createCryptoMarketOrder: typeof import("./orders").createCryptoMarketOrder;
+    createCryptoLimitOrder: typeof import("./orders").createCryptoLimitOrder;
+    createCryptoStopOrder: typeof import("./orders").createCryptoStopOrder;
+    createCryptoStopLimitOrder: typeof import("./orders").createCryptoStopLimitOrder;
+    buyCryptoNotional: typeof import("./orders").buyCryptoNotional;
+    sellCryptoNotional: typeof import("./orders").sellCryptoNotional;
+    sellAllCrypto: typeof import("./orders").sellAllCrypto;
+    getOpenCryptoOrders: typeof import("./orders").getOpenCryptoOrders;
+    cancelAllCryptoOrders: typeof import("./orders").cancelAllCryptoOrders;
+    isCryptoPair: typeof import("./orders").isCryptoPair;
+};
+export declare const data: {
+    getCryptoBars: typeof import("./data").getCryptoBars;
+    getLatestCryptoTrades: typeof import("./data").getLatestCryptoTrades;
+    getLatestCryptoQuotes: typeof import("./data").getLatestCryptoQuotes;
+    getCryptoPrice: typeof import("./data").getCryptoPrice;
+    getCryptoSpread: typeof import("./data").getCryptoSpread;
+    getCryptoSnapshots: typeof import("./data").getCryptoSnapshots;
+    getCryptoTrades: typeof import("./data").getCryptoTrades;
+    getCryptoDailyPrices: typeof import("./data").getCryptoDailyPrices;
+    getCrypto24HourChange: typeof import("./data").getCrypto24HourChange;
+    getSupportedCryptoPairs: typeof import("./data").getSupportedCryptoPairs;
+    getCryptoPairsByQuote: typeof import("./data").getCryptoPairsByQuote;
+    isSupportedCryptoPair: typeof import("./data").isSupportedCryptoPair;
+    getPopularCryptoPairs: typeof import("./data").getPopularCryptoPairs;
+    BTC_PAIRS: import("../..").BTCPairs[];
+    USDT_PAIRS: import("../..").USDTPairs[];
+    USDC_PAIRS: import("../..").USDCPairs[];
+    USD_PAIRS: import("../..").USDPairs[];
+};
+declare const _default: {
+    orders: {
+        createCryptoOrder: typeof import("./orders").createCryptoOrder;
+        createCryptoMarketOrder: typeof import("./orders").createCryptoMarketOrder;
+        createCryptoLimitOrder: typeof import("./orders").createCryptoLimitOrder;
+        createCryptoStopOrder: typeof import("./orders").createCryptoStopOrder;
+        createCryptoStopLimitOrder: typeof import("./orders").createCryptoStopLimitOrder;
+        buyCryptoNotional: typeof import("./orders").buyCryptoNotional;
+        sellCryptoNotional: typeof import("./orders").sellCryptoNotional;
+        sellAllCrypto: typeof import("./orders").sellAllCrypto;
+        getOpenCryptoOrders: typeof import("./orders").getOpenCryptoOrders;
+        cancelAllCryptoOrders: typeof import("./orders").cancelAllCryptoOrders;
+        isCryptoPair: typeof import("./orders").isCryptoPair;
+    };
+    data: {
+        getCryptoBars: typeof import("./data").getCryptoBars;
+        getLatestCryptoTrades: typeof import("./data").getLatestCryptoTrades;
+        getLatestCryptoQuotes: typeof import("./data").getLatestCryptoQuotes;
+        getCryptoPrice: typeof import("./data").getCryptoPrice;
+        getCryptoSpread: typeof import("./data").getCryptoSpread;
+        getCryptoSnapshots: typeof import("./data").getCryptoSnapshots;
+        getCryptoTrades: typeof import("./data").getCryptoTrades;
+        getCryptoDailyPrices: typeof import("./data").getCryptoDailyPrices;
+        getCrypto24HourChange: typeof import("./data").getCrypto24HourChange;
+        getSupportedCryptoPairs: typeof import("./data").getSupportedCryptoPairs;
+        getCryptoPairsByQuote: typeof import("./data").getCryptoPairsByQuote;
+        isSupportedCryptoPair: typeof import("./data").isSupportedCryptoPair;
+        getPopularCryptoPairs: typeof import("./data").getPopularCryptoPairs;
+        BTC_PAIRS: import("../..").BTCPairs[];
+        USDT_PAIRS: import("../..").USDTPairs[];
+        USDC_PAIRS: import("../..").USDCPairs[];
+        USD_PAIRS: import("../..").USDPairs[];
+    };
+};
+export default _default;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/alpaca/crypto/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,EACL,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,UAAU,CAAC;AAGlB,OAAO,EACL,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,QAAQ,CAAC;AAMhB,eAAO,MAAM,MAAM;;;;;;;;;;;;CAAe,CAAC;AACnC,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;CAAa,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAE/B,wBAGE"}

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,205 @@
+/**
+ * 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 * as legacyApi from "./legacy";
+export { legacyApi };
+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 clock from "./trading/clock";
+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;
+    clock: typeof clock;
+    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":"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"}

package/dist/types/alpaca/legacy/account.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Legacy Alpaca Account Functions
+ * Account details, portfolio history, and configuration management
+ * using AlpacaAuth pattern with direct fetch calls.
+ */
+import { types } from "@adaptic/backend-legacy";
+import { AlpacaAccountDetails, AccountConfiguration, FetchAccountDetailsProps, FetchPortfolioHistoryProps, PortfolioHistoryResponse } from "../../types/alpaca-types";
+/**
+ * Fetches account details from Alpaca API.
+ * @param props - The properties for fetching account details
+ * @returns The account details
+ */
+export declare function fetchAccountDetails({ accountId, client, alpacaAccount, auth, }: FetchAccountDetailsProps): Promise<AlpacaAccountDetails>;
+/**
+ * Fetches portfolio history for one Alpaca account, as stored in Adaptic backend.
+ * @param props - The properties for fetching portfolio history
+ * @returns The portfolio history
+ */
+export declare function fetchPortfolioHistory({ params, accountId, client, alpacaAccount, }: FetchPortfolioHistoryProps): Promise<PortfolioHistoryResponse>;
+/**
+ * Retrieves the configuration for a specific Alpaca account.
+ * @param account - The Alpaca account to retrieve the configuration for
+ * @returns The account configuration
+ */
+export declare function getConfiguration(account: types.AlpacaAccount): Promise<AccountConfiguration>;
+/**
+ * Updates the configuration for a specific Alpaca account.
+ * @param user - The user making the update
+ * @param account - The Alpaca account to update
+ * @param updatedConfig - The updated configuration
+ * @returns The updated account configuration
+ */
+export declare function updateConfiguration(user: types.User, account: types.AlpacaAccount, updatedConfig: AccountConfiguration): Promise<AccountConfiguration>;
+//# sourceMappingURL=account.d.ts.map

package/dist/types/alpaca/legacy/account.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"account.d.ts","sourceRoot":"","sources":["../../../../src/alpaca/legacy/account.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,EAAE,KAAK,EAAE,MAAM,yBAAyB,CAAC;AAGhD,OAAO,EACL,oBAAoB,EACpB,oBAAoB,EAEpB,wBAAwB,EACxB,0BAA0B,EAC1B,wBAAwB,EAEzB,MAAM,0BAA0B,CAAC;AAMlC;;;;GAIG;AACH,wBAAsB,mBAAmB,CAAC,EACxC,SAAS,EACT,MAAM,EACN,aAAa,EACb,IAAI,GACL,EAAE,wBAAwB,GAAG,OAAO,CAAC,oBAAoB,CAAC,CAmE1D;AAED;;;;GAIG;AACH,wBAAsB,qBAAqB,CAAC,EAC1C,MAAM,EACN,SAAS,EACT,MAAM,EACN,aAAa,GACd,EAAE,0BAA0B,GAAG,OAAO,CAAC,wBAAwB,CAAC,CA4FhE;AAED;;;;GAIG;AACH,wBAAsB,gBAAgB,CACpC,OAAO,EAAE,KAAK,CAAC,aAAa,GAC3B,OAAO,CAAC,oBAAoB,CAAC,CAgG/B;AAED;;;;;;GAMG;AACH,wBAAsB,mBAAmB,CACvC,IAAI,EAAE,KAAK,CAAC,IAAI,EAChB,OAAO,EAAE,KAAK,CAAC,aAAa,EAC5B,aAAa,EAAE,oBAAoB,GAClC,OAAO,CAAC,oBAAoB,CAAC,CAoP/B"}

package/dist/types/alpaca/legacy/assets.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Legacy Alpaca Asset Functions
+ * Asset retrieval using AlpacaAuth pattern with direct fetch calls.
+ */
+import { AlpacaAuth, AlpacaAsset } from "../../types/alpaca-types";
+/**
+ * Retrieves an asset from Alpaca by symbol or asset ID.
+ * @param auth - The authentication details for Alpaca
+ * @param symbolOrAssetId - The symbol or asset ID to retrieve
+ * @returns The requested asset
+ */
+export declare function getAsset(auth: AlpacaAuth, symbolOrAssetId: string): Promise<AlpacaAsset>;
+//# sourceMappingURL=assets.d.ts.map

package/dist/types/alpaca/legacy/assets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assets.d.ts","sourceRoot":"","sources":["../../../../src/alpaca/legacy/assets.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAMnE;;;;;GAKG;AACH,wBAAsB,QAAQ,CAC5B,IAAI,EAAE,UAAU,EAChB,eAAe,EAAE,MAAM,GACtB,OAAO,CAAC,WAAW,CAAC,CAiCtB"}

package/dist/types/alpaca/legacy/auth.d.ts

@@ -0,0 +1,18 @@
+import { AlpacaAuth } from "../../types/alpaca-types";
+/**
+ * Validated authentication credentials ready for API calls.
+ */
+export interface ValidatedAuth {
+    APIKey: string;
+    APISecret: string;
+    type: string;
+}
+/**
+ * Resolves AlpacaAuth into validated API credentials.
+ * Supports authentication via adapticAccountId or direct API key/secret.
+ * @param auth - The authentication details for Alpaca
+ * @returns Validated authentication credentials
+ * @throws Error if authentication details are missing or invalid
+ */
+export declare function validateAuth(auth: AlpacaAuth): Promise<ValidatedAuth>;
+//# sourceMappingURL=auth.d.ts.map

package/dist/types/alpaca/legacy/auth.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth.d.ts","sourceRoot":"","sources":["../../../../src/alpaca/legacy/auth.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AAGtD;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;CACd;AAED;;;;;;GAMG;AACH,wBAAsB,YAAY,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,aAAa,CAAC,CA6C3E"}

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

@@ -0,0 +1,15 @@
+/**
+ * Legacy Alpaca API Functions
+ * Re-exports all legacy functions that use the AlpacaAuth pattern
+ * with direct fetch calls (as opposed to the SDK-based AlpacaClient pattern).
+ *
+ * @module @adaptic/utils/alpaca/legacy
+ */
+export { validateAuth, type ValidatedAuth } from "./auth";
+export { roundPriceForAlpaca, cleanContent } from "./utils";
+export { makeRequest, createOrder, getOrders, cancelAllOrders, getOrder, replaceOrder, cancelOrder, createLimitOrder, } from "./orders";
+export { fetchAllPositions, fetchPosition, closePosition, closeAllPositions, closeAllPositionsAfterHours, } from "./positions";
+export { fetchAccountDetails, fetchPortfolioHistory, getConfiguration, updateConfiguration, } from "./account";
+export { getLatestQuotes, fetchNews } from "./market-data";
+export { getAsset } from "./assets";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/alpaca/legacy/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,OAAO,EAAE,YAAY,EAAE,KAAK,aAAa,EAAE,MAAM,QAAQ,CAAC;AAG1D,OAAO,EAAE,mBAAmB,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAG5D,OAAO,EACL,WAAW,EACX,WAAW,EACX,SAAS,EACT,eAAe,EACf,QAAQ,EACR,YAAY,EACZ,WAAW,EACX,gBAAgB,GACjB,MAAM,UAAU,CAAC;AAGlB,OAAO,EACL,iBAAiB,EACjB,aAAa,EACb,aAAa,EACb,iBAAiB,EACjB,2BAA2B,GAC5B,MAAM,aAAa,CAAC;AAGrB,OAAO,EACL,mBAAmB,EACnB,qBAAqB,EACrB,gBAAgB,EAChB,mBAAmB,GACpB,MAAM,WAAW,CAAC;AAGnB,OAAO,EAAE,eAAe,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAG3D,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC"}