backtest-kit 4.0.2 → 5.1.0

package/types.d.ts

@@ -1792,6 +1792,9 @@ interface IAction {
      *
      * NOTE: Exceptions are NOT swallowed here — they propagate to CREATE_SYNC_FN.
      *
+     * @deprecated This method is not recommended for use. Implement custom logic in signal(), signalLive(), or signalBacktest() instead.
+     * If you need to implement custom logic on signal open/close, please use signal(), signalBacktest(), signalLive() instead.
+     * If Action::signalSync throws the exchange will not execute the order!
      * @param event - Sync event with action "signal-open" or "signal-close"
      */
     signalSync(event: SignalSyncContract): void | Promise<void>;
@@ -2161,8 +2164,8 @@ interface ISignalRow extends ISignalDto {
          * Used to slice _entry to only entries that existed at this partial.
          */
         entryCountAtClose: number;
-        /** Debug only timestamp in milliseconds */
-        debugTimestamp?: number;
+        /** Unix timestamp in milliseconds when this partial close was executed */
+        timestamp: number;
     }>;
     /**
      * Trailing stop-loss price that overrides priceStopLoss when set.
@@ -2185,8 +2188,8 @@ interface ISignalRow extends ISignalDto {
         price: number;
         /** Cost of this entry in USD (e.g. 100 for $100 position) */
         cost: number;
-        /** Debug only timestamp in milliseconds */
-        debugTimestamp?: number;
+        /** Unix timestamp in milliseconds when this entry was executed */
+        timestamp: number;
     }>;
     /**
      * Trailing take-profit price that overrides priceTakeProfit when set.
@@ -2863,9 +2866,29 @@ interface IStrategy {
      * @param symbol - Trading pair symbol
      * @returns Promise resolving to array of entry records or null
      */
