backtest-kit 3.7.0 → 3.8.0

package/types.d.ts

@@ -1958,7 +1958,24 @@ interface ISignalRow extends ISignalDto {
         /** Percentage of position closed (0-100) */
         percent: number;
         /** Price at which this partial was executed */
-        price: number;
+        currentPrice: number;
+        /** Debug only timestamp in milliseconds */
+        debugTimestamp?: number;
+        /**
+         * Effective entry price (DCA average) at the moment this partial close was executed.
+         * Captured from GET_EFFECTIVE_PRICE_OPEN at partial close time.
+         * Used in PNL calculation when averageBuy() is called after partial closes,
+         * so each partial's profit is calculated against the correct entry price at that moment.
+         */
+        effectivePrice: number;
+        /**
+         * Entry count (number of entries in _entry history) at the moment this partial close was executed.
+         * Used to determine which entries are included in the effective price calculation for this partial close.
+         * When averageBuy() is called after partial closes, new entries are added to _entry, but they should not affect the effective price used for already executed partial closes.
+         * By capturing entryCountAtClose, we can slice the _entry array to include only the entries that were part of the position at the time of this partial close when calculating the effective price for PNL.
+         * This ensures that each partial close's PNL is calculated against the correct average entry price, even if more averaging happens after the partial close.
+         */
+        entryCountAtClose: number;
     }>;
     /**
      * Trailing stop-loss price that overrides priceStopLoss when set.
@@ -1979,6 +1996,8 @@ interface ISignalRow extends ISignalDto {
     _entry?: Array<{
         /** Price at which this entry was executed */
         price: number;
+        /** Debug only timestamp in milliseconds */
+        debugTimestamp?: number;
     }>;
     /**
      * Trailing take-profit price that overrides priceTakeProfit when set.
@@ -2568,6 +2587,57 @@ interface IStrategy {
      * @returns Promise resolving to true if strategy is stopped, false otherwise
      */
     getStopped: (symbol: string) => Promise<boolean>;
+    /**
+     * Returns how much of the position is still held, as a percentage of totalInvested.
+     *
+     * Uses dollar-basis cost-basis replay (DCA-aware).
+     * 100% means nothing was closed yet. Decreases with each partial close.
+     *
+     * Returns 100 if no pending signal or no partial closes.
+     *
+     * @param symbol - Trading pair symbol
+     * @returns Promise resolving to held percentage (0–100)
+     */
+    getTotalPercentClosed: (symbol: string) => Promise<number | null>;
+    /**
+     * Returns how many dollars of cost basis are still held (not yet closed by partials).
+     *
+     * Full position open: equals totalInvested (entries × $100).
+     * Decreases with each partial close, increases with each averageBuy().
+     *
+     * Returns totalInvested if no pending signal or no partial closes.
+     *
+     * @param symbol - Trading pair symbol
+     * @returns Promise resolving to held cost basis in dollars
+     */
+    getTotalCostClosed: (symbol: string) => Promise<number | null>;
+    /**
+     * Returns the effective (DCA-averaged) entry price for the current pending signal.
+     * Returns null if no pending signal exists.
+     */
+    getPositionAveragePrice: (symbol: string) => Promise<number | null>;
+    /**
+     * Returns the number of DCA entries for the current pending signal.
+     * 1 = original entry only. Returns null if no pending signal exists.
+     */
+    getPositionInvestedCount: (symbol: string) => Promise<number | null>;
+    /**
+     * Returns the total invested cost basis in dollars (entryCount × $100).
+     * Returns null if no pending signal exists.
+     */
+    getPositionInvestedCost: (symbol: string) => Promise<number | null>;
+    /**
+     * Returns the unrealized PNL percentage at currentPrice.
+     * Accounts for partial closes, DCA entries, slippage and fees.
+     * Returns null if no pending signal exists.
+     */
+    getPositionPnlPercent: (symbol: string, currentPrice: number) => Promise<number | null>;
+    /**
+     * Returns the unrealized PNL in dollars at currentPrice.
+     * Calculated as: pnlPercentage / 100 × totalInvestedCost.
+     * Returns null if no pending signal exists.
+     */
+    getPositionPnlCost: (symbol: string, currentPrice: number) => Promise<number | null>;
     /**
      * Fast backtest using historical candles.
      * Iterates through candles, calculates VWAP, checks TP/SL on each candle.
@@ -4210,6 +4280,202 @@ declare function commitActivateScheduled(symbol: string, activateId?: string): P
  * ```
  */
 declare function commitAverageBuy(symbol: string): Promise<boolean>;
