@adaptic/utils 0.0.382 → 0.1.0

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

@@ -0,0 +1,199 @@
+/**
+ * Alpaca Order Management Module
+ * Provides functions for creating, managing, and canceling orders using the official SDK
+ */
+import { AlpacaClient } from '../client';
+import { AlpacaOrder, CreateOrderParams, GetOrdersParams, ReplaceOrderParams, OrderStatus } from '../../types/alpaca-types';
+/**
+ * Response from cancel all orders operation
+ */
+export interface CancelAllOrdersResponse {
+    /** Number of orders successfully canceled */
+    canceled: number;
+    /** Order IDs that failed to cancel */
+    failed: string[];
+}
+/**
+ * Creates a new order using the Alpaca SDK.
+ * Supports market, limit, stop, and stop_limit order types.
+ *
+ * @param client - The AlpacaClient instance
+ * @param params - Order parameters including symbol, qty, side, type, and time_in_force
+ * @returns The created order object
+ * @throws Error if order creation fails
+ *
+ * @example
+ * // Create a market order
+ * const order = await createOrder(client, {
+ *   symbol: 'AAPL',
+ *   qty: '10',
+ *   side: 'buy',
+ *   type: 'market',
+ *   time_in_force: 'day',
+ * });
+ *
+ * @example
+ * // Create a limit order
+ * const order = await createOrder(client, {
+ *   symbol: 'AAPL',
+ *   qty: '10',
+ *   side: 'buy',
+ *   type: 'limit',
+ *   limit_price: '150.00',
+ *   time_in_force: 'gtc',
+ * });
+ */
+export declare function createOrder(client: AlpacaClient, params: CreateOrderParams): Promise<AlpacaOrder>;
+/**
+ * Retrieves a specific order by its ID.
+ *
+ * @param client - The AlpacaClient instance
+ * @param orderId - The unique identifier of the order
+ * @returns The order object if found
+ * @throws Error if order is not found or request fails
+ *
+ * @example
+ * const order = await getOrder(client, 'order-uuid-here');
+ * console.log(`Order status: ${order.status}`);
+ */
+export declare function getOrder(client: AlpacaClient, orderId: string): Promise<AlpacaOrder>;
+/**
+ * Retrieves all orders matching the specified filters.
+ *
+ * @param client - The AlpacaClient instance
+ * @param params - Optional filter parameters
+ * @param params.status - Filter by order status: 'open', 'closed', or 'all'
+ * @param params.limit - Maximum number of orders to return (default: 50, max: 500)
+ * @param params.after - Filter orders created after this timestamp (RFC-3339 format)
+ * @param params.until - Filter orders created before this timestamp (RFC-3339 format)
+ * @param params.direction - Sort direction: 'asc' or 'desc' (default: 'desc')
+ * @param params.nested - Include nested orders (for bracket orders)
+ * @param params.symbols - Filter by specific symbols
+ * @param params.side - Filter by order side: 'buy' or 'sell'
+ * @returns Array of orders matching the filters
+ *
+ * @example
+ * // Get all open orders
+ * const openOrders = await getOrders(client, { status: 'open' });
+ *
+ * @example
+ * // Get recent orders for specific symbols
+ * const orders = await getOrders(client, {
+ *   symbols: ['AAPL', 'GOOGL'],
+ *   limit: 100,
+ * });
+ */
+export declare function getOrders(client: AlpacaClient, params?: GetOrdersParams): Promise<AlpacaOrder[]>;
+/**
+ * Cancels a specific order by its ID.
+ * Only orders that are 'new', 'partially_filled', or 'accepted' can be canceled.
+ *
+ * @param client - The AlpacaClient instance
+ * @param orderId - The unique identifier of the order to cancel
+ * @throws Error if order cannot be canceled (e.g., already filled or canceled)
+ *
+ * @example
+ * await cancelOrder(client, 'order-uuid-here');
+ * console.log('Order canceled successfully');
+ */
+export declare function cancelOrder(client: AlpacaClient, orderId: string): Promise<void>;
+/**
+ * Cancels all open orders.
+ * This operation is atomic - if any cancellation fails, the function continues
+ * with remaining orders and returns information about failures.
+ *
+ * @param client - The AlpacaClient instance
+ * @returns Object containing count of canceled orders and any failures
+ *
+ * @example
+ * const result = await cancelAllOrders(client);
+ * console.log(`Canceled ${result.canceled} orders`);
+ * if (result.failed.length > 0) {
+ *   console.log(`Failed to cancel: ${result.failed.join(', ')}`);
+ * }
+ */
+export declare function cancelAllOrders(client: AlpacaClient): Promise<CancelAllOrdersResponse>;
+/**
+ * Replaces (modifies) an existing order with new parameters.
+ * Only pending orders can be replaced. The order must not be filled.
+ *
+ * Common use cases:
+ * - Update the quantity of an order
+ * - Change the limit price
+ * - Adjust the stop price
+ * - Update trailing stop parameters
+ *
+ * @param client - The AlpacaClient instance
+ * @param orderId - The unique identifier of the order to replace
+ * @param params - New order parameters (qty, limit_price, stop_price, trail, time_in_force, client_order_id)
+ * @returns The new order object that replaces the original
+ * @throws Error if order cannot be replaced
+ *
+ * @example
+ * // Update limit price
+ * const newOrder = await replaceOrder(client, 'order-id', {
+ *   limit_price: '155.00',
+ * });
+ *
+ * @example
+ * // Update quantity and price
+ * const newOrder = await replaceOrder(client, 'order-id', {
+ *   qty: '20',
+ *   limit_price: '152.50',
+ * });
+ */
+export declare function replaceOrder(client: AlpacaClient, orderId: string, params: ReplaceOrderParams): Promise<AlpacaOrder>;
+/**
+ * Convenience function to get all open orders.
+ *
+ * @param client - The AlpacaClient instance
+ * @param symbols - Optional array of symbols to filter by
+ * @returns Array of open orders
+ *
+ * @example
+ * const openOrders = await getOpenOrders(client);
+ * console.log(`Found ${openOrders.length} open orders`);
+ */
+export declare function getOpenOrders(client: AlpacaClient, symbols?: string[]): Promise<AlpacaOrder[]>;
+/**
+ * Convenience function to check if an order is in a terminal state.
+ * Terminal states are: filled, canceled, expired, rejected
+ *
+ * @param status - The order status to check
+ * @returns True if the order is in a terminal state
+ *
+ * @example
+ * const order = await getOrder(client, 'order-id');
+ * if (isOrderTerminal(order.status)) {
+ *   console.log('Order is complete');
+ * }
+ */
+export declare function isOrderTerminal(status: OrderStatus): boolean;
+/**
+ * Convenience function to check if an order can be canceled.
+ * Orders can be canceled if they are: new, partially_filled, accepted, pending_new
+ *
+ * @param status - The order status to check
+ * @returns True if the order can be canceled
+ *
+ * @example
+ * const order = await getOrder(client, 'order-id');
+ * if (isOrderCancelable(order.status)) {
+ *   await cancelOrder(client, order.id);
+ * }
+ */
+export declare function isOrderCancelable(status: OrderStatus): boolean;
+/**
+ * Gets an order by client order ID.
+ * Useful when you need to track orders using your own identifiers.
+ *
+ * @param client - The AlpacaClient instance
+ * @param clientOrderId - Your custom order identifier
+ * @returns The order if found
+ * @throws Error if order is not found
+ *
+ * @example
+ * const order = await getOrderByClientId(client, 'my-custom-order-123');
+ */
+export declare function getOrderByClientId(client: AlpacaClient, clientOrderId: string): Promise<AlpacaOrder>;
+//# sourceMappingURL=orders.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"orders.d.ts","sourceRoot":"","sources":["../../../../src/alpaca/trading/orders.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAGzC,OAAO,EACL,WAAW,EACX,iBAAiB,EACjB,eAAe,EACf,kBAAkB,EAClB,WAAW,EACZ,MAAM,0BAA0B,CAAC;AAWlC;;GAEG;AACH,MAAM,WAAW,uBAAuB;IACtC,6CAA6C;IAC7C,QAAQ,EAAE,MAAM,CAAC;IACjB,sCAAsC;IACtC,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAsB,WAAW,CAC/B,MAAM,EAAE,YAAY,EACpB,MAAM,EAAE,iBAAiB,GACxB,OAAO,CAAC,WAAW,CAAC,CAgCtB;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,QAAQ,CAC5B,MAAM,EAAE,YAAY,EACpB,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,WAAW,CAAC,CAkBtB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAsB,SAAS,CAC7B,MAAM,EAAE,YAAY,EACpB,MAAM,GAAE,eAAoB,GAC3B,OAAO,CAAC,WAAW,EAAE,CAAC,CAkCxB;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,WAAW,CAC/B,MAAM,EAAE,YAAY,EACpB,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,IAAI,CAAC,CA2Bf;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,eAAe,CACnC,MAAM,EAAE,YAAY,GACnB,OAAO,CAAC,uBAAuB,CAAC,CA+BlC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAsB,YAAY,CAChC,MAAM,EAAE,YAAY,EACpB,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,kBAAkB,GACzB,OAAO,CAAC,WAAW,CAAC,CAsCtB;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,aAAa,CACjC,MAAM,EAAE,YAAY,EACpB,OAAO,CAAC,EAAE,MAAM,EAAE,GACjB,OAAO,CAAC,WAAW,EAAE,CAAC,CAExB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,WAAW,GAAG,OAAO,CAG5D;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,WAAW,GAAG,OAAO,CAG9D;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,kBAAkB,CACtC,MAAM,EAAE,YAAY,EACpB,aAAa,EAAE,MAAM,GACpB,OAAO,CAAC,WAAW,CAAC,CAoBtB"}

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