-    getPositionEntries: (symbol: string) => Promise<Array<{
+    getPositionEntries: (symbol: string, timestamp: number) => Promise<Array<{
         price: number;
         cost: number;
+        timestamp: number;
+    }> | null>;
+    /**
+     * Returns the history of partial closes for the current pending signal.
+     *
+     * Each record includes the type (profit or loss), percentage closed, price, cost basis at close, and timestamp.
+     * Used for tracking how the position was partially closed over time.
+     *
+     * Returns null if no pending signal exists or no partial closes were executed.
+     *
+     * @param symbol - Trading pair symbol
+     * @returns Promise resolving to array of partial close records or null
+     */
+    getPositionPartials: (symbol: string) => Promise<Array<{
+        type: "profit" | "loss";
+        percent: number;
+        currentPrice: number;
+        costBasisAtClose: number;
+        entryCountAtClose: number;
+        timestamp: number;
     }> | null>;
     /**
      * Fast backtest using historical candles.
@@ -2985,14 +3008,15 @@ interface IStrategy {
      * @param percentToClose - Absolute percentage of position to close (0-100)
      * @param currentPrice - Current market price for partial close
      * @param backtest - Whether running in backtest mode
+     * @param timestamp - Unix timestamp (ms) of the candle that triggered this partial close
      * @returns Promise<boolean> - true if partial close executed, false if skipped
      *
      * @example
      * ```typescript
      * callbacks: {
-     *   onPartialProfit: async (symbol, signal, currentPrice, percentTp, backtest) => {
+     *   onPartialProfit: async (symbol, signal, currentPrice, percentTp, backtest, timestamp) => {
      *     if (percentTp >= 50) {
-     *       const success = await strategy.partialProfit(symbol, 25, currentPrice, backtest);
+     *       const success = await strategy.partialProfit(symbol, 25, currentPrice, backtest, timestamp);
      *       if (success) {
      *         console.log('Partial profit executed');
      *       }
@@ -3001,7 +3025,7 @@ interface IStrategy {
      * }
      * ```
      */
-    partialProfit: (symbol: string, percentToClose: number, currentPrice: number, backtest: boolean) => Promise<boolean>;
+    partialProfit: (symbol: string, percentToClose: number, currentPrice: number, backtest: boolean, timestamp: number) => Promise<boolean>;
     /**
      * Checks whether `partialProfit` would succeed without executing it.
      *
@@ -3040,14 +3064,15 @@ interface IStrategy {
      * @param percentToClose - Absolute percentage of position to close (0-100)
      * @param currentPrice - Current market price for partial close
      * @param backtest - Whether running in backtest mode
+     * @param timestamp - Unix timestamp (ms) of the candle that triggered this partial close
      * @returns Promise<boolean> - true if partial close executed, false if skipped
      *
      * @example
      * ```typescript
      * callbacks: {
-     *   onPartialLoss: async (symbol, signal, currentPrice, percentSl, backtest) => {
+     *   onPartialLoss: async (symbol, signal, currentPrice, percentSl, backtest, timestamp) => {
      *     if (percentSl >= 80) {
-     *       const success = await strategy.partialLoss(symbol, 50, currentPrice, backtest);
+     *       const success = await strategy.partialLoss(symbol, 50, currentPrice, backtest, timestamp);
      *       if (success) {
      *         console.log('Partial loss executed');
      *       }
@@ -3056,7 +3081,7 @@ interface IStrategy {
      * }
      * ```
      */
-    partialLoss: (symbol: string, percentToClose: number, currentPrice: number, backtest: boolean) => Promise<boolean>;
+    partialLoss: (symbol: string, percentToClose: number, currentPrice: number, backtest: boolean, timestamp: number) => Promise<boolean>;
     /**
      * Checks whether `partialLoss` would succeed without executing it.
      *
@@ -3315,9 +3340,11 @@ interface IStrategy {
      * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
      * @param currentPrice - New entry price to add to the averaging history
      * @param backtest - Whether running in backtest mode
+     * @param timestamp - Unix timestamp (ms) of the candle that triggered this DCA entry
+     * @param cost - Optional cost of the new entry (defaults to $100 if not provided)
      * @returns Promise<boolean> - true if entry added, false if rejected by direction check
      */
-    averageBuy: (symbol: string, currentPrice: number, backtest: boolean) => Promise<boolean>;
+    averageBuy: (symbol: string, currentPrice: number, backtest: boolean, timestamp: number, cost?: number) => Promise<boolean>;
     /**
      * Checks whether `averageBuy` would succeed without executing it.
      *
@@ -4370,6 +4397,17 @@ declare function getRiskSchema(riskName: RiskName): IRiskSchema;
  */
 declare function getActionSchema(actionName: ActionName): IActionSchema;
 
+/**
+ * Tolerance zone configuration for DCA overlap detection.
+ * Percentages are in 0–100 format (e.g. 5 means 5%).
+ */
+interface IPositionOverlapLadder {
+    /** Upper tolerance in percent (0–100): how far above each DCA level to flag as overlap */
+    upperPercent: number;
+    /** Lower tolerance in percent (0–100): how far below each DCA level to flag as overlap */
+    lowerPercent: number;
+}
+
 /**
  * Cancels the scheduled signal without stopping the strategy.
  *
@@ -4760,9 +4798,101 @@ declare function getScheduledSignal(symbol: string): Promise<IScheduledSignalRow
  * ```
  */
 declare function getBreakeven(symbol: string, currentPrice: number): Promise<boolean>;
+/**
+ * Returns the effective (DCA-weighted) entry price for the current pending signal.
+ *
+ * Uses cost-weighted harmonic mean: Σcost / Σ(cost/price).
+ * When partial closes exist, the price is computed iteratively using
+ * costBasisAtClose snapshots from each partial, then blended with any
+ * DCA entries added after the last partial.
+ * With no DCA entries, equals the original priceOpen.
+ *
+ * Returns null if no pending signal exists.
+ *
+ * Automatically detects backtest/live mode from execution context.
+ *
+ * @param symbol - Trading pair symbol
+ * @returns Promise resolving to effective entry price or null
+ *
+ * @example
+ * ```typescript
+ * import { getPositionAveragePrice } from "backtest-kit";
+ *
+ * const avgPrice = await getPositionAveragePrice("BTCUSDT");
+ * // No DCA: avgPrice === priceOpen
+ * // After DCA at lower price: avgPrice < priceOpen
+ * ```
+ */
 declare function getPositionAveragePrice(symbol: string): Promise<number | null>;
+/**
+ * Returns the number of DCA entries made for the current pending signal.
+ *
+ * 1 = original entry only (no DCA).
+ * Increases by 1 with each successful commitAverageBuy().
+ *
+ * Returns null if no pending signal exists.
+ *
+ * Automatically detects backtest/live mode from execution context.
+ *
+ * @param symbol - Trading pair symbol
+ * @returns Promise resolving to entry count or null
+ *
+ * @example
+ * ```typescript
+ * import { getPositionInvestedCount } from "backtest-kit";
+ *
+ * const count = await getPositionInvestedCount("BTCUSDT");
+ * // No DCA: count === 1
+ * // After one DCA: count === 2
+ * ```
+ */
 declare function getPositionInvestedCount(symbol: string): Promise<number | null>;
+/**
+ * Returns the total invested cost basis in dollars for the current pending signal.
+ *
+ * Equal to the sum of all _entry costs (Σ entry.cost).
+ * Each entry cost is set at the time of commitAverageBuy (defaults to CC_POSITION_ENTRY_COST).
+ *
+ * Returns null if no pending signal exists.
+ *
+ * Automatically detects backtest/live mode from execution context.
+ *
+ * @param symbol - Trading pair symbol
+ * @returns Promise resolving to total invested cost in dollars or null
+ *
+ * @example
+ * ```typescript
+ * import { getPositionInvestedCost } from "backtest-kit";
+ *
+ * const cost = await getPositionInvestedCost("BTCUSDT");
+ * // No DCA, default cost: cost === 100
+ * // After one DCA with default cost: cost === 200
+ * ```
+ */
 declare function getPositionInvestedCost(symbol: string): Promise<number | null>;
+/**
+ * Returns the unrealized PNL percentage for the current pending signal at current market price.
+ *
+ * Accounts for partial closes, DCA entries, slippage and fees
+ * (delegates to toProfitLossDto).
+ *
+ * Returns null if no pending signal exists.
+ *
+ * Automatically detects backtest/live mode from execution context.
+ * Automatically fetches current price via getAveragePrice.
+ *
+ * @param symbol - Trading pair symbol
+ * @returns Promise resolving to PNL percentage or null
+ *
+ * @example
+ * ```typescript
+ * import { getPositionPnlPercent } from "backtest-kit";
+ *
+ * const pnlPct = await getPositionPnlPercent("BTCUSDT");
+ * // LONG at 100, current=105: pnlPct ≈ 5
+ * // LONG at 100, current=95: pnlPct ≈ -5
+ * ```
+ */
 declare function getPositionPnlPercent(symbol: string): Promise<number | null>;
 /**
  * Executes partial close at profit level by absolute dollar amount (moving toward TP).
@@ -4824,6 +4954,29 @@ declare function commitPartialProfitCost(symbol: string, dollarAmount: number):
  * ```
  */
 declare function commitPartialLossCost(symbol: string, dollarAmount: number): Promise<boolean>;
+/**
+ * Returns the unrealized PNL in dollars for the current pending signal at current market price.
+ *
+ * Calculated as: pnlPercentage / 100 × totalInvestedCost.
+ * Accounts for partial closes, DCA entries, slippage and fees.
+ *
+ * Returns null if no pending signal exists.
+ *
+ * Automatically detects backtest/live mode from execution context.
+ * Automatically fetches current price via getAveragePrice.
+ *
+ * @param symbol - Trading pair symbol
+ * @returns Promise resolving to PNL in dollars or null
+ *
+ * @example
+ * ```typescript
+ * import { getPositionPnlCost } from "backtest-kit";
+ *
+ * const pnlCost = await getPositionPnlCost("BTCUSDT");
+ * // LONG at 100, invested $100, current=105: pnlCost ≈ 5
+ * // LONG at 100, invested $200 (DCA), current=95: pnlCost ≈ -10
+ * ```
+ */
 declare function getPositionPnlCost(symbol: string): Promise<number | null>;
 /**
  * Returns the list of DCA entry prices for the current pending signal.
@@ -4881,8 +5034,60 @@ declare function getPositionPartials(symbol: string): Promise<{
     currentPrice: number;
     costBasisAtClose: number;
     entryCountAtClose: number;
-    debugTimestamp?: number;
+    timestamp: number;
 }[]>;
+/**
+ * Checks whether the current price falls within the tolerance zone of any existing DCA entry level.
+ * Use this to prevent duplicate DCA entries at the same price area.
+ *
+ * Returns true if currentPrice is within [level - lowerStep, level + upperStep] for any level,
+ * where step = level * percent / 100.
+ * Returns false if no pending signal exists.
+ *
+ * @param symbol - Trading pair symbol
+ * @param currentPrice - Price to check against existing DCA levels
+ * @param ladder - Tolerance zone config; percentages in 0–100 format (default: 1.5% up and down)
+ * @returns Promise<boolean> - true if price overlaps an existing entry level (DCA not recommended)
+ *
+ * @example
+ * ```typescript
+ * import { getPositionEntryOverlap } from "backtest-kit";
+ *
+ * // LONG with levels [43000, 42000], check if 42100 is too close to 42000
+ * const overlap = await getPositionEntryOverlap("BTCUSDT", 42100, { upperPercent: 5, lowerPercent: 5 });
+ * // overlap = true (42100 is within 5% of 42000 = [39900, 44100])
+ * if (!overlap) {
+ *   await commitAverageBuy("BTCUSDT");
+ * }
+ * ```
+ */
+declare function getPositionEntryOverlap(symbol: string, currentPrice: number, ladder?: IPositionOverlapLadder): Promise<boolean>;
+/**
+ * Checks whether the current price falls within the tolerance zone of any existing partial close price.
+ * Use this to prevent duplicate partial closes at the same price area.
+ *
+ * Returns true if currentPrice is within [partial.currentPrice - lowerStep, partial.currentPrice + upperStep]
+ * for any partial, where step = partial.currentPrice * percent / 100.
+ * Returns false if no pending signal exists or no partials have been executed yet.
+ *
+ * @param symbol - Trading pair symbol
+ * @param currentPrice - Price to check against existing partial close prices
+ * @param ladder - Tolerance zone config; percentages in 0–100 format (default: 1.5% up and down)
+ * @returns Promise<boolean> - true if price overlaps an existing partial price (partial not recommended)
+ *
+ * @example
+ * ```typescript
+ * import { getPositionPartialOverlap } from "backtest-kit";
+ *
+ * // Partials at [45000], check if 45100 is too close
+ * const overlap = await getPositionPartialOverlap("BTCUSDT", 45100, { upperPercent: 1.5, lowerPercent: 1.5 });
+ * // overlap = true (45100 is within 1.5% of 45000)
+ * if (!overlap) {
+ *   await commitPartialProfit("BTCUSDT", 50);
+ * }
+ * ```
+ */
+declare function getPositionPartialOverlap(symbol: string, currentPrice: number, ladder?: IPositionOverlapLadder): Promise<boolean>;
 
 /**
  * Stops the strategy from generating new signals.
@@ -5165,9 +5370,17 @@ declare const GLOBAL_CONFIG: {
      * 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)
+     * Default: false (DCA logic enabled only when antirecord is broken)
      */
     CC_ENABLE_DCA_EVERYWHERE: boolean;
+    /**
+     * Enables PPPL (Partial Profit, Partial Loss) logic even if this breaks a direction of exits
+     * Allows to take partial profit or loss on a position even if it results in a mix of profit and loss exits
+     * This can help lock in profits or cut losses on part of the position without waiting for a perfect exit scenario.
+     *
+     * Default: false (PPPL logic is only applied when it does not break the direction of exits, ensuring clearer profit/loss outcomes)
+     */
+    CC_ENABLE_PPPL_EVERYWHERE: boolean;
     /**
      * Cost of entering a position (in USD).
      * This is used as a default value for calculating position size and risk management when cost data is not provided by the strategy
@@ -5288,6 +5501,7 @@ declare function getConfig(): {
     CC_MAX_LOG_LINES: number;
     CC_ENABLE_CANDLE_FETCH_MUTEX: boolean;
     CC_ENABLE_DCA_EVERYWHERE: boolean;
+    CC_ENABLE_PPPL_EVERYWHERE: boolean;
     CC_POSITION_ENTRY_COST: number;
 };
 /**
@@ -5329,6 +5543,7 @@ declare function getDefaultConfig(): Readonly<{
     CC_MAX_LOG_LINES: number;
     CC_ENABLE_CANDLE_FETCH_MUTEX: boolean;
     CC_ENABLE_DCA_EVERYWHERE: boolean;
+    CC_ENABLE_PPPL_EVERYWHERE: boolean;
     CC_POSITION_ENTRY_COST: number;
 }>;
 /**
@@ -11646,7 +11861,7 @@ declare class BacktestUtils {
         currentPrice: number;
         costBasisAtClose: number;
         entryCountAtClose: number;
-        debugTimestamp?: number;
+        timestamp: number;
     }[]>;
     /**
      * Returns the list of DCA entry prices and costs for the current pending signal.
@@ -11672,7 +11887,46 @@ declare class BacktestUtils {
     }) => Promise<{
         price: number;
         cost: number;
+        timestamp: number;
     }[]>;
+    /**
+     * Checks whether the current price falls within the tolerance zone of any existing DCA entry level.
+     * Use this to prevent duplicate DCA entries at the same price area.
+     *
+     * Returns true if currentPrice is within [level - lowerStep, level + upperStep] for any level,
+     * where step = level * percent / 100.
+     * Returns false if no pending signal exists.
+     *
+     * @param symbol - Trading pair symbol
+     * @param currentPrice - Price to check against existing DCA levels
+     * @param context - Execution context with strategyName, exchangeName, and frameName
+     * @param ladder - Tolerance zone config; percentages in 0–100 format (default: 1.5% up and down)
+     * @returns true if price overlaps an existing entry level (DCA not recommended)
+     */
+    getPositionEntryOverlap: (symbol: string, currentPrice: number, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }, ladder?: IPositionOverlapLadder) => Promise<boolean>;
+    /**
+     * Checks whether the current price falls within the tolerance zone of any existing partial close price.
+     * Use this to prevent duplicate partial closes at the same price area.
+     *
+     * Returns true if currentPrice is within [partial.currentPrice - lowerStep, partial.currentPrice + upperStep]
+     * for any partial, where step = partial.currentPrice * percent / 100.
+     * Returns false if no pending signal exists or no partials have been executed yet.
+     *
+     * @param symbol - Trading pair symbol
+     * @param currentPrice - Price to check against existing partial close prices
+     * @param context - Execution context with strategyName, exchangeName, and frameName
+     * @param ladder - Tolerance zone config; percentages in 0–100 format (default: 1.5% up and down)
+     * @returns true if price overlaps an existing partial price (partial not recommended)
+     */
+    getPositionPartialOverlap: (symbol: string, currentPrice: number, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }, ladder?: IPositionOverlapLadder) => Promise<boolean>;
     /**
      * Stops the strategy from generating new signals.
      *
@@ -12729,7 +12983,7 @@ declare class LiveUtils {
         currentPrice: number;
         costBasisAtClose: number;
         entryCountAtClose: number;
-        debugTimestamp?: number;
+        timestamp: number;
     }[]>;
     /**
      * Returns the list of DCA entry prices and costs for the current pending signal.
@@ -12754,7 +13008,44 @@ declare class LiveUtils {
     }) => Promise<{
         price: number;
         cost: number;
+        timestamp: number;
     }[]>;
+    /**
+     * Checks whether the current price falls within the tolerance zone of any existing DCA entry level.
+     * Use this to prevent duplicate DCA entries at the same price area.
+     *
+     * Returns true if currentPrice is within [level - lowerStep, level + upperStep] for any level,
+     * where step = level * percent / 100.
+     * Returns false if no pending signal exists.
+     *
+     * @param symbol - Trading pair symbol
+     * @param currentPrice - Price to check against existing DCA levels
+     * @param context - Execution context with strategyName and exchangeName
+     * @param ladder - Tolerance zone config; percentages in 0–100 format (default: 1.5% up and down)
+     * @returns true if price overlaps an existing entry level (DCA not recommended)
+     */
+    getPositionEntryOverlap: (symbol: string, currentPrice: number, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+    }, ladder?: IPositionOverlapLadder) => Promise<boolean>;
+    /**
+     * Checks whether the current price falls within the tolerance zone of any existing partial close price.
+     * Use this to prevent duplicate partial closes at the same price area.
+     *
+     * Returns true if currentPrice is within [partial.currentPrice - lowerStep, partial.currentPrice + upperStep]
+     * for any partial, where step = partial.currentPrice * percent / 100.
+     * Returns false if no pending signal exists or no partials have been executed yet.
+     *
+     * @param symbol - Trading pair symbol
+     * @param currentPrice - Price to check against existing partial close prices
+     * @param context - Execution context with strategyName and exchangeName
+     * @param ladder - Tolerance zone config; percentages in 0–100 format (default: 1.5% up and down)
+     * @returns true if price overlaps an existing partial price (partial not recommended)
+     */
+    getPositionPartialOverlap: (symbol: string, currentPrice: number, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+    }, ladder?: IPositionOverlapLadder) => Promise<boolean>;
     /**
      * Stops the strategy from generating new signals.
      *
@@ -16152,7 +16443,7 @@ declare class NotificationBacktestAdapter implements INotificationUtils {
      * Proxies call to the underlying notification adapter.
      * @param data - The signal sync contract data
      */