+/**
+ * Returns the percentage of the position currently held (not closed).
+ * 100 = nothing has been closed (full position), 0 = fully closed.
+ * Correctly accounts for DCA entries between partial closes.
+ *
+ * Automatically detects backtest/live mode from execution context.
+ *
+ * @param symbol - Trading pair symbol
+ * @returns Promise<number> - held percentage (0–100)
+ *
+ * @example
+ * ```typescript
+ * import { getTotalPercentClosed } from "backtest-kit";
+ *
+ * const heldPct = await getTotalPercentClosed("BTCUSDT");
+ * console.log(`Holding ${heldPct}% of position`);
+ * ```
+ */
+declare function getTotalPercentClosed(symbol: string): Promise<number>;
+/**
+ * Returns the cost basis in dollars of the position currently held (not closed).
+ * Correctly accounts for DCA entries between partial closes.
+ *
+ * Automatically detects backtest/live mode from execution context.
+ *
+ * @param symbol - Trading pair symbol
+ * @returns Promise<number> - held cost basis in dollars
+ *
+ * @example
+ * ```typescript
+ * import { getTotalCostClosed } from "backtest-kit";
+ *
+ * const heldCost = await getTotalCostClosed("BTCUSDT");
+ * console.log(`Holding $${heldCost} of position`);
+ * ```
+ */
+declare function getTotalCostClosed(symbol: string): Promise<number>;
+/**
+ * Returns the currently active pending signal for the strategy.
+ * If no active signal exists, returns null.
+ *
+ * Automatically detects backtest/live mode from execution context.
+ *
+ * @param symbol - Trading pair symbol
+ * @returns Promise resolving to pending signal or null
+ *
+ * @example
+ * ```typescript
+ * import { getPendingSignal } from "backtest-kit";
+ *
+ * const pending = await getPendingSignal("BTCUSDT");
+ * if (pending) {
+ *   console.log("Active signal:", pending.id);
+ * }
+ * ```
+ */
+declare function getPendingSignal(symbol: string): Promise<ISignalRow>;
+/**
+ * Returns the currently active scheduled signal for the strategy.
+ * If no scheduled signal exists, returns null.
+ *
+ * Automatically detects backtest/live mode from execution context.
+ *
+ * @param symbol - Trading pair symbol
+ * @returns Promise resolving to scheduled signal or null
+ *
+ * @example
+ * ```typescript
+ * import { getScheduledSignal } from "backtest-kit";
+ *
+ * const scheduled = await getScheduledSignal("BTCUSDT");
+ * if (scheduled) {
+ *   console.log("Scheduled signal:", scheduled.id);
+ * }
+ * ```
+ */
+declare function getScheduledSignal(symbol: string): Promise<IScheduledSignalRow>;
+/**
+ * Checks if breakeven threshold has been reached for the current pending signal.
+ *
+ * Returns true if price has moved far enough in profit direction to cover
+ * transaction costs. Threshold is calculated as: (CC_PERCENT_SLIPPAGE + CC_PERCENT_FEE) * 2
+ *
+ * Automatically detects backtest/live mode from execution context.
+ *
+ * @param symbol - Trading pair symbol
+ * @param currentPrice - Current market price to check against threshold
+ * @returns Promise<boolean> - true if breakeven threshold reached, false otherwise
+ *
+ * @example
+ * ```typescript
+ * import { getBreakeven, getAveragePrice } from "backtest-kit";
+ *
+ * const price = await getAveragePrice("BTCUSDT");
+ * const canBreakeven = await getBreakeven("BTCUSDT", price);
+ * if (canBreakeven) {
+ *   console.log("Breakeven available");
+ * }
+ * ```
+ */
+declare function getBreakeven(symbol: string, currentPrice: number): Promise<boolean>;
+declare function getPositionAveragePrice(symbol: string): Promise<number | null>;
+declare function getPositionInvestedCount(symbol: string): Promise<number | null>;
+declare function getPositionInvestedCost(symbol: string): Promise<number | null>;
+declare function getPositionPnlPercent(symbol: string): Promise<number | null>;
+/**
+ * Executes partial close at profit level by absolute dollar amount (moving toward TP).
+ *
+ * Convenience wrapper around commitPartialProfit that converts a dollar amount
+ * to a percentage of the invested position cost automatically.
+ * Price must be moving toward take profit (in profit direction).
+ *
+ * Automatically detects backtest/live mode from execution context.
+ * Automatically fetches current price via getAveragePrice.
+ *
+ * @param symbol - Trading pair symbol
+ * @param dollarAmount - Dollar value of position to close (e.g. 150 closes $150 worth)
+ * @returns Promise<boolean> - true if partial close executed, false if skipped or no position
+ *
+ * @throws Error if currentPrice is not in profit direction:
+ *   - LONG: currentPrice must be > priceOpen
+ *   - SHORT: currentPrice must be < priceOpen
+ *
+ * @example
+ * ```typescript
+ * import { commitPartialProfitCost } from "backtest-kit";
+ *
+ * // Close $150 of a $300 position (50%) at profit
+ * const success = await commitPartialProfitCost("BTCUSDT", 150);
+ * if (success) {
+ *   console.log('Partial profit executed');
+ * }
+ * ```
+ */
+declare function commitPartialProfitCost(symbol: string, dollarAmount: number): Promise<boolean>;
+/**
+ * Executes partial close at loss level by absolute dollar amount (moving toward SL).
+ *
+ * Convenience wrapper around commitPartialLoss that converts a dollar amount
+ * to a percentage of the invested position cost automatically.
+ * Price must be moving toward stop loss (in loss direction).
+ *
+ * Automatically detects backtest/live mode from execution context.
+ * Automatically fetches current price via getAveragePrice.
+ *
+ * @param symbol - Trading pair symbol
+ * @param dollarAmount - Dollar value of position to close (e.g. 100 closes $100 worth)
+ * @returns Promise<boolean> - true if partial close executed, false if skipped or no position
+ *
+ * @throws Error if currentPrice is not in loss direction:
+ *   - LONG: currentPrice must be < priceOpen
+ *   - SHORT: currentPrice must be > priceOpen
+ *
+ * @example
+ * ```typescript
+ * import { commitPartialLossCost } from "backtest-kit";
+ *
+ * // Close $100 of a $300 position (~33%) at loss
+ * const success = await commitPartialLossCost("BTCUSDT", 100);
+ * if (success) {
+ *   console.log('Partial loss executed');
+ * }
+ * ```
+ */
+declare function commitPartialLossCost(symbol: string, dollarAmount: number): Promise<boolean>;
+declare function getPositionPnlCost(symbol: string): Promise<number | null>;
+/**
+ * Returns the list of DCA entry prices for the current pending signal.
+ *
+ * The first element is always the original priceOpen (initial entry).
+ * Each subsequent element is a price added by commitAverageBuy().
+ *
+ * Returns null if no pending signal exists.
+ * Returns a single-element array [priceOpen] if no DCA entries were made.
+ *
+ * @param symbol - Trading pair symbol
+ * @returns Promise resolving to array of entry prices or null
+ *
+ * @example
+ * ```typescript
+ * import { getPositionLevels } from "backtest-kit";
+ *
+ * const levels = await getPositionLevels("BTCUSDT");
+ * // No DCA: [43000]
+ * // One DCA: [43000, 42000]
+ * ```
+ */
+declare function getPositionLevels(symbol: string): Promise<number[] | null>;
+declare function getPositionPartials(symbol: string): Promise<{
+    type: "profit" | "loss";
+    percent: number;
+    currentPrice: number;
+    effectivePrice: number;
+    entryCountAtClose: number;
+    debugTimestamp?: number;
+}[]>;
 
 /**
  * Stops the strategy from generating new signals.
@@ -4483,6 +4749,14 @@ declare const GLOBAL_CONFIG: {
      * Default: true (mutex locking enabled for candle fetching)
      */
     CC_ENABLE_CANDLE_FETCH_MUTEX: boolean;
