@adaptic/utils 0.0.383 → 0.1.1

package/dist/types/alpaca/trading/positions.d.ts

@@ -0,0 +1,389 @@
+/**
+ * Position Management Module
+ * Handles all position-related operations using Alpaca SDK
+ */
+import { AlpacaClient } from '../client';
+import { AlpacaPosition, AssetClass, AlpacaOrder } from '../../types/alpaca-types';
+/**
+ * P&L summary for a single position
+ */
+export interface PositionPnLSummary {
+    /** Trading symbol */
+    symbol: string;
+    /** Number of shares/contracts held */
+    qty: number;
+    /** Average entry price per share */
+    avgEntryPrice: number;
+    /** Current market price per share */
+    currentPrice: number;
+    /** Total market value of the position */
+    marketValue: number;
+    /** Total cost basis of the position */
+    costBasis: number;
+    /** Unrealized profit/loss in dollars */
+    unrealizedPL: number;
+    /** Unrealized profit/loss as a percentage */
+    unrealizedPLPercent: number;
+    /** Today's profit/loss in dollars */
+    todayPL: number;
+    /** Today's profit/loss as a percentage */
+    todayPLPercent: number;
+}
+/**
+ * P&L summary for the entire portfolio
+ */
+export interface PortfolioPnLSummary {
+    /** Total market value of all positions */
+    totalMarketValue: number;
+    /** Total cost basis of all positions */
+    totalCostBasis: number;
+    /** Total unrealized profit/loss in dollars */
+    totalUnrealizedPL: number;
+    /** Total unrealized profit/loss as a percentage */
+    totalUnrealizedPLPercent: number;
+    /** Today's total profit/loss in dollars */
+    todayPL: number;
+    /** Today's total profit/loss as a percentage */
+    todayPLPercent: number;
+    /** Individual position summaries */
+    positions: PositionPnLSummary[];
+}
+/**
+ * Options for closing a single position
+ */
+export interface ClosePositionOptions {
+    /** Percentage of position to close (0-100) */
+    percentage?: number;
+    /** Specific quantity to close */
+    qty?: number;
+}
+/**
+ * Options for closing all positions
+ */
+export interface CloseAllPositionsOptions {
+    /** Whether to cancel open orders first */
+    cancelOrders?: boolean;
+}
+/**
+ * Options for closing positions during after-hours
+ */
+export interface ClosePositionsAfterHoursOptions {
+    /** Percentage offset from current price for limit orders (default: 0.5) */
+    limitPriceOffset?: number;
+}
+/**
+ * Get all open positions for the account
+ *
+ * @param client - The Alpaca client instance
+ * @returns Array of all open positions
+ *
+ * @example
+ * const client = createAlpacaClient(config);
+ * const positions = await getPositions(client);
+ * console.log(`Found ${positions.length} open positions`);
+ */
+export declare function getPositions(client: AlpacaClient): Promise<AlpacaPosition[]>;
+/**
+ * Get positions filtered by asset class
+ *
+ * @param client - The Alpaca client instance
+ * @param assetClass - The asset class to filter by ('us_equity', 'us_option', 'crypto')
+ * @returns Array of positions matching the asset class
+ *
+ * @example
+ * const equityPositions = await getPositionsByAssetClass(client, 'us_equity');
+ * const optionPositions = await getPositionsByAssetClass(client, 'us_option');
+ */
+export declare function getPositionsByAssetClass(client: AlpacaClient, assetClass: AssetClass): Promise<AlpacaPosition[]>;
+/**
+ * Get a specific position by symbol
+ *
+ * @param client - The Alpaca client instance
+ * @param symbol - The trading symbol to look up
+ * @returns The position if found, null otherwise
+ *
+ * @example
+ * const applePosition = await getPosition(client, 'AAPL');
+ * if (applePosition) {
+ *   console.log(`Holding ${applePosition.qty} shares of AAPL`);
+ * }
+ */
+export declare function getPosition(client: AlpacaClient, symbol: string): Promise<AlpacaPosition | null>;
+/**
+ * Check if a position exists for a given symbol
+ *
+ * @param client - The Alpaca client instance
+ * @param symbol - The trading symbol to check
+ * @returns True if a position exists, false otherwise
+ *
+ * @example
+ * if (await hasPosition(client, 'AAPL')) {
+ *   console.log('Already have AAPL position');
+ * }
+ */
+export declare function hasPosition(client: AlpacaClient, symbol: string): Promise<boolean>;
+/**
+ * Get the quantity of shares held for a symbol
+ *
+ * @param client - The Alpaca client instance
+ * @param symbol - The trading symbol
+ * @returns The quantity held (positive for long, negative for short), 0 if no position
+ *
+ * @example
+ * const qty = await getPositionQty(client, 'AAPL');
+ * console.log(`Holding ${qty} shares of AAPL`);
+ */
+export declare function getPositionQty(client: AlpacaClient, symbol: string): Promise<number>;
+/**
+ * Get the market value of a position
+ *
+ * @param client - The Alpaca client instance
+ * @param symbol - The trading symbol
+ * @returns The market value in dollars, 0 if no position
+ *
+ * @example
+ * const value = await getPositionValue(client, 'AAPL');
+ * console.log(`AAPL position worth $${value.toFixed(2)}`);
+ */
+export declare function getPositionValue(client: AlpacaClient, symbol: string): Promise<number>;
+/**
+ * Get the side of a position (long or short)
+ *
+ * @param client - The Alpaca client instance
+ * @param symbol - The trading symbol
+ * @returns 'long', 'short', or null if no position
+ *
+ * @example
+ * const side = await getPositionSide(client, 'AAPL');
+ * if (side === 'long') {
+ *   console.log('Long position in AAPL');
+ * }
+ */
+export declare function getPositionSide(client: AlpacaClient, symbol: string): Promise<'long' | 'short' | null>;
+/**
+ * Close a specific position
+ *
+ * @param client - The Alpaca client instance
+ * @param symbol - The trading symbol to close
+ * @param options - Optional parameters for partial closes
+ * @returns The resulting close order
+ * @throws Error if no position exists or close fails
+ *
+ * @example
+ * // Close entire position
+ * const order = await closePosition(client, 'AAPL');
+ *
+ * // Close 50% of position
+ * const order = await closePosition(client, 'AAPL', { percentage: 50 });
+ *
+ * // Close specific quantity
+ * const order = await closePosition(client, 'AAPL', { qty: 10 });
+ */
+export declare function closePosition(client: AlpacaClient, symbol: string, options?: ClosePositionOptions): Promise<AlpacaOrder>;
+/**
+ * Close all open positions
+ *
+ * @param client - The Alpaca client instance
+ * @param options - Optional parameters
+ * @returns Array of close orders
+ *
+ * @example
+ * // Close all positions and cancel orders
+ * const orders = await closeAllPositions(client, { cancelOrders: true });
+ *
+ * // Close all positions without canceling orders
+ * const orders = await closeAllPositions(client, { cancelOrders: false });
+ */
+export declare function closeAllPositions(client: AlpacaClient, options?: CloseAllPositionsOptions): Promise<AlpacaOrder[]>;
+/**
+ * Close all positions with limit orders (for after-hours trading)
+ * Sets limit price slightly below current price for sells, above for buys
+ *
+ * @param client - The Alpaca client instance
+ * @param options - Optional parameters
+ * @returns Array of limit orders created
+ *
+ * @example
+ * // Close positions after hours with 0.5% price offset
+ * const orders = await closeAllPositionsAfterHours(client, { limitPriceOffset: 0.5 });
+ */
+export declare function closeAllPositionsAfterHours(client: AlpacaClient, options?: ClosePositionsAfterHoursOptions): Promise<AlpacaOrder[]>;
+/**
+ * Get P&L summary for a specific position
+ *
+ * @param client - The Alpaca client instance
+ * @param symbol - The trading symbol
+ * @returns P&L summary for the position, null if no position exists
+ *
+ * @example
+ * const pnl = await getPositionPnL(client, 'AAPL');
+ * if (pnl) {
+ *   console.log(`AAPL unrealized P&L: $${pnl.unrealizedPL.toFixed(2)} (${pnl.unrealizedPLPercent.toFixed(2)}%)`);
+ * }
+ */
+export declare function getPositionPnL(client: AlpacaClient, symbol: string): Promise<PositionPnLSummary | null>;
+/**
+ * Get total portfolio P&L summary
+ *
+ * @param client - The Alpaca client instance
+ * @returns Portfolio-level P&L summary including all positions
+ *
+ * @example
+ * const portfolio = await getPortfolioPnL(client);
+ * console.log(`Total unrealized P&L: $${portfolio.totalUnrealizedPL.toFixed(2)}`);
+ * console.log(`Today's P&L: $${portfolio.todayPL.toFixed(2)}`);
+ */
+export declare function getPortfolioPnL(client: AlpacaClient): Promise<PortfolioPnLSummary>;
+/**
+ * Get all equity positions (us_equity asset class)
+ *
+ * @param client - The Alpaca client instance
+ * @returns Array of equity positions
+ *
+ * @example
+ * const equities = await getEquityPositions(client);
+ */
+export declare function getEquityPositions(client: AlpacaClient): Promise<AlpacaPosition[]>;
+/**
+ * Get all option positions (us_option asset class)
+ *
+ * @param client - The Alpaca client instance
+ * @returns Array of option positions
+ *
+ * @example
+ * const options = await getOptionPositions(client);
+ */
+export declare function getOptionPositions(client: AlpacaClient): Promise<AlpacaPosition[]>;
+/**
+ * Get all crypto positions
+ *
+ * @param client - The Alpaca client instance
+ * @returns Array of crypto positions
+ *
+ * @example
+ * const crypto = await getCryptoPositions(client);
+ */
+export declare function getCryptoPositions(client: AlpacaClient): Promise<AlpacaPosition[]>;
+/**
+ * Get count of open positions
+ *
+ * @param client - The Alpaca client instance
+ * @param assetClass - Optional asset class filter
+ * @returns Number of open positions
+ *
+ * @example
+ * const totalPositions = await getPositionCount(client);
+ * const equityPositions = await getPositionCount(client, 'us_equity');
+ */
+export declare function getPositionCount(client: AlpacaClient, assetClass?: AssetClass): Promise<number>;
+/**
+ * Get symbols of all open positions
+ *
+ * @param client - The Alpaca client instance
+ * @param assetClass - Optional asset class filter
+ * @returns Array of position symbols
+ *
+ * @example
+ * const symbols = await getPositionSymbols(client);
+ * console.log(`Holding positions in: ${symbols.join(', ')}`);
+ */
+export declare function getPositionSymbols(client: AlpacaClient, assetClass?: AssetClass): Promise<string[]>;
+/**
+ * Get total market value of all positions
+ *
+ * @param client - The Alpaca client instance
+ * @param assetClass - Optional asset class filter
+ * @returns Total market value in dollars
+ *
+ * @example
+ * const totalValue = await getTotalMarketValue(client);
+ * const equityValue = await getTotalMarketValue(client, 'us_equity');
+ */
+export declare function getTotalMarketValue(client: AlpacaClient, assetClass?: AssetClass): Promise<number>;
+/**
+ * Check if there are any open positions
+ *
+ * @param client - The Alpaca client instance
+ * @param assetClass - Optional asset class filter
+ * @returns True if there are open positions
+ *
+ * @example
+ * if (await hasAnyPositions(client)) {
+ *   console.log('Portfolio has open positions');
+ * }
+ */
+export declare function hasAnyPositions(client: AlpacaClient, assetClass?: AssetClass): Promise<boolean>;
+/**
+ * Get positions sorted by market value (descending)
+ *
+ * @param client - The Alpaca client instance
+ * @param assetClass - Optional asset class filter
+ * @returns Positions sorted by market value (largest first)
+ *
+ * @example
+ * const sortedPositions = await getPositionsByValue(client);
+ * console.log(`Largest position: ${sortedPositions[0]?.symbol}`);
+ */
+export declare function getPositionsByValue(client: AlpacaClient, assetClass?: AssetClass): Promise<AlpacaPosition[]>;
+/**
+ * Get positions sorted by unrealized P&L (descending - best performers first)
+ *
+ * @param client - The Alpaca client instance
+ * @param assetClass - Optional asset class filter
+ * @returns Positions sorted by unrealized P&L
+ *
+ * @example
+ * const sortedPositions = await getPositionsByPnL(client);
+ * const winners = sortedPositions.filter(p => parseFloat(p.unrealized_pl) > 0);
+ * const losers = sortedPositions.filter(p => parseFloat(p.unrealized_pl) < 0);
+ */
+export declare function getPositionsByPnL(client: AlpacaClient, assetClass?: AssetClass): Promise<AlpacaPosition[]>;
+/**
+ * Get winning positions (positive unrealized P&L)
+ *
+ * @param client - The Alpaca client instance
+ * @param assetClass - Optional asset class filter
+ * @returns Positions with positive unrealized P&L
+ *
+ * @example
+ * const winners = await getWinningPositions(client);
+ */
+export declare function getWinningPositions(client: AlpacaClient, assetClass?: AssetClass): Promise<AlpacaPosition[]>;
+/**
+ * Get losing positions (negative unrealized P&L)
+ *
+ * @param client - The Alpaca client instance
+ * @param assetClass - Optional asset class filter
+ * @returns Positions with negative unrealized P&L
+ *
+ * @example
+ * const losers = await getLosingPositions(client);
+ */
+export declare function getLosingPositions(client: AlpacaClient, assetClass?: AssetClass): Promise<AlpacaPosition[]>;
+declare const _default: {
+    getPositions: typeof getPositions;
+    getPositionsByAssetClass: typeof getPositionsByAssetClass;
+    getPosition: typeof getPosition;
+    hasPosition: typeof hasPosition;
+    getPositionQty: typeof getPositionQty;
+    getPositionValue: typeof getPositionValue;
+    getPositionSide: typeof getPositionSide;
+    closePosition: typeof closePosition;
+    closeAllPositions: typeof closeAllPositions;
+    closeAllPositionsAfterHours: typeof closeAllPositionsAfterHours;
+    getPositionPnL: typeof getPositionPnL;
+    getPortfolioPnL: typeof getPortfolioPnL;
+    getEquityPositions: typeof getEquityPositions;
+    getOptionPositions: typeof getOptionPositions;
+    getCryptoPositions: typeof getCryptoPositions;
+    getPositionCount: typeof getPositionCount;
+    getPositionSymbols: typeof getPositionSymbols;
+    getTotalMarketValue: typeof getTotalMarketValue;
+    hasAnyPositions: typeof hasAnyPositions;
+    getPositionsByValue: typeof getPositionsByValue;
+    getPositionsByPnL: typeof getPositionsByPnL;
+    getWinningPositions: typeof getWinningPositions;
+    getLosingPositions: typeof getLosingPositions;
+};
+export default _default;
+//# sourceMappingURL=positions.d.ts.map