-    handleSync: (data: SignalSyncContract) => Promise<void>;
+    handleSync: (data: SignalSyncContract) => any;
     /**
      * Handles risk rejection event.
      * Proxies call to the underlying notification adapter.
@@ -16258,7 +16549,7 @@ declare class NotificationLiveAdapter implements INotificationUtils {
      * Proxies call to the underlying notification adapter.
      * @param data - The signal sync contract data
      */
-    handleSync: (data: SignalSyncContract) => Promise<void>;
+    handleSync: (data: SignalSyncContract) => any;
     /**
      * Handles risk rejection event.
      * Proxies call to the underlying notification adapter.
@@ -18239,15 +18530,6 @@ declare class ActionBase implements IPublicAction {
      * ```
      */
     riskRejection(event: RiskContract, source?: string): void | Promise<void>;
-    /**
-     * Gate for position open/close via limit order. Default allows all.
-     * Throw to reject — framework retries next tick.
-     *
-     * NOTE: Exceptions are NOT swallowed — they propagate to CREATE_SYNC_FN.
-     *
-     * @param event - Sync event with action "signal-open" or "signal-close"
-     */
-    signalSync(_event: SignalSyncContract, source?: string): void | Promise<void>;
     /**
      * Cleans up resources and subscriptions when action handler is disposed.
      *
@@ -18483,6 +18765,8 @@ type BrokerTrailingStopPayload = {
     currentPrice: number;
     /** Absolute stop-loss price after applying percentShift */
     newStopLossPrice: number;