+    /**
+     * Enables DCA (Dollar-Cost Averaging) logic even if antirecord is not broken.
+     * Allows to commitAverageBuy if currentPrice is not the lowest price since entry, but still lower than priceOpen.
+     * This can help improve average entry price in cases where price has rebounded after entry but is still below priceOpen, without waiting for a new lower price.
+     *
+     * Default: true (DCA logic enabled everywhere, not just when antirecord is broken)
+     */
+    CC_ENABLE_DCA_EVERYWHERE: boolean;
 };
 /**
  * Type for global configuration object.
@@ -4594,6 +4868,7 @@ declare function getConfig(): {
     CC_MAX_SIGNALS: number;
     CC_MAX_LOG_LINES: number;
     CC_ENABLE_CANDLE_FETCH_MUTEX: boolean;
+    CC_ENABLE_DCA_EVERYWHERE: boolean;
 };
 /**
  * Retrieves the default configuration object for the framework.
@@ -4633,6 +4908,7 @@ declare function getDefaultConfig(): Readonly<{
     CC_MAX_SIGNALS: number;
     CC_MAX_LOG_LINES: number;
     CC_ENABLE_CANDLE_FETCH_MUTEX: boolean;
+    CC_ENABLE_DCA_EVERYWHERE: boolean;
 }>;
 /**
  * Sets custom column configurations for markdown report generation.
@@ -10382,6 +10658,45 @@ declare class BacktestUtils {
         exchangeName: ExchangeName;
         frameName: FrameName;
     }) => Promise<ISignalRow>;
+    /**
+     * Returns the percentage of the position currently held (not closed).
+     * 100 = nothing has been closed (full position), 0 = fully closed.
+     * Correctly accounts for DCA entries between partial closes.
+     *
+     * @param symbol - Trading pair symbol
+     * @param context - Context with strategyName, exchangeName, frameName
+     * @returns Promise<number> - held percentage (0–100)
+     *
+     * @example
+     * ```typescript
+     * const heldPct = await Backtest.getTotalPercentClosed("BTCUSDT", { strategyName, exchangeName, frameName });
+     * console.log(`Holding ${heldPct}% of position`);
+     * ```
+     */
+    getTotalPercentClosed: (symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<number>;
+    /**
+     * Returns the cost basis in dollars of the position currently held (not closed).
+     * Correctly accounts for DCA entries between partial closes.
+     *
+     * @param symbol - Trading pair symbol
+     * @param context - Context with strategyName, exchangeName, frameName
+     * @returns Promise<number> - held cost basis in dollars
+     *
+     * @example
+     * ```typescript
+     * const heldCost = await Backtest.getTotalCostClosed("BTCUSDT", { strategyName, exchangeName, frameName });
+     * console.log(`Holding $${heldCost} of position`);
+     * ```
+     */
+    getTotalCostClosed: (symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<number>;
     /**
      * Retrieves the currently active scheduled signal for the strategy.
      * If no scheduled signal exists, returns null.
@@ -10432,6 +10747,48 @@ declare class BacktestUtils {
         exchangeName: ExchangeName;
         frameName: FrameName;
     }) => Promise<boolean>;
+    getPositionAveragePrice: (symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<number | null>;
+    getPositionInvestedCount: (symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<number | null>;
+    getPositionInvestedCost: (symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<number | null>;
+    getPositionPnlPercent: (symbol: string, currentPrice: number, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<number | null>;
+    getPositionPnlCost: (symbol: string, currentPrice: number, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<number | null>;
+    getPositionLevels: (symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<number[] | null>;
+    getPositionPartials: (symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<{
+        type: "profit" | "loss";
+        percent: number;
+        currentPrice: number;
+        effectivePrice: number;
+        entryCountAtClose: number;
+        debugTimestamp?: number;
+    }[]>;
     /**
      * Stops the strategy from generating new signals.
      *
@@ -10582,6 +10939,76 @@ declare class BacktestUtils {
         exchangeName: ExchangeName;
         frameName: FrameName;
     }) => Promise<boolean>;
+    /**
+     * Executes partial close at profit level by absolute dollar amount (moving toward TP).
+     *
+     * Convenience wrapper around commitPartialProfit that converts a dollar amount
+     * to a percentage of the invested position cost automatically.
+     * Price must be moving toward take profit (in profit direction).
+     *
+     * @param symbol - Trading pair symbol
+     * @param dollarAmount - Dollar value of position to close (e.g. 150 closes $150 worth)
+     * @param currentPrice - Current market price for this partial close
+     * @param context - Execution context with strategyName, exchangeName, and frameName
+     * @returns Promise<boolean> - true if partial close executed, false if skipped or no position
+     *
+     * @throws Error if currentPrice is not in profit direction:
+     *   - LONG: currentPrice must be > priceOpen
+     *   - SHORT: currentPrice must be < priceOpen
+     *
+     * @example
+     * ```typescript
+     * // Close $150 of a $300 position (50%) at profit
+     * const success = await Backtest.commitPartialProfitCost("BTCUSDT", 150, 45000, {
+     *   exchangeName: "binance",
+     *   frameName: "frame1",
+     *   strategyName: "my-strategy"
+     * });
+     * if (success) {
+     *   console.log('Partial profit executed');
+     * }
+     * ```
+     */
+    commitPartialProfitCost: (symbol: string, dollarAmount: number, currentPrice: number, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<boolean>;
+    /**
+     * Executes partial close at loss level by absolute dollar amount (moving toward SL).
+     *
+     * Convenience wrapper around commitPartialLoss that converts a dollar amount
+     * to a percentage of the invested position cost automatically.
+     * Price must be moving toward stop loss (in loss direction).
+     *
+     * @param symbol - Trading pair symbol
+     * @param dollarAmount - Dollar value of position to close (e.g. 100 closes $100 worth)
+     * @param currentPrice - Current market price for this partial close
+     * @param context - Execution context with strategyName, exchangeName, and frameName
+     * @returns Promise<boolean> - true if partial close executed, false if skipped or no position
+     *
+     * @throws Error if currentPrice is not in loss direction:
+     *   - LONG: currentPrice must be < priceOpen
+     *   - SHORT: currentPrice must be > priceOpen
+     *
+     * @example
+     * ```typescript
+     * // Close $100 of a $300 position (~33%) at loss
+     * const success = await Backtest.commitPartialLossCost("BTCUSDT", 100, 38000, {
+     *   exchangeName: "binance",
+     *   frameName: "frame1",
+     *   strategyName: "my-strategy"
+     * });
+     * if (success) {
+     *   console.log('Partial loss executed');
+     * }
+     * ```
+     */
+    commitPartialLossCost: (symbol: string, dollarAmount: number, currentPrice: number, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<boolean>;
     /**
      * Adjusts the trailing stop-loss distance for an active pending signal.
      *
@@ -11186,6 +11613,43 @@ declare class LiveUtils {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
     }) => Promise<ISignalRow>;
+    /**
+     * Returns the percentage of the position currently held (not closed).
+     * 100 = nothing has been closed (full position), 0 = fully closed.
+     * Correctly accounts for DCA entries between partial closes.
+     *
+     * @param symbol - Trading pair symbol
+     * @param context - Context with strategyName and exchangeName
+     * @returns Promise<number> - held percentage (0–100)
+     *
+     * @example
+     * ```typescript
+     * const heldPct = await Live.getTotalPercentClosed("BTCUSDT", { strategyName, exchangeName });
+     * console.log(`Holding ${heldPct}% of position`);
+     * ```
+     */
+    getTotalPercentClosed: (symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+    }) => Promise<number>;
+    /**
+     * Returns the cost basis in dollars of the position currently held (not closed).
+     * Correctly accounts for DCA entries between partial closes.
+     *
+     * @param symbol - Trading pair symbol
+     * @param context - Context with strategyName and exchangeName
+     * @returns Promise<number> - held cost basis in dollars
+     *
+     * @example
+     * ```typescript
+     * const heldCost = await Live.getTotalCostClosed("BTCUSDT", { strategyName, exchangeName });
+     * console.log(`Holding $${heldCost} of position`);
+     * ```
+     */
+    getTotalCostClosed: (symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+    }) => Promise<number>;
     /**
      * Retrieves the currently active scheduled signal for the strategy.
      * If no scheduled signal exists, returns null.
@@ -11233,6 +11697,41 @@ declare class LiveUtils {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
     }) => Promise<boolean>;
+    getPositionAveragePrice: (symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+    }) => Promise<number | null>;
+    getPositionInvestedCount: (symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+    }) => Promise<number | null>;
+    getPositionInvestedCost: (symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+    }) => Promise<number | null>;
+    getPositionPnlPercent: (symbol: string, currentPrice: number, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+    }) => Promise<number | null>;
+    getPositionPnlCost: (symbol: string, currentPrice: number, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+    }) => Promise<number | null>;
+    getPositionLevels: (symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+    }) => Promise<number[] | null>;
+    getPositionPartials: (symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+    }) => Promise<{
+        type: "profit" | "loss";
+        percent: number;
+        currentPrice: number;
+        effectivePrice: number;
+        entryCountAtClose: number;
+        debugTimestamp?: number;
+    }[]>;
     /**
      * Stops the strategy from generating new signals.
      *
@@ -11370,6 +11869,72 @@ declare class LiveUtils {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
     }) => Promise<boolean>;
+    /**
+     * Executes partial close at profit level by absolute dollar amount (moving toward TP).
+     *
+     * Convenience wrapper around commitPartialProfit that converts a dollar amount
+     * to a percentage of the invested position cost automatically.
+     * Price must be moving toward take profit (in profit direction).
+     *
+     * @param symbol - Trading pair symbol
+     * @param dollarAmount - Dollar value of position to close (e.g. 150 closes $150 worth)
+     * @param currentPrice - Current market price for this partial close
+     * @param context - Execution context with strategyName and exchangeName
+     * @returns Promise<boolean> - true if partial close executed, false if skipped or no position
+     *
+     * @throws Error if currentPrice is not in profit direction:
+     *   - LONG: currentPrice must be > priceOpen
+     *   - SHORT: currentPrice must be < priceOpen
+     *
+     * @example
+     * ```typescript
+     * // Close $150 of a $300 position (50%) at profit
+     * const success = await Live.commitPartialProfitCost("BTCUSDT", 150, 45000, {
+     *   exchangeName: "binance",
+     *   strategyName: "my-strategy"
+     * });
+     * if (success) {
+     *   console.log('Partial profit executed');
+     * }
+     * ```
+     */
+    commitPartialProfitCost: (symbol: string, dollarAmount: number, currentPrice: number, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+    }) => Promise<boolean>;
+    /**
+     * Executes partial close at loss level by absolute dollar amount (moving toward SL).
+     *
+     * Convenience wrapper around commitPartialLoss that converts a dollar amount
+     * to a percentage of the invested position cost automatically.
+     * Price must be moving toward stop loss (in loss direction).
+     *
+     * @param symbol - Trading pair symbol
+     * @param dollarAmount - Dollar value of position to close (e.g. 100 closes $100 worth)
+     * @param currentPrice - Current market price for this partial close
+     * @param context - Execution context with strategyName and exchangeName
+     * @returns Promise<boolean> - true if partial close executed, false if skipped or no position
+     *
+     * @throws Error if currentPrice is not in loss direction:
+     *   - LONG: currentPrice must be < priceOpen
+     *   - SHORT: currentPrice must be > priceOpen
+     *
+     * @example
+     * ```typescript
+     * // Close $100 of a $300 position (~33%) at loss
+     * const success = await Live.commitPartialLossCost("BTCUSDT", 100, 38000, {
+     *   exchangeName: "binance",
+     *   strategyName: "my-strategy"
+     * });
+     * if (success) {
+     *   console.log('Partial loss executed');
+     * }
+     * ```
+     */
+    commitPartialLossCost: (symbol: string, dollarAmount: number, currentPrice: number, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+    }) => Promise<boolean>;
     /**
      * Adjusts the trailing stop-loss distance for an active pending signal.
      *
@@ -15317,6 +15882,77 @@ declare class StrategyCoreService implements TStrategy$1 {
         exchangeName: ExchangeName;
         frameName: FrameName;
     }) => Promise<ISignalRow | null>;
+    /**
+     * Returns the percentage of the position currently held (not closed).
+     * 100 = nothing has been closed (full position), 0 = fully closed.
+     * Correctly accounts for DCA entries between partial closes.
+     *
+     * @param backtest - Whether running in backtest mode
+     * @param symbol - Trading pair symbol
+     * @param context - Execution context with strategyName, exchangeName, frameName
+     * @returns Promise<number> - held percentage (0–100)
+     */
+    getTotalPercentClosed: (backtest: boolean, symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<number | null>;
+    /**
+     * Returns the cost basis in dollars of the position currently held (not closed).
+     * Correctly accounts for DCA entries between partial closes.
+     *
+     * @param backtest - Whether running in backtest mode
+     * @param symbol - Trading pair symbol
+     * @param context - Execution context with strategyName, exchangeName, frameName
+     * @returns Promise<number> - held cost basis in dollars
+     */
+    getTotalCostClosed: (backtest: boolean, symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<number | null>;
+    getPositionAveragePrice: (backtest: boolean, symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<number | null>;
+    getPositionInvestedCount: (backtest: boolean, symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<number | null>;
+    getPositionInvestedCost: (backtest: boolean, symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<number | null>;
+    getPositionPnlPercent: (backtest: boolean, symbol: string, currentPrice: number, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<number | null>;
+    getPositionPnlCost: (backtest: boolean, symbol: string, currentPrice: number, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<number | null>;
+    getPositionLevels: (backtest: boolean, symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<number[] | null>;
+    getPositionPartials: (backtest: boolean, symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<{
+        type: "profit" | "loss";
+        percent: number;
+        currentPrice: number;
+        effectivePrice: number;
+        entryCountAtClose: number;
+        debugTimestamp?: number;
+    }[]>;
     /**
      * Retrieves the currently active scheduled signal for the symbol.
      * If no scheduled signal exists, returns null.
@@ -17132,6 +17768,36 @@ declare const get: (object: any, path: any) => any;
  */
 declare const set: (object: any, path: any, value: any) => boolean;
 
+/**
+ * Calculate the percentage difference between two numbers.
+ * @param {number} a - The first number.
+ * @param {number} b - The second number.
+ * @returns {number} The percentage difference between the two numbers.
+ */
+declare const percentDiff: (a?: number, b?: number) => number;
+
+/**
+ * Calculate the percentage change from yesterday's value to today's value.
+ * @param {number} yesterdayValue - The value from yesterday.
+ * @param {number} todayValue - The value from today.
+ * @returns {number} The percentage change from yesterday to today.
+ */
+declare const percentValue: (yesterdayValue: number, todayValue: number) => number;
+
+/**
+ * Convert an absolute dollar amount to a percentage of the invested position cost.
+ * Use the result as the `percent` argument to `commitPartialProfit` / `commitPartialLoss`.
+ *
+ * @param dollarAmount - Dollar value to close (e.g. 150)
+ * @param investedCost - Total invested cost from `getPositionInvestedCost` (e.g. 300)
+ * @returns Percentage of the position to close (0–100)
+ *
+ * @example
+ * const percent = investedCostToPercent(150, 300); // 50
+ * await commitPartialProfit("BTCUSDT", percent);
+ */
+declare const investedCostToPercent: (dollarAmount: number, investedCost: number) => number;
+
 /**
  * Client implementation for exchange data access.
  *
@@ -18170,6 +18836,77 @@ declare class StrategyConnectionService implements TStrategy {
         exchangeName: ExchangeName;
         frameName: FrameName;
     }) => Promise<ISignalRow | null>;
+    /**
+     * Returns the percentage of the position currently held (not closed).
+     * 100 = nothing has been closed (full position), 0 = fully closed.
+     * Correctly accounts for DCA entries between partial closes.
+     *
+     * @param backtest - Whether running in backtest mode
+     * @param symbol - Trading pair symbol
+     * @param context - Execution context with strategyName, exchangeName, frameName
+     * @returns Promise<number> - held percentage (0–100)
+     */
+    getTotalPercentClosed: (backtest: boolean, symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<number | null>;
+    /**
+     * Returns the cost basis in dollars of the position currently held (not closed).
+     * Correctly accounts for DCA entries between partial closes.
+     *
+     * @param backtest - Whether running in backtest mode
+     * @param symbol - Trading pair symbol
+     * @param context - Execution context with strategyName, exchangeName, frameName
+     * @returns Promise<number> - held cost basis in dollars
+     */
+    getTotalCostClosed: (backtest: boolean, symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<number | null>;
+    getPositionAveragePrice: (backtest: boolean, symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<number | null>;
+    getPositionInvestedCount: (backtest: boolean, symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<number | null>;
+    getPositionInvestedCost: (backtest: boolean, symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<number | null>;
+    getPositionPnlPercent: (backtest: boolean, symbol: string, currentPrice: number, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<number | null>;
+    getPositionPnlCost: (backtest: boolean, symbol: string, currentPrice: number, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<number | null>;
+    getPositionLevels: (backtest: boolean, symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<number[] | null>;
+    getPositionPartials: (backtest: boolean, symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<{
+        type: "profit" | "loss";
+        percent: number;
+        currentPrice: number;
+        effectivePrice: number;
+        entryCountAtClose: number;
+        debugTimestamp?: number;
+    }[]>;
     /**
      * Retrieves the currently active scheduled signal for the strategy.
      * If no scheduled signal exists, returns null.
@@ -21754,4 +22491,75 @@ declare const backtest: {
     loggerService: LoggerService;
 };
 
-export { ActionBase, type ActivateScheduledCommit, type ActivateScheduledCommitNotification, type ActivePingContract, type AverageBuyCommit, Backtest, type BacktestStatisticsModel, Breakeven, type BreakevenAvailableNotification, type BreakevenCommit, type BreakevenCommitNotification, type BreakevenContract, type BreakevenData, Cache, type CancelScheduledCommit, type CandleData, type CandleInterval, type ClosePendingCommit, type ColumnConfig, type ColumnModel, Constant, type CriticalErrorNotification, type DoneContract, type EntityId, Exchange, ExecutionContextService, type FrameInterval, type GlobalConfig, Heat, type HeatmapStatisticsModel, type IActionSchema, type IActivateScheduledCommitRow, type IAggregatedTradeData, type IBidData, type IBreakevenCommitRow, type ICandleData, type ICommitRow, type IExchangeSchema, type IFrameSchema, type IHeatmapRow, type ILog, type ILogEntry, type ILogger, type IMarkdownDumpOptions, type INotificationUtils, type IOrderBookData, type IPartialLossCommitRow, type IPartialProfitCommitRow, type IPersistBase, type IPositionSizeATRParams, type IPositionSizeFixedPercentageParams, type IPositionSizeKellyParams, type IPublicAction, type IPublicCandleData, type IPublicSignalRow, type IReportDumpOptions, type IRiskActivePosition, type IRiskCheckArgs, type IRiskSchema, type IRiskSignalRow, type IRiskValidation, type IRiskValidationFn, type IRiskValidationPayload, type IScheduledSignalCancelRow, type IScheduledSignalRow, type ISignalDto, type ISignalRow, type ISizingCalculateParams, type ISizingCalculateParamsATR, type ISizingCalculateParamsFixedPercentage, type ISizingCalculateParamsKelly, type ISizingParams, type ISizingParamsATR, type ISizingParamsFixedPercentage, type ISizingParamsKelly, type ISizingSchema, type ISizingSchemaATR, type ISizingSchemaFixedPercentage, type ISizingSchemaKelly, type IStorageSignalRow, type IStorageUtils, type IStrategyPnL, type IStrategyResult, type IStrategySchema, type IStrategyTickResult, type IStrategyTickResultActive, type IStrategyTickResultCancelled, type IStrategyTickResultClosed, type IStrategyTickResultIdle, type IStrategyTickResultOpened, type IStrategyTickResultScheduled, type IStrategyTickResultWaiting, type ITrailingStopCommitRow, type ITrailingTakeCommitRow, type IWalkerResults, type IWalkerSchema, type IWalkerStrategyResult, type InfoErrorNotification, Live, type LiveStatisticsModel, Log, type LogData, Markdown, MarkdownFileBase, MarkdownFolderBase, type MarkdownName, type MeasureData, MethodContextService, type MetricStats, Notification, NotificationBacktest, type NotificationData, NotificationLive, type NotificationModel, Partial$1 as Partial, type PartialData, type PartialEvent, type PartialLossAvailableNotification, type PartialLossCommit, type PartialLossCommitNotification, type PartialLossContract, type PartialProfitAvailableNotification, type PartialProfitCommit, type PartialProfitCommitNotification, type PartialProfitContract, type PartialStatisticsModel, Performance, type PerformanceContract, type PerformanceMetricType, type PerformanceStatisticsModel, PersistBase, PersistBreakevenAdapter, PersistCandleAdapter, PersistLogAdapter, PersistMeasureAdapter, PersistNotificationAdapter, PersistPartialAdapter, PersistRiskAdapter, PersistScheduleAdapter, PersistSignalAdapter, PersistStorageAdapter, PositionSize, type ProgressBacktestContract, type ProgressWalkerContract, Report, ReportBase, type ReportName, Risk, type RiskContract, type RiskData, type RiskEvent, type RiskRejectionNotification, type RiskStatisticsModel, Schedule, type ScheduleData, type SchedulePingContract, type ScheduleStatisticsModel, type ScheduledEvent, type SignalCancelledNotification, type SignalClosedNotification, type SignalData, type SignalInterval, type SignalOpenedNotification, type SignalScheduledNotification, Storage, StorageBacktest, type StorageData, StorageLive, Strategy, type StrategyActionType, type StrategyCancelReason, type StrategyCloseReason, type StrategyCommitContract, type StrategyEvent, type StrategyStatisticsModel, type TLogCtor, type TMarkdownBase, type TNotificationUtilsCtor, type TPersistBase, type TPersistBaseCtor, type TReportBase, type TStorageUtilsCtor, type TickEvent, type TrailingStopCommit, type TrailingStopCommitNotification, type TrailingTakeCommit, type TrailingTakeCommitNotification, type ValidationErrorNotification, Walker, type WalkerCompleteContract, type WalkerContract, type WalkerMetric, type SignalData$1 as WalkerSignalData, type WalkerStatisticsModel, addActionSchema, addExchangeSchema, addFrameSchema, addRiskSchema, addSizingSchema, addStrategySchema, addWalkerSchema, alignToInterval, checkCandles, commitActivateScheduled, commitAverageBuy, commitBreakeven, commitCancelScheduled, commitClosePending, commitPartialLoss, commitPartialProfit, commitTrailingStop, commitTrailingTake, dumpMessages, emitters, formatPrice, formatQuantity, get, getActionSchema, getAggregatedTrades, getAveragePrice, getBacktestTimeframe, getCandles, getColumns, getConfig, getContext, getDate, getDefaultColumns, getDefaultConfig, getExchangeSchema, getFrameSchema, getMode, getNextCandles, getOrderBook, getRawCandles, getRiskSchema, getSizingSchema, getStrategySchema, getSymbol, getTimestamp, getWalkerSchema, hasTradeContext, backtest as lib, listExchangeSchema, listFrameSchema, listRiskSchema, listSizingSchema, listStrategySchema, listWalkerSchema, listenActivePing, listenActivePingOnce, listenBacktestProgress, listenBreakevenAvailable, listenBreakevenAvailableOnce, listenDoneBacktest, listenDoneBacktestOnce, listenDoneLive, listenDoneLiveOnce, listenDoneWalker, listenDoneWalkerOnce, listenError, listenExit, listenPartialLossAvailable, listenPartialLossAvailableOnce, listenPartialProfitAvailable, listenPartialProfitAvailableOnce, listenPerformance, listenRisk, listenRiskOnce, listenSchedulePing, listenSchedulePingOnce, listenSignal, listenSignalBacktest, listenSignalBacktestOnce, listenSignalLive, listenSignalLiveOnce, listenSignalOnce, listenStrategyCommit, listenStrategyCommitOnce, listenValidation, listenWalker, listenWalkerComplete, listenWalkerOnce, listenWalkerProgress, overrideActionSchema, overrideExchangeSchema, overrideFrameSchema, overrideRiskSchema, overrideSizingSchema, overrideStrategySchema, overrideWalkerSchema, parseArgs, roundTicks, set, setColumns, setConfig, setLogger, shutdown, stopStrategy, validate, waitForCandle, warmCandles };
+/**
+ * Calculates profit/loss for a closed signal with slippage and fees.
+ *
+ * For signals with partial closes:
+ * - Weights are calculated by ACTUAL DOLLAR VALUE of each partial relative to total invested.
+ *   This correctly handles DCA entries that occur before or after partial closes.
+ *
+ * Cost basis is reconstructed by replaying the partial sequence via entryCountAtClose + percent:
+ *   costBasis = 0
+ *   for each partial[i]:
+ *     costBasis += (entryCountAtClose[i] - entryCountAtClose[i-1]) × $100
+ *     partialDollarValue[i] = (percent[i] / 100) × costBasis
+ *     weight[i]             = partialDollarValue[i] / totalInvested
+ *     costBasis            *= (1 - percent[i] / 100)
+ *
+ * Fee structure:
+ *   - Open fee:  CC_PERCENT_FEE (charged once)
+ *   - Close fee: CC_PERCENT_FEE × weight × (closeWithSlip / openWithSlip) per partial/remaining
+ *
+ * @param signal - Closed signal with position details and optional partial history
+ * @param priceClose - Actual close price at final exit
+ * @returns PNL data with percentage and prices
+ */
+declare const toProfitLossDto: (signal: ISignalRow, priceClose: number) => IStrategyPnL;
+
+/**
+ * Returns the effective entry price for price calculations.
+ *
+ * Uses harmonic mean (correct for fixed-dollar DCA: $100 per entry).
+ *
+ * When partial closes exist, replays the partial sequence to reconstruct
+ * the running cost basis at each partial — no extra stored fields needed.
+ *
+ * Cost basis replay:
+ *   costBasis starts at 0
+ *   for each partial[i]:
+ *     newEntries = entryCountAtClose[i] - entryCountAtClose[i-1]  (or entryCountAtClose[0] for i=0)
+ *     costBasis += newEntries × $100          ← add DCA entries up to this partial
+ *     positionCostBasisAtClose[i] = costBasis ← snapshot BEFORE close
+ *     costBasis × = (1 - percent[i] / 100)    ← reduce after close
+ *
+ * @param signal - Signal row
+ * @returns Effective entry price for PNL calculations
+ */
+declare const getEffectivePriceOpen: (signal: ISignalRow) => number;
+
+/**
+ * Returns the total closed state of a position using cost-basis replay.
+ *
+ * Correctly accounts for DCA entries added between partial closes via averageBuy().
+ * Simple percent summation (sum of _partial[i].percent) is INCORRECT when averageBuy()
+ * is called between partials — this function uses the same cost-basis replay as
+ * toProfitLossDto to compute the true dollar-weighted closed fraction.
+ *
+ * Cost-basis replay:
+ *   costBasis = 0
+ *   for each partial[i]:
+ *     costBasis += (entryCountAtClose[i] - entryCountAtClose[i-1]) × $100
+ *     closedDollar += (percent[i] / 100) × costBasis
+ *     costBasis ×= (1 - percent[i] / 100)
+ *   // then add entries added AFTER the last partial
+ *   costBasis += (currentEntryCount - lastPartialEntryCount) × $100
+ *
+ * @param signal - Signal row with _partial and _entry arrays
+ * @returns Object with totalClosedPercent (0–100+) and remainingCostBasis (dollar value still open)
+ */
+declare const getTotalClosed: (signal: ISignalRow) => {
+    totalClosedPercent: number;
+    remainingCostBasis: number;
+};
+
+export { ActionBase, type ActivateScheduledCommit, type ActivateScheduledCommitNotification, type ActivePingContract, type AverageBuyCommit, Backtest, type BacktestStatisticsModel, Breakeven, type BreakevenAvailableNotification, type BreakevenCommit, type BreakevenCommitNotification, type BreakevenContract, type BreakevenData, Cache, type CancelScheduledCommit, type CandleData, type CandleInterval, type ClosePendingCommit, type ColumnConfig, type ColumnModel, Constant, type CriticalErrorNotification, type DoneContract, type EntityId, Exchange, ExecutionContextService, type FrameInterval, type GlobalConfig, Heat, type HeatmapStatisticsModel, type IActionSchema, type IActivateScheduledCommitRow, type IAggregatedTradeData, type IBidData, type IBreakevenCommitRow, type ICandleData, type ICommitRow, type IExchangeSchema, type IFrameSchema, type IHeatmapRow, type ILog, type ILogEntry, type ILogger, type IMarkdownDumpOptions, type INotificationUtils, type IOrderBookData, type IPartialLossCommitRow, type IPartialProfitCommitRow, type IPersistBase, type IPositionSizeATRParams, type IPositionSizeFixedPercentageParams, type IPositionSizeKellyParams, type IPublicAction, type IPublicCandleData, type IPublicSignalRow, type IReportDumpOptions, type IRiskActivePosition, type IRiskCheckArgs, type IRiskSchema, type IRiskSignalRow, type IRiskValidation, type IRiskValidationFn, type IRiskValidationPayload, type IScheduledSignalCancelRow, type IScheduledSignalRow, type ISignalDto, type ISignalRow, type ISizingCalculateParams, type ISizingCalculateParamsATR, type ISizingCalculateParamsFixedPercentage, type ISizingCalculateParamsKelly, type ISizingParams, type ISizingParamsATR, type ISizingParamsFixedPercentage, type ISizingParamsKelly, type ISizingSchema, type ISizingSchemaATR, type ISizingSchemaFixedPercentage, type ISizingSchemaKelly, type IStorageSignalRow, type IStorageUtils, type IStrategyPnL, type IStrategyResult, type IStrategySchema, type IStrategyTickResult, type IStrategyTickResultActive, type IStrategyTickResultCancelled, type IStrategyTickResultClosed, type IStrategyTickResultIdle, type IStrategyTickResultOpened, type IStrategyTickResultScheduled, type IStrategyTickResultWaiting, type ITrailingStopCommitRow, type ITrailingTakeCommitRow, type IWalkerResults, type IWalkerSchema, type IWalkerStrategyResult, type InfoErrorNotification, Live, type LiveStatisticsModel, Log, type LogData, Markdown, MarkdownFileBase, MarkdownFolderBase, type MarkdownName, type MeasureData, MethodContextService, type MetricStats, Notification, NotificationBacktest, type NotificationData, NotificationLive, type NotificationModel, Partial$1 as Partial, type PartialData, type PartialEvent, type PartialLossAvailableNotification, type PartialLossCommit, type PartialLossCommitNotification, type PartialLossContract, type PartialProfitAvailableNotification, type PartialProfitCommit, type PartialProfitCommitNotification, type PartialProfitContract, type PartialStatisticsModel, Performance, type PerformanceContract, type PerformanceMetricType, type PerformanceStatisticsModel, PersistBase, PersistBreakevenAdapter, PersistCandleAdapter, PersistLogAdapter, PersistMeasureAdapter, PersistNotificationAdapter, PersistPartialAdapter, PersistRiskAdapter, PersistScheduleAdapter, PersistSignalAdapter, PersistStorageAdapter, PositionSize, type ProgressBacktestContract, type ProgressWalkerContract, Report, ReportBase, type ReportName, Risk, type RiskContract, type RiskData, type RiskEvent, type RiskRejectionNotification, type RiskStatisticsModel, Schedule, type ScheduleData, type SchedulePingContract, type ScheduleStatisticsModel, type ScheduledEvent, type SignalCancelledNotification, type SignalClosedNotification, type SignalData, type SignalInterval, type SignalOpenedNotification, type SignalScheduledNotification, Storage, StorageBacktest, type StorageData, StorageLive, Strategy, type StrategyActionType, type StrategyCancelReason, type StrategyCloseReason, type StrategyCommitContract, type StrategyEvent, type StrategyStatisticsModel, type TLogCtor, type TMarkdownBase, type TNotificationUtilsCtor, type TPersistBase, type TPersistBaseCtor, type TReportBase, type TStorageUtilsCtor, type TickEvent, type TrailingStopCommit, type TrailingStopCommitNotification, type TrailingTakeCommit, type TrailingTakeCommitNotification, type ValidationErrorNotification, Walker, type WalkerCompleteContract, type WalkerContract, type WalkerMetric, type SignalData$1 as WalkerSignalData, type WalkerStatisticsModel, addActionSchema, addExchangeSchema, addFrameSchema, addRiskSchema, addSizingSchema, addStrategySchema, addWalkerSchema, alignToInterval, checkCandles, commitActivateScheduled, commitAverageBuy, commitBreakeven, commitCancelScheduled, commitClosePending, commitPartialLoss, commitPartialLossCost, commitPartialProfit, commitPartialProfitCost, commitTrailingStop, commitTrailingTake, dumpMessages, emitters, formatPrice, formatQuantity, get, getActionSchema, getAggregatedTrades, getAveragePrice, getBacktestTimeframe, getBreakeven, getCandles, getColumns, getConfig, getContext, getDate, getDefaultColumns, getDefaultConfig, getEffectivePriceOpen, getExchangeSchema, getFrameSchema, getMode, getNextCandles, getOrderBook, getPendingSignal, getPositionAveragePrice, getPositionInvestedCost, getPositionInvestedCount, getPositionLevels, getPositionPartials, getPositionPnlCost, getPositionPnlPercent, getRawCandles, getRiskSchema, getScheduledSignal, getSizingSchema, getStrategySchema, getSymbol, getTimestamp, getTotalClosed, getTotalCostClosed, getTotalPercentClosed, getWalkerSchema, hasTradeContext, investedCostToPercent, backtest as lib, listExchangeSchema, listFrameSchema, listRiskSchema, listSizingSchema, listStrategySchema, listWalkerSchema, listenActivePing, listenActivePingOnce, listenBacktestProgress, listenBreakevenAvailable, listenBreakevenAvailableOnce, listenDoneBacktest, listenDoneBacktestOnce, listenDoneLive, listenDoneLiveOnce, listenDoneWalker, listenDoneWalkerOnce, listenError, listenExit, listenPartialLossAvailable, listenPartialLossAvailableOnce, listenPartialProfitAvailable, listenPartialProfitAvailableOnce, listenPerformance, listenRisk, listenRiskOnce, listenSchedulePing, listenSchedulePingOnce, listenSignal, listenSignalBacktest, listenSignalBacktestOnce, listenSignalLive, listenSignalLiveOnce, listenSignalOnce, listenStrategyCommit, listenStrategyCommitOnce, listenValidation, listenWalker, listenWalkerComplete, listenWalkerOnce, listenWalkerProgress, overrideActionSchema, overrideExchangeSchema, overrideFrameSchema, overrideRiskSchema, overrideSizingSchema, overrideStrategySchema, overrideWalkerSchema, parseArgs, percentDiff, percentValue, roundTicks, set, setColumns, setConfig, setLogger, shutdown, stopStrategy, toProfitLossDto, validate, waitForCandle, warmCandles };