package/dist/types/alpaca/trading/positions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"positions.d.ts","sourceRoot":"","sources":["../../../../src/alpaca/trading/positions.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAEzC,OAAO,EAAE,cAAc,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAUnF;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,qBAAqB;IACrB,MAAM,EAAE,MAAM,CAAC;IACf,sCAAsC;IACtC,GAAG,EAAE,MAAM,CAAC;IACZ,oCAAoC;IACpC,aAAa,EAAE,MAAM,CAAC;IACtB,qCAAqC;IACrC,YAAY,EAAE,MAAM,CAAC;IACrB,yCAAyC;IACzC,WAAW,EAAE,MAAM,CAAC;IACpB,uCAAuC;IACvC,SAAS,EAAE,MAAM,CAAC;IAClB,wCAAwC;IACxC,YAAY,EAAE,MAAM,CAAC;IACrB,6CAA6C;IAC7C,mBAAmB,EAAE,MAAM,CAAC;IAC5B,qCAAqC;IACrC,OAAO,EAAE,MAAM,CAAC;IAChB,0CAA0C;IAC1C,cAAc,EAAE,MAAM,CAAC;CACxB;AAED;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,0CAA0C;IAC1C,gBAAgB,EAAE,MAAM,CAAC;IACzB,wCAAwC;IACxC,cAAc,EAAE,MAAM,CAAC;IACvB,8CAA8C;IAC9C,iBAAiB,EAAE,MAAM,CAAC;IAC1B,mDAAmD;IACnD,wBAAwB,EAAE,MAAM,CAAC;IACjC,2CAA2C;IAC3C,OAAO,EAAE,MAAM,CAAC;IAChB,gDAAgD;IAChD,cAAc,EAAE,MAAM,CAAC;IACvB,oCAAoC;IACpC,SAAS,EAAE,kBAAkB,EAAE,CAAC;CACjC;AAED;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC,8CAA8C;IAC9C,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,iCAAiC;IACjC,GAAG,CAAC,EAAE,MAAM,CAAC;CACd;AAED;;GAEG;AACH,MAAM,WAAW,wBAAwB;IACvC,0CAA0C;IAC1C,YAAY,CAAC,EAAE,OAAO,CAAC;CACxB;AAED;;GAEG;AACH,MAAM,WAAW,+BAA+B;IAC9C,2EAA2E;IAC3E,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B;AAyCD;;;;;;;;;;GAUG;AACH,wBAAsB,YAAY,CAAC,MAAM,EAAE,YAAY,GAAG,OAAO,CAAC,cAAc,EAAE,CAAC,CAalF;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,wBAAwB,CAC5C,MAAM,EAAE,YAAY,EACpB,UAAU,EAAE,UAAU,GACrB,OAAO,CAAC,cAAc,EAAE,CAAC,CAa3B;AAED;;;;;;;;;;;;GAYG;AACH,wBAAsB,WAAW,CAC/B,MAAM,EAAE,YAAY,EACpB,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,cAAc,GAAG,IAAI,CAAC,CAkBhC;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,WAAW,CAAC,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAGxF;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,cAAc,CAAC,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAO1F;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,gBAAgB,CAAC,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAM5F;AAED;;;;;;;;;;;;GAYG;AACH,wBAAsB,eAAe,CACnC,MAAM,EAAE,YAAY,EACpB,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,MAAM,GAAG,OAAO,GAAG,IAAI,CAAC,CAGlC;AAMD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAsB,aAAa,CACjC,MAAM,EAAE,YAAY,EACpB,MAAM,EAAE,MAAM,EACd,OAAO,CAAC,EAAE,oBAAoB,GAC7B,OAAO,CAAC,WAAW,CAAC,CAwCtB;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAsB,iBAAiB,CACrC,MAAM,EAAE,YAAY,EACpB,OAAO,CAAC,EAAE,wBAAwB,GACjC,OAAO,CAAC,WAAW,EAAE,CAAC,CAyBxB;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,2BAA2B,CAC/C,MAAM,EAAE,YAAY,EACpB,OAAO,CAAC,EAAE,+BAA+B,GACxC,OAAO,CAAC,WAAW,EAAE,CAAC,CAkExB;AAMD;;;;;;;;;;;;GAYG;AACH,wBAAsB,cAAc,CAClC,MAAM,EAAE,YAAY,EACpB,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,kBAAkB,GAAG,IAAI,CAAC,CAsCpC;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,eAAe,CAAC,MAAM,EAAE,YAAY,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAgExF;AAMD;;;;;;;;GAQG;AACH,wBAAsB,kBAAkB,CAAC,MAAM,EAAE,YAAY,GAAG,OAAO,CAAC,cAAc,EAAE,CAAC,CAExF;AAED;;;;;;;;GAQG;AACH,wBAAsB,kBAAkB,CAAC,MAAM,EAAE,YAAY,GAAG,OAAO,CAAC,cAAc,EAAE,CAAC,CAExF;AAED;;;;;;;;GAQG;AACH,wBAAsB,kBAAkB,CAAC,MAAM,EAAE,YAAY,GAAG,OAAO,CAAC,cAAc,EAAE,CAAC,CAExF;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,gBAAgB,CACpC,MAAM,EAAE,YAAY,EACpB,UAAU,CAAC,EAAE,UAAU,GACtB,OAAO,CAAC,MAAM,CAAC,CAKjB;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,kBAAkB,CACtC,MAAM,EAAE,YAAY,EACpB,UAAU,CAAC,EAAE,UAAU,GACtB,OAAO,CAAC,MAAM,EAAE,CAAC,CAKnB;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,mBAAmB,CACvC,MAAM,EAAE,YAAY,EACpB,UAAU,CAAC,EAAE,UAAU,GACtB,OAAO,CAAC,MAAM,CAAC,CAMjB;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,eAAe,CACnC,MAAM,EAAE,YAAY,EACpB,UAAU,CAAC,EAAE,UAAU,GACtB,OAAO,CAAC,OAAO,CAAC,CAGlB;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,mBAAmB,CACvC,MAAM,EAAE,YAAY,EACpB,UAAU,CAAC,EAAE,UAAU,GACtB,OAAO,CAAC,cAAc,EAAE,CAAC,CAU3B;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,iBAAiB,CACrC,MAAM,EAAE,YAAY,EACpB,UAAU,CAAC,EAAE,UAAU,GACtB,OAAO,CAAC,cAAc,EAAE,CAAC,CAU3B;AAED;;;;;;;;;GASG;AACH,wBAAsB,mBAAmB,CACvC,MAAM,EAAE,YAAY,EACpB,UAAU,CAAC,EAAE,UAAU,GACtB,OAAO,CAAC,cAAc,EAAE,CAAC,CAM3B;AAED;;;;;;;;;GASG;AACH,wBAAsB,kBAAkB,CACtC,MAAM,EAAE,YAAY,EACpB,UAAU,CAAC,EAAE,UAAU,GACtB,OAAO,CAAC,cAAc,EAAE,CAAC,CAM3B;;;;;;;;;;;;;;;;;;;;;;;;;;AAMD,wBA+BE"}