+    /** Active take profit price at the time of the trailing update */
+    takeProfitPrice: number;
     /** Position direction */
     position: "long" | "short";
     /** Strategy/exchange/frame routing context */
@@ -18523,6 +18807,8 @@ type BrokerTrailingTakePayload = {
     currentPrice: number;
     /** Absolute take-profit price after applying percentShift */
     newTakeProfitPrice: number;
+    /** Active take profit price at the time of the trailing update */
+    takeProfitPrice: number;
     /** Position direction */
     position: "long" | "short";
     /** Strategy/exchange/frame routing context */
@@ -20647,6 +20933,184 @@ declare class BreakevenConnectionService implements IBreakeven {
     clear: (symbol: string, data: IPublicSignalRow, priceClose: number, backtest: boolean) => Promise<void>;
 }
 
+/**
+ * Service for tracking the latest candle timestamp per symbol-strategy-exchange-frame combination.
+ *
+ * Maintains a memoized BehaviorSubject per unique key that is updated on every strategy tick
+ * by StrategyConnectionService. Consumers can synchronously read the last known timestamp or
+ * await the first value if none has arrived yet.
+ *
+ * Primary use case: providing the current candle time outside of a tick execution context,
+ * e.g., when a command is triggered between ticks.
+ *
+ * Features:
+ * - One BehaviorSubject per (symbol, strategyName, exchangeName, frameName, backtest) key
+ * - Falls back to ExecutionContextService.context.when when called inside an execution context
+ * - Waits up to LISTEN_TIMEOUT ms for the first timestamp if none is cached yet
+ * - clear() disposes the BehaviorSubject for a single key or all keys
+ *
+ * Architecture:
+ * - Registered as singleton in DI container
+ * - Updated by StrategyConnectionService after each tick
+ * - Cleared by Backtest/Live/Walker at strategy start to prevent stale data
+ *
+ * @example
+ * ```typescript
+ * const ts = await backtest.timeMetaService.getTimestamp("BTCUSDT", context, false);
+ * ```
+ */
+declare class TimeMetaService {
+    private readonly loggerService;
+    private readonly executionContextService;
+    /**
+     * Memoized factory for BehaviorSubject streams keyed by (symbol, strategyName, exchangeName, frameName, backtest).
+     *
+     * Each subject holds the latest createdAt timestamp emitted by the strategy iterator for that key.
+     * Instances are cached until clear() is called.
+     */
+    private getSource;
+    /**
+     * Returns the current candle timestamp (in milliseconds) for the given symbol and context.
+     *
+     * When called inside an execution context (i.e., during a signal handler or action),
+     * reads the timestamp directly from ExecutionContextService.context.when.
+     * Otherwise, reads the last value from the cached BehaviorSubject. If no value has
+     * been emitted yet, waits up to LISTEN_TIMEOUT ms for the first tick before throwing.
+     *
+     * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+     * @param context - Strategy, exchange, and frame identifiers
+     * @param backtest - True if backtest mode, false if live mode
+     * @returns Unix timestamp in milliseconds of the latest processed candle
+     * @throws When no timestamp arrives within LISTEN_TIMEOUT ms
+     */
+    getTimestamp: (symbol: string, context: {
+        strategyName: string;
+        exchangeName: string;
+        frameName: string;
+    }, backtest: boolean) => Promise<number>;
+    /**
+     * Pushes a new timestamp value into the BehaviorSubject for the given key.
+     *
+     * Called by StrategyConnectionService after each strategy tick to keep
+     * the cached timestamp up to date.
+     *
+     * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+     * @param timestamp - The createdAt timestamp from the tick (milliseconds)
+     * @param context - Strategy, exchange, and frame identifiers
+     * @param backtest - True if backtest mode, false if live mode
+     */
+    next: (symbol: string, timestamp: number, context: {
+        strategyName: string;
+        exchangeName: string;
+        frameName: string;
+    }, backtest: boolean) => Promise<void>;
+    /**
+     * Disposes cached BehaviorSubject(s) to free memory and prevent stale data.
+     *
+     * When called without arguments, clears all memoized timestamp streams.
+     * When called with a payload, clears only the stream for the specified key.
+     * Should be called at strategy start (Backtest/Live/Walker) to reset state.
+     *
+     * @param payload - Optional key to clear a single stream; omit to clear all
+     */
+    clear: (payload?: {
+        symbol: string;
+        strategyName: string;
+        exchangeName: string;
+        frameName: string;
+        backtest: boolean;
+    }) => void;
+}
+
+/**
+ * Service for tracking the latest market price per symbol-strategy-exchange-frame combination.
+ *
+ * Maintains a memoized BehaviorSubject per unique key that is updated on every strategy tick
+ * by StrategyConnectionService. Consumers can synchronously read the last known price or
+ * await the first value if none has arrived yet.
+ *
+ * Primary use case: providing the current price outside of a tick execution context,
+ * e.g., when a command is triggered between ticks.
+ *
+ * Features:
+ * - One BehaviorSubject per (symbol, strategyName, exchangeName, frameName, backtest) key
+ * - Falls back to ExchangeConnectionService.getAveragePrice when called inside an execution context
+ * - Waits up to LISTEN_TIMEOUT ms for the first price if none is cached yet
+ * - clear() disposes the BehaviorSubject for a single key or all keys
+ *
+ * Architecture:
+ * - Registered as singleton in DI container
+ * - Updated by StrategyConnectionService after each tick
+ * - Cleared by Backtest/Live/Walker at strategy start to prevent stale data
+ *
+ * @example
+ * ```typescript
+ * const price = await backtest.priceMetaService.getCurrentPrice("BTCUSDT", context, false);
+ * ```
+ */
+declare class PriceMetaService {
+    private readonly loggerService;
+    private readonly exchangeConnectionService;
+    /**
+     * Memoized factory for BehaviorSubject streams keyed by (symbol, strategyName, exchangeName, frameName, backtest).
+     *
+     * Each subject holds the latest currentPrice emitted by the strategy iterator for that key.
+     * Instances are cached until clear() is called.
+     */
+    private getSource;
+    /**
+     * Returns the current market price for the given symbol and context.
+     *
+     * When called inside an execution context (i.e., during a signal handler or action),
+     * delegates to ExchangeConnectionService.getAveragePrice for the live exchange price.
+     * Otherwise, reads the last value from the cached BehaviorSubject. If no value has
+     * been emitted yet, waits up to LISTEN_TIMEOUT ms for the first tick before throwing.
+     *
+     * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+     * @param context - Strategy, exchange, and frame identifiers
+     * @param backtest - True if backtest mode, false if live mode
+     * @returns Current market price in quote currency
+     * @throws When no price arrives within LISTEN_TIMEOUT ms
+     */
+    getCurrentPrice: (symbol: string, context: {
+        strategyName: string;
+        exchangeName: string;
+        frameName: string;
+    }, backtest: boolean) => Promise<number>;
+    /**
+     * Pushes a new price value into the BehaviorSubject for the given key.
+     *
+     * Called by StrategyConnectionService after each strategy tick to keep
+     * the cached price up to date.
+     *
+     * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+     * @param currentPrice - The latest price from the tick
+     * @param context - Strategy, exchange, and frame identifiers
+     * @param backtest - True if backtest mode, false if live mode
+     */
+    next: (symbol: string, currentPrice: number, context: {
+        strategyName: string;
+        exchangeName: string;
+        frameName: string;
+    }, backtest: boolean) => Promise<void>;
+    /**
+     * Disposes cached BehaviorSubject(s) to free memory and prevent stale data.
+     *
+     * When called without arguments, clears all memoized price streams.
+     * When called with a payload, clears only the stream for the specified key.
+     * Should be called at strategy start (Backtest/Live/Walker) to reset state.
+     *
+     * @param payload - Optional key to clear a single stream; omit to clear all
+     */
+    clear: (payload?: {
+        symbol: string;
+        strategyName: string;
+        exchangeName: string;
+        frameName: string;
+        backtest: boolean;
+    }) => void;
+}
+
 /**
  * Type definition for strategy methods.
  * Maps all keys of IStrategy to any type.
@@ -20689,6 +21153,8 @@ declare class StrategyConnectionService implements TStrategy$1 {
     readonly partialConnectionService: PartialConnectionService;
     readonly breakevenConnectionService: BreakevenConnectionService;
     readonly actionCoreService: ActionCoreService;
+    readonly timeMetaService: TimeMetaService;
+    readonly priceMetaService: PriceMetaService;
     /**
      * Retrieves memoized ClientStrategy instance for given symbol-strategy pair with exchange and frame isolation.
      *
@@ -20748,36 +21214,139 @@ declare class StrategyConnectionService implements TStrategy$1 {
         exchangeName: ExchangeName;
         frameName: FrameName;
     }) => Promise<number | null>;
+    /**
+     * Returns the effective (DCA-averaged) entry price for the current pending signal.
+     *
+     * This is the harmonic mean of all _entry prices, which is the correct
+     * cost-basis price used in all PNL calculations.
+     * With no DCA entries, equals the original priceOpen.
+     *
+     * Returns null if no pending signal exists.
+     *
+     * @param backtest - Whether running in backtest mode
+     * @param symbol - Trading pair symbol
+     * @param context - Execution context with strategyName, exchangeName, frameName
+     * @returns Promise resolving to effective entry price or null
+     */
     getPositionAveragePrice: (backtest: boolean, symbol: string, context: {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
         frameName: FrameName;
     }) => Promise<number | null>;
+    /**
+     * Returns the number of DCA entries made for the current pending signal.
+     *
+     * 1 = original entry only (no DCA).
+     * Increases by 1 with each successful commitAverageBuy().
+     *
+     * Returns null if no pending signal exists.
+     *
+     * @param backtest - Whether running in backtest mode
+     * @param symbol - Trading pair symbol
+     * @param context - Execution context with strategyName, exchangeName, frameName
+     * @returns Promise resolving to entry count or null
+     */
     getPositionInvestedCount: (backtest: boolean, symbol: string, context: {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
         frameName: FrameName;
     }) => Promise<number | null>;
+    /**
+     * Returns the total invested cost basis in dollars for the current pending signal.
+     *
+     * Equal to entryCount × $100 (COST_BASIS_PER_ENTRY).
+     * 1 entry = $100, 2 entries = $200, etc.
+     *
+     * Returns null if no pending signal exists.
+     *
+     * @param backtest - Whether running in backtest mode
+     * @param symbol - Trading pair symbol
+     * @param context - Execution context with strategyName, exchangeName, frameName
+     * @returns Promise resolving to total invested cost in dollars or null
+     */
     getPositionInvestedCost: (backtest: boolean, symbol: string, context: {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
         frameName: FrameName;
     }) => Promise<number | null>;
+    /**
+     * Returns the unrealized PNL percentage for the current pending signal at currentPrice.
+     *
+     * Accounts for partial closes, DCA entries, slippage and fees
+     * (delegates to toProfitLossDto).
+     *
+     * Returns null if no pending signal exists.
+     *
+     * @param backtest - Whether running in backtest mode
+     * @param symbol - Trading pair symbol
+     * @param currentPrice - Current market price
+     * @param context - Execution context with strategyName, exchangeName, frameName
+     * @returns Promise resolving to pnlPercentage or null
+     */
     getPositionPnlPercent: (backtest: boolean, symbol: string, currentPrice: number, context: {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
         frameName: FrameName;
     }) => Promise<number | null>;
+    /**
+     * Returns the unrealized PNL in dollars for the current pending signal at currentPrice.
+     *
+     * Calculated as: pnlPercentage / 100 × totalInvestedCost
+     * Accounts for partial closes, DCA entries, slippage and fees.
+     *
+     * Returns null if no pending signal exists.
+     *
+     * @param backtest - Whether running in backtest mode
+     * @param symbol - Trading pair symbol
+     * @param currentPrice - Current market price
+     * @param context - Execution context with strategyName, exchangeName, frameName
+     * @returns Promise resolving to pnl in dollars or null
+     */
     getPositionPnlCost: (backtest: boolean, symbol: string, currentPrice: number, context: {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
         frameName: FrameName;
     }) => 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 backtest - Whether running in backtest mode
+     * @param symbol - Trading pair symbol
+     * @param context - Execution context with strategyName, exchangeName, frameName
+     * @returns Promise resolving to array of entry prices or null
+     *
+     * @example
+     * ```typescript
+     * // No DCA: [43000]
+     * // One DCA: [43000, 42000]
+     * // Two DCA: [43000, 42000, 41500]
+     * ```
+     */
     getPositionLevels: (backtest: boolean, symbol: string, context: {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
         frameName: FrameName;
     }) => Promise<number[] | null>;
+    /**
+     * Returns the list of partial closes for the current pending signal.
+     *
+     * Each entry records a partial profit or loss close event with its type,
+     * percent closed, price at close, cost basis snapshot, and entry count at close.
+     *
+     * Returns null if no pending signal exists.
+     * Returns an empty array if no partial closes have been executed.
+     *
+     * @param backtest - Whether running in backtest mode
+     * @param symbol - Trading pair symbol
+     * @param context - Execution context with strategyName, exchangeName, frameName
+     * @returns Promise resolving to array of partial close records or null
+     */
     getPositionPartials: (backtest: boolean, symbol: string, context: {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
@@ -20788,8 +21357,29 @@ declare class StrategyConnectionService implements TStrategy$1 {
         currentPrice: number;
         costBasisAtClose: number;
         entryCountAtClose: number;
-        debugTimestamp?: number;
+        timestamp: number;
     }[]>;
+    /**
+     * Returns the list of DCA entry prices and costs for the current pending signal.
+     *
+     * Each entry records the price and cost of a single position entry.
+     * The first element is always the original priceOpen (initial entry).
+     * Each subsequent element is an entry added by averageBuy().
+     *
+     * Returns null if no pending signal exists.
+     * Returns a single-element array [{ price: priceOpen, cost }] if no DCA entries were made.
+     *
+     * @param backtest - Whether running in backtest mode
+     * @param symbol - Trading pair symbol
+     * @param context - Execution context with strategyName, exchangeName, frameName
+     * @returns Promise resolving to array of entry records or null
+     *
+     * @example
+     * ```typescript
+     * // No DCA: [{ price: 43000, cost: 100 }]
+     * // One DCA: [{ price: 43000, cost: 100 }, { price: 42000, cost: 100 }]
+     * ```
+     */
     getPositionEntries: (backtest: boolean, symbol: string, context: {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
@@ -20797,6 +21387,7 @@ declare class StrategyConnectionService implements TStrategy$1 {
     }) => Promise<{
         price: number;
         cost: number;
+        timestamp: number;
     }[]>;
     /**
      * Retrieves the currently active scheduled signal for the strategy.
@@ -22041,7 +22632,7 @@ declare class StrategyCoreService implements TStrategy {
         currentPrice: number;
         costBasisAtClose: number;
         entryCountAtClose: number;
-        debugTimestamp?: number;
+        timestamp: number;
     }[]>;
     getPositionEntries: (backtest: boolean, symbol: string, context: {
         strategyName: StrategyName;
@@ -22050,6 +22641,7 @@ declare class StrategyCoreService implements TStrategy {
     }) => Promise<{
         price: number;
         cost: number;
+        timestamp: number;
     }[]>;
     /**
      * Retrieves the currently active scheduled signal for the symbol.
@@ -25068,6 +25660,8 @@ declare const backtest: {
     riskGlobalService: RiskGlobalService;
     partialGlobalService: PartialGlobalService;
     breakevenGlobalService: BreakevenGlobalService;
+    timeMetaService: TimeMetaService;
+    priceMetaService: PriceMetaService;
     exchangeCoreService: ExchangeCoreService;
     strategyCoreService: StrategyCoreService;
     actionCoreService: ActionCoreService;
@@ -25172,4 +25766,4 @@ declare const getTotalClosed: (signal: Signal) => {
     remainingCostBasis: number;
 };
 
-export { ActionBase, type ActivateScheduledCommit, type ActivateScheduledCommitNotification, type ActivePingContract, type AverageBuyCommit, type AverageBuyCommitNotification, Backtest, type BacktestStatisticsModel, Breakeven, type BreakevenAvailableNotification, type BreakevenCommit, type BreakevenCommitNotification, type BreakevenContract, type BreakevenData, Broker, type BrokerAverageBuyPayload, BrokerBase, type BrokerBreakevenPayload, type BrokerPartialLossPayload, type BrokerPartialProfitPayload, type BrokerSignalClosePayload, type BrokerSignalOpenPayload, type BrokerTrailingStopPayload, type BrokerTrailingTakePayload, 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 IBroker, 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 SignalCloseContract, type SignalClosedNotification, type SignalData, type SignalInterval, type SignalOpenContract, type SignalOpenedNotification, type SignalScheduledNotification, type SignalSyncCloseNotification, type SignalSyncContract, type SignalSyncOpenNotification, Storage, StorageBacktest, type StorageData, StorageLive, Strategy, type StrategyActionType, type StrategyCancelReason, type StrategyCloseReason, type StrategyCommitContract, type StrategyEvent, type StrategyStatisticsModel, Sync, type SyncEvent, type SyncStatisticsModel, type TBrokerCtor, 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, commitTrailingStopCost, commitTrailingTake, commitTrailingTakeCost, 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, listenSync, listenSyncOnce, listenValidation, listenWalker, listenWalkerComplete, listenWalkerOnce, listenWalkerProgress, overrideActionSchema, overrideExchangeSchema, overrideFrameSchema, overrideRiskSchema, overrideSizingSchema, overrideStrategySchema, overrideWalkerSchema, parseArgs, percentDiff, percentToCloseCost, percentValue, roundTicks, set, setColumns, setConfig, setLogger, shutdown, slPercentShiftToPrice, slPriceToPercentShift, stopStrategy, toProfitLossDto, tpPercentShiftToPrice, tpPriceToPercentShift, validate, waitForCandle, warmCandles };
+export { ActionBase, type ActivateScheduledCommit, type ActivateScheduledCommitNotification, type ActivePingContract, type AverageBuyCommit, type AverageBuyCommitNotification, Backtest, type BacktestStatisticsModel, Breakeven, type BreakevenAvailableNotification, type BreakevenCommit, type BreakevenCommitNotification, type BreakevenContract, type BreakevenData, Broker, type BrokerAverageBuyPayload, BrokerBase, type BrokerBreakevenPayload, type BrokerPartialLossPayload, type BrokerPartialProfitPayload, type BrokerSignalClosePayload, type BrokerSignalOpenPayload, type BrokerTrailingStopPayload, type BrokerTrailingTakePayload, 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 IBroker, 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 SignalCloseContract, type SignalClosedNotification, type SignalData, type SignalInterval, type SignalOpenContract, type SignalOpenedNotification, type SignalScheduledNotification, type SignalSyncCloseNotification, type SignalSyncContract, type SignalSyncOpenNotification, Storage, StorageBacktest, type StorageData, StorageLive, Strategy, type StrategyActionType, type StrategyCancelReason, type StrategyCloseReason, type StrategyCommitContract, type StrategyEvent, type StrategyStatisticsModel, Sync, type SyncEvent, type SyncStatisticsModel, type TBrokerCtor, 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, commitTrailingStopCost, commitTrailingTake, commitTrailingTakeCost, 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, getPositionEntryOverlap, getPositionInvestedCost, getPositionInvestedCount, getPositionLevels, getPositionPartialOverlap, 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, listenSync, listenSyncOnce, listenValidation, listenWalker, listenWalkerComplete, listenWalkerOnce, listenWalkerProgress, overrideActionSchema, overrideExchangeSchema, overrideFrameSchema, overrideRiskSchema, overrideSizingSchema, overrideStrategySchema, overrideWalkerSchema, parseArgs, percentDiff, percentToCloseCost, percentValue, roundTicks, set, setColumns, setConfig, setLogger, shutdown, slPercentShiftToPrice, slPriceToPercentShift, stopStrategy, toProfitLossDto, tpPercentShiftToPrice, tpPriceToPercentShift, validate, waitForCandle, warmCandles };