@@ -0,0 +1,282 @@
+/**
+ * OTO (One-Triggers-Other) Order Module
+ *
+ * OTO orders consist of a primary order and a dependent order. When the primary
+ * order fills, it automatically triggers the dependent order. This is commonly
+ * used for:
+ * - Entry orders that automatically set up a stop loss
+ * - Entry orders that automatically set up a take profit
+ * - Automatic position management after entry
+ *
+ * Unlike bracket orders, OTO only has one dependent order (not two).
+ *
+ * @module oto-orders
+ */
+import { AlpacaClient } from '../client';
+import { AlpacaOrder, OrderSide, OrderType, TimeInForce } from '../../types/alpaca-types';
+/**
+ * Dependent order type options for OTO orders
+ */
+export type DependentOrderType = 'limit' | 'stop' | 'stop_limit' | 'trailing_stop';
+/**
+ * Configuration for the dependent order in an OTO
+ */
+export interface DependentOrderConfig {
+    /** Side of the dependent order */
+    side: OrderSide;
+    /** Type of the dependent order */
+    type: DependentOrderType;
+    /** Limit price (required for 'limit' and 'stop_limit' types) */
+    limitPrice?: number;
+    /** Stop price (required for 'stop' and 'stop_limit' types) */
+    stopPrice?: number;
+    /** Trail percent for trailing stop orders (e.g., 5 for 5%) */
+    trailPercent?: number;
+    /** Trail price for trailing stop orders (absolute dollar amount) */
+    trailPrice?: number;
+}
+/**
+ * OTO Order Parameters
+ * Primary order triggers secondary order on fill.
+ *
+ * @example
+ * // Buy 100 shares with automatic trailing stop on fill
+ * const params: OTOOrderParams = {
+ *   symbol: 'AAPL',
+ *   qty: 100,
+ *   side: 'buy',
+ *   type: 'limit',
+ *   limitPrice: 150.00,
+ *   dependent: {
+ *     side: 'sell',
+ *     type: 'trailing_stop',
+ *     trailPercent: 5
+ *   },
+ *   timeInForce: 'gtc'
+ * };
+ */
+export interface OTOOrderParams {
+    /** Symbol of the asset to trade */
+    symbol: string;
+    /** Quantity of shares to trade */
+    qty: number;
+    /** Side of the primary order */
+    side: OrderSide;
+    /** Type of the primary order */
+    type: OrderType;
+    /** Limit price for primary order (required for 'limit' and 'stop_limit') */
+    limitPrice?: number;
+    /** Stop price for primary order (required for 'stop' and 'stop_limit') */
+    stopPrice?: number;
+    /** Configuration for the dependent order that triggers on primary fill */
+    dependent: DependentOrderConfig;
+    /** Time in force for orders (default: 'day') */
+    timeInForce?: TimeInForce;
+    /** Allow extended hours trading */
+    extendedHours?: boolean;
+    /** Client-specified order ID for tracking */
+    clientOrderId?: string;
+}
+/**
+ * Result of OTO order creation
+ */
+export interface OTOOrderResult {
+    /** The primary (entry) order */
+    primaryOrder: AlpacaOrder;
+    /** The dependent order (will be triggered when primary fills) - null until triggered */
+    dependentOrder: AlpacaOrder | null;
+    /** All orders in the OTO group */
+    allOrders: AlpacaOrder[];
+    /** Parent order ID (can be used for cancellation and tracking) */
+    parentOrderId: string;
+}
+/**
+ * Create an OTO order (entry triggers exit)
+ *
+ * Useful for setting up automatic exit orders when an entry fills.
+ * The dependent order remains dormant until the primary order fills.
+ *
+ * @param client - AlpacaClient instance
+ * @param params - OTO order parameters
+ * @returns OTO order result with primary and dependent orders
+ *
+ * @example
+ * // Buy entry with automatic stop loss
+ * const result = await createOTOOrder(client, {
+ *   symbol: 'AAPL',
+ *   qty: 100,
+ *   side: 'buy',
+ *   type: 'limit',
+ *   limitPrice: 150.00,
+ *   dependent: {
+ *     side: 'sell',
+ *     type: 'stop',
+ *     stopPrice: 145.00
+ *   },
+ *   timeInForce: 'gtc'
+ * });
+ *
+ * @example
+ * // Market entry with automatic trailing stop
+ * const result = await createOTOOrder(client, {
+ *   symbol: 'TSLA',
+ *   qty: 50,
+ *   side: 'buy',
+ *   type: 'market',
+ *   dependent: {
+ *     side: 'sell',
+ *     type: 'trailing_stop',
+ *     trailPercent: 3 // 3% trailing stop
+ *   }
+ * });
+ *
+ * @example
+ * // Limit entry with take profit limit order
+ * const result = await createOTOOrder(client, {
+ *   symbol: 'NVDA',
+ *   qty: 25,
+ *   side: 'buy',
+ *   type: 'limit',
+ *   limitPrice: 400.00,
+ *   dependent: {
+ *     side: 'sell',
+ *     type: 'limit',
+ *     limitPrice: 440.00 // Take profit at 10% gain
+ *   },
+ *   timeInForce: 'gtc'
+ * });
+ *
+ * @example
+ * // Short entry with stop-limit protection
+ * const result = await createOTOOrder(client, {
+ *   symbol: 'GOOGL',
+ *   qty: 10,
+ *   side: 'sell',
+ *   type: 'limit',
+ *   limitPrice: 140.00,
+ *   dependent: {
+ *     side: 'buy',
+ *     type: 'stop_limit',
+ *     stopPrice: 145.00,
+ *     limitPrice: 146.00
+ *   },
+ *   timeInForce: 'gtc'
+ * });
+ */
+export declare function createOTOOrder(client: AlpacaClient, params: OTOOrderParams): Promise<OTOOrderResult>;
+/**
+ * Cancel an OTO order group by parent order ID
+ * This will cancel both the primary order and any pending dependent order
+ *
+ * @param client - AlpacaClient instance
+ * @param parentOrderId - The parent order ID from OTOOrderResult
+ *
+ * @example
+ * const result = await createOTOOrder(client, params);
+ * // Later, before primary fills...
+ * await cancelOTOOrder(client, result.parentOrderId);
+ */
+export declare function cancelOTOOrder(client: AlpacaClient, parentOrderId: string): Promise<void>;
+/**
+ * Get the status of an OTO order group
+ *
+ * @param client - AlpacaClient instance
+ * @param parentOrderId - The parent order ID from OTOOrderResult
+ * @returns The parent order with dependent order information
+ *
+ * @example
+ * const result = await createOTOOrder(client, params);
+ * const status = await getOTOOrderStatus(client, result.parentOrderId);
+ * console.log('Primary status:', status.status);
+ * if (status.legs && status.legs[0]) {
+ *   console.log('Dependent status:', status.legs[0].status);
+ * }
+ */
+export declare function getOTOOrderStatus(client: AlpacaClient, parentOrderId: string): Promise<AlpacaOrder>;
+/**
+ * Create a market buy with automatic stop loss
+ * Convenience wrapper for common use case
+ *
+ * @param client - AlpacaClient instance
+ * @param symbol - Stock symbol
+ * @param qty - Number of shares
+ * @param stopLossPrice - Stop loss trigger price
+ * @param stopLimitPrice - Optional limit price for stop-limit
+ *
+ * @example
+ * // Buy AAPL with immediate stop loss protection
+ * const result = await buyWithStopLoss(client, 'AAPL', 100, 145.00);
+ */
+export declare function buyWithStopLoss(client: AlpacaClient, symbol: string, qty: number, stopLossPrice: number, stopLimitPrice?: number): Promise<OTOOrderResult>;
+/**
+ * Create a market buy with automatic trailing stop
+ * Convenience wrapper for common use case
+ *
+ * @param client - AlpacaClient instance
+ * @param symbol - Stock symbol
+ * @param qty - Number of shares
+ * @param trailPercent - Trail percentage (e.g., 5 for 5%)
+ *
+ * @example
+ * // Buy TSLA with 3% trailing stop
+ * const result = await buyWithTrailingStop(client, 'TSLA', 50, 3);
+ */
+export declare function buyWithTrailingStop(client: AlpacaClient, symbol: string, qty: number, trailPercent: number): Promise<OTOOrderResult>;
+/**
+ * Create a limit buy with automatic take profit
+ * Convenience wrapper for limit entry with profit target
+ *
+ * @param client - AlpacaClient instance
+ * @param symbol - Stock symbol
+ * @param qty - Number of shares
+ * @param entryPrice - Limit price for entry
+ * @param takeProfitPrice - Take profit limit price
+ *
+ * @example
+ * // Buy NVDA at $400 with take profit at $440
+ * const result = await limitBuyWithTakeProfit(client, 'NVDA', 25, 400.00, 440.00);
+ */
+export declare function limitBuyWithTakeProfit(client: AlpacaClient, symbol: string, qty: number, entryPrice: number, takeProfitPrice: number): Promise<OTOOrderResult>;
+/**
+ * Create a short entry with automatic stop loss
+ * Convenience wrapper for short selling with protection
+ *
+ * @param client - AlpacaClient instance
+ * @param symbol - Stock symbol
+ * @param qty - Number of shares
+ * @param entryPrice - Limit price for short entry
+ * @param stopLossPrice - Stop loss trigger price (higher than entry)
+ *
+ * @example
+ * // Short GOOGL at $140 with stop at $145
+ * const result = await shortWithStopLoss(client, 'GOOGL', 10, 140.00, 145.00);
+ */
+export declare function shortWithStopLoss(client: AlpacaClient, symbol: string, qty: number, entryPrice: number, stopLossPrice: number): Promise<OTOOrderResult>;
+/**
+ * Create entry with automatic stop loss using percentage
+ * Calculates stop price based on entry price and percentage
+ *
+ * @param client - AlpacaClient instance
+ * @param symbol - Stock symbol
+ * @param qty - Number of shares
+ * @param entryPrice - Limit price for entry (null for market)
+ * @param stopLossPercent - Stop loss percentage (e.g., 5 for 5%)
+ * @param side - Order side ('buy' or 'sell')
+ *
+ * @example
+ * // Buy AAPL at $150 with 3% stop loss (stop at $145.50)
+ * const result = await entryWithPercentStopLoss(client, 'AAPL', 100, 150.00, 3, 'buy');
+ */
+export declare function entryWithPercentStopLoss(client: AlpacaClient, symbol: string, qty: number, entryPrice: number | null, stopLossPercent: number, side?: OrderSide): Promise<OTOOrderResult>;
+declare const _default: {
+    createOTOOrder: typeof createOTOOrder;
+    cancelOTOOrder: typeof cancelOTOOrder;
+    getOTOOrderStatus: typeof getOTOOrderStatus;
+    buyWithStopLoss: typeof buyWithStopLoss;
+    buyWithTrailingStop: typeof buyWithTrailingStop;
+    limitBuyWithTakeProfit: typeof limitBuyWithTakeProfit;
+    shortWithStopLoss: typeof shortWithStopLoss;
+    entryWithPercentStopLoss: typeof entryWithPercentStopLoss;
+};
+export default _default;
+//# sourceMappingURL=oto-orders.d.ts.map

package/dist/types/alpaca/trading/oto-orders.d.ts.map

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