package/dist/types/alpaca/trading/smart-orders.d.ts

@@ -0,0 +1,301 @@
+/**
+ * Smart Orders Module
+ * Unified interface for bracket, OCO, OTO, and trailing stop orders
+ *
+ * This module aggregates all advanced order types and provides:
+ * - Automatic order type selection based on parameters
+ * - Convenience functions for common trading strategies
+ * - Risk-managed position creation with automatic sizing
+ * - Percentage-based bracket orders
+ *
+ * @module smart-orders
+ */
+import { AlpacaClient } from '../client';
+import { AlpacaOrder, OrderSide, TimeInForce } from '../../types/alpaca-types';
+import { createBracketOrder, createProtectiveBracket, BracketOrderResult, createExecutorFromTradingAPI } from './bracket-orders';
+import { createOCOOrder, OCOOrderResult } from './oco-orders';
+import { createOTOOrder, OTOOrderResult } from './oto-orders';
+import { createTrailingStop, updateTrailingStop } from './trailing-stops';
+export * from './bracket-orders';
+export * from './oco-orders';
+export * from './oto-orders';
+export * from './trailing-stops';
+/**
+ * Unified smart order creation parameters
+ * Allows specifying entry, take profit, stop loss, and trailing stop in a single interface
+ */
+export interface SmartOrderParams {
+    /** Trading symbol (e.g., 'AAPL') */
+    symbol: string;
+    /** Number of shares */
+    qty: number;
+    /** Order side: 'buy' or 'sell' */
+    side: OrderSide;
+    /** Entry configuration (optional - if omitted, assumes existing position) */
+    entry?: {
+        /** Entry order type */
+        type: 'market' | 'limit';
+        /** Limit price for entry (required if type is 'limit') */
+        limitPrice?: number;
+    };
+    /** Take profit configuration (optional) */
+    takeProfit?: {
+        /** Limit price for take profit */
+        limitPrice: number;
+    };
+    /** Stop loss configuration (optional) */
+    stopLoss?: {
+        /** Stop price to trigger stop loss */
+        stopPrice: number;
+        /** Optional limit price for stop-limit orders */
+        limitPrice?: number;
+    };
+    /** Trailing stop configuration (alternative to fixed stop loss) */
+    trailingStop?: {
+        /** Trail by percentage (e.g., 5 = 5%) */
+        trailPercent?: number;
+        /** Trail by fixed dollar amount */
+        trailPrice?: number;
+    };
+    /** Time in force for the order */
+    timeInForce?: TimeInForce;
+    /** Allow extended hours trading */
+    extendedHours?: boolean;
+}
+/**
+ * Type of order determined by smart order analysis
+ */
+export type SmartOrderType = 'bracket' | 'oco' | 'oto' | 'trailing_stop' | 'simple';
+/**
+ * Result of smart order creation - union of all possible result types
+ */
+export type SmartOrderResult = BracketOrderResult | OCOOrderResult | OTOOrderResult | AlpacaOrder;
+/**
+ * Analyze parameters and determine the best order type
+ *
+ * Decision logic:
+ * - Bracket: Entry + Take Profit + Stop Loss
+ * - OCO: Take Profit + Stop Loss (no entry - for existing position)
+ * - OTO: Entry + single exit (either TP or SL, not both)
+ * - Trailing Stop: Only trailing stop specified
+ * - Simple: None of the above
+ *
+ * @param params - Smart order parameters
+ * @returns The recommended order type
+ *
+ * @example
+ * ```typescript
+ * const orderType = determineOrderType({
+ *   symbol: 'AAPL',
+ *   qty: 100,
+ *   side: 'buy',
+ *   entry: { type: 'limit', limitPrice: 150 },
+ *   takeProfit: { limitPrice: 160 },
+ *   stopLoss: { stopPrice: 145 },
+ * });
+ * // Returns: 'bracket'
+ * ```
+ */
+export declare function determineOrderType(params: SmartOrderParams): SmartOrderType;
+/**
+ * Create a smart order based on parameters
+ * Automatically selects the appropriate order type based on provided configuration
+ *
+ * @param client - AlpacaClient instance
+ * @param params - Smart order parameters
+ * @returns The created order(s) based on the determined order type
+ * @throws Error if parameters result in 'simple' order type (use createOrder directly)
+ *
+ * @example
+ * ```typescript
+ * // Full bracket order with entry, take profit, and stop loss
+ * const result = await createSmartOrder(client, {
+ *   symbol: 'AAPL',
+ *   qty: 100,
+ *   side: 'buy',
+ *   entry: { type: 'limit', limitPrice: 150 },
+ *   takeProfit: { limitPrice: 160 },
+ *   stopLoss: { stopPrice: 145 },
+ *   timeInForce: 'gtc',
+ * });
+ *
+ * // OCO for existing position (no entry)
+ * const result = await createSmartOrder(client, {
+ *   symbol: 'AAPL',
+ *   qty: 100,
+ *   side: 'sell',
+ *   takeProfit: { limitPrice: 160 },
+ *   stopLoss: { stopPrice: 145 },
+ * });
+ *
+ * // OTO with entry and stop loss only
+ * const result = await createSmartOrder(client, {
+ *   symbol: 'AAPL',
+ *   qty: 100,
+ *   side: 'buy',
+ *   entry: { type: 'limit', limitPrice: 150 },
+ *   stopLoss: { stopPrice: 145 },
+ * });
+ *
+ * // Trailing stop
+ * const result = await createSmartOrder(client, {
+ *   symbol: 'AAPL',
+ *   qty: 100,
+ *   side: 'sell',
+ *   trailingStop: { trailPercent: 5 },
+ * });
+ * ```
+ */
+export declare function createSmartOrder(client: AlpacaClient, params: SmartOrderParams): Promise<SmartOrderResult>;
+/**
+ * Parameters for percentage-based bracket order
+ */
+export interface PercentageBracketParams {
+    /** Trading symbol */
+    symbol: string;
+    /** Number of shares */
+    qty: number;
+    /** Order side: 'buy' or 'sell' */
+    side: OrderSide;
+    /** Entry price (limit order) */
+    entryPrice: number;
+    /** Take profit percentage above/below entry (e.g., 5 = 5% profit target) */
+    takeProfitPercent: number;
+    /** Stop loss percentage above/below entry (e.g., 2 = 2% risk) */
+    stopLossPercent: number;
+    /** Time in force for the order */
+    timeInForce?: TimeInForce;
+}
+/**
+ * Quick bracket order with percentage-based take profit and stop loss
+ * Calculates TP and SL prices based on percentages from entry price
+ *
+ * For buy orders:
+ * - Take profit is entryPrice + takeProfitPercent
+ * - Stop loss is entryPrice - stopLossPercent
+ *
+ * For sell (short) orders:
+ * - Take profit is entryPrice - takeProfitPercent
+ * - Stop loss is entryPrice + stopLossPercent
+ *
+ * @param client - AlpacaClient instance
+ * @param params - Percentage bracket parameters
+ * @returns The created bracket order result
+ *
+ * @example
+ * ```typescript
+ * // Buy AAPL at $150 with 5% take profit ($157.50) and 2% stop loss ($147)
+ * const result = await createPercentageBracket(client, {
+ *   symbol: 'AAPL',
+ *   qty: 100,
+ *   side: 'buy',
+ *   entryPrice: 150.00,
+ *   takeProfitPercent: 5,  // Take profit at $157.50
+ *   stopLossPercent: 2,    // Stop loss at $147.00
+ *   timeInForce: 'gtc',
+ * });
+ * ```
+ */
+export declare function createPercentageBracket(client: AlpacaClient, params: PercentageBracketParams): Promise<BracketOrderResult>;
+/**
+ * Parameters for risk-managed position
+ */
+export interface RiskManagedPositionParams {
+    /** Trading symbol */
+    symbol: string;
+    /** Order side: 'buy' or 'sell' */
+    side: OrderSide;
+    /** Entry price (limit order) */
+    entryPrice: number;
+    /** Stop loss price */
+    stopPrice: number;
+    /** Dollar amount willing to risk */
+    riskAmount: number;
+    /** Optional take profit price */
+    takeProfitPrice?: number;
+    /** Time in force for the order */
+    timeInForce?: TimeInForce;
+}
+/**
+ * Create a risk-managed position
+ * Calculates position size based on risk amount and stop distance
+ *
+ * Position size formula: riskAmount / abs(entryPrice - stopPrice)
+ *
+ * @param client - AlpacaClient instance
+ * @param params - Risk-managed position parameters
+ * @returns The created bracket or OTO order result
+ * @throws Error if risk amount is too small for the stop distance
+ *
+ * @example
+ * ```typescript
+ * // Risk $500 on AAPL trade with entry at $150 and stop at $145
+ * // Position size = $500 / ($150 - $145) = 100 shares
+ * const result = await createRiskManagedPosition(client, {
+ *   symbol: 'AAPL',
+ *   side: 'buy',
+ *   entryPrice: 150.00,
+ *   stopPrice: 145.00,
+ *   riskAmount: 500,
+ *   takeProfitPrice: 160.00, // Optional
+ *   timeInForce: 'gtc',
+ * });
+ *
+ * // Actual risk: 100 shares * $5 stop distance = $500
+ * ```
+ */
+export declare function createRiskManagedPosition(client: AlpacaClient, params: RiskManagedPositionParams): Promise<BracketOrderResult | OTOOrderResult>;
+/**
+ * Calculate reward-to-risk ratio for a trade setup
+ *
+ * @param entryPrice - Entry price
+ * @param takeProfitPrice - Take profit price
+ * @param stopLossPrice - Stop loss price
+ * @param side - Order side ('buy' or 'sell')
+ * @returns Reward-to-risk ratio (e.g., 2.5 means 2.5:1 reward:risk)
+ *
+ * @example
+ * ```typescript
+ * // Buy at $150, TP at $160, SL at $145
+ * const rr = calculateRewardRiskRatio(150, 160, 145, 'buy');
+ * // Returns: 2.0 (reward: $10 / risk: $5 = 2:1)
+ * ```
+ */
+export declare function calculateRewardRiskRatio(entryPrice: number, takeProfitPrice: number, stopLossPrice: number, side: OrderSide): number;
+/**
+ * Calculate position size based on account risk percentage
+ *
+ * @param accountValue - Total account value
+ * @param riskPercent - Percentage of account to risk (e.g., 1 = 1%)
+ * @param entryPrice - Entry price
+ * @param stopPrice - Stop loss price
+ * @returns Recommended position size in shares
+ *
+ * @example
+ * ```typescript
+ * // $100,000 account, risk 1%, entry at $150, stop at $145
+ * const shares = calculatePositionSize(100000, 1, 150, 145);
+ * // Returns: 200 (risk $1,000 / $5 per share = 200 shares)
+ * ```
+ */
+export declare function calculatePositionSize(accountValue: number, riskPercent: number, entryPrice: number, stopPrice: number): number;
+/**
+ * Default export with all smart order functions
+ */
+declare const _default: {
+    createSmartOrder: typeof createSmartOrder;
+    determineOrderType: typeof determineOrderType;
+    createPercentageBracket: typeof createPercentageBracket;
+    createRiskManagedPosition: typeof createRiskManagedPosition;
+    calculateRewardRiskRatio: typeof calculateRewardRiskRatio;
+    calculatePositionSize: typeof calculatePositionSize;
+    createBracketOrder: typeof createBracketOrder;
+    createProtectiveBracket: typeof createProtectiveBracket;
+    createExecutorFromTradingAPI: typeof createExecutorFromTradingAPI;
+    createOCOOrder: typeof createOCOOrder;
+    createOTOOrder: typeof createOTOOrder;
+    createTrailingStop: typeof createTrailingStop;
+    updateTrailingStop: typeof updateTrailingStop;
+};
+export default _default;
+//# sourceMappingURL=smart-orders.d.ts.map