backtest-kit 6.5.1 → 6.7.0

package/types.d.ts

@@ -2235,6 +2235,19 @@ interface ISignalRow extends ISignalDto {
         pnlPercentage: number;
         pnlCost: number;
     };
+    /**
+     * Worst price seen in loss direction during the life of this position.
+     * Initialized at position open with priceOpen/pendingAt (pnl = 0).
+     * Updated on every tick/candle when price moves toward SL (currentDistance < 0).
+     * - For LONG: minimum VWAP price seen below effective entry
+     * - For SHORT: maximum VWAP price seen above effective entry
+     */
+    _fall: {
+        price: number;
+        timestamp: number;
+        pnlPercentage: number;
+        pnlCost: number;
+    };
     /** Unix timestamp in milliseconds when this signal was created/scheduled in backtest context or when getSignal was called in live context (before validation) */
     timestamp: number;
 }
@@ -3502,6 +3515,68 @@ interface IStrategy {
      * @returns Promise resolving to drawdown duration in minutes or null
      */
     getPositionDrawdownMinutes: (symbol: string, timestamp: number) => Promise<number | null>;
+    /**
+     * Returns the number of minutes elapsed since the highest profit price was recorded.
+     *
+     * Alias for getPositionDrawdownMinutes — measures how long the position has been
+     * pulling back from its peak profit level.
+     *
+     * Returns null if no pending signal exists.
+     *
+     * @param symbol - Trading pair symbol
+     * @param timestamp - Current Unix timestamp in milliseconds
+     * @returns Promise resolving to minutes since last profit peak or null
+     */
+    getPositionHighestProfitMinutes: (symbol: string, timestamp: number) => Promise<number | null>;
+    /**
+     * Returns the number of minutes elapsed since the worst loss price was recorded.
+     *
+     * Measures how long ago the deepest drawdown point occurred.
+     * Zero when called at the exact moment the trough was set.
+     *
+     * Returns null if no pending signal exists.
+     *
+     * @param symbol - Trading pair symbol
+     * @param timestamp - Current Unix timestamp in milliseconds
+     * @returns Promise resolving to minutes since last drawdown trough or null
+     */
+    getPositionMaxDrawdownMinutes: (symbol: string, timestamp: number) => Promise<number | null>;
+    /**
+     * Returns the worst price reached in the loss direction during this position's life.
+     *
+     * Returns null if no pending signal exists.
+     *
+     * @param symbol - Trading pair symbol
+     * @returns Promise resolving to price or null
+     */
+    getPositionMaxDrawdownPrice: (symbol: string) => Promise<number | null>;
+    /**
+     * Returns the timestamp when the worst loss price was recorded during this position's life.
+     *
+     * Returns null if no pending signal exists.
+     *
+     * @param symbol - Trading pair symbol
+     * @returns Promise resolving to timestamp in milliseconds or null
+     */
+    getPositionMaxDrawdownTimestamp: (symbol: string) => Promise<number | null>;
+    /**
+     * Returns the PnL percentage at the moment the worst loss price was recorded during this position's life.
+     *
+     * Returns null if no pending signal exists.
+     *
+     * @param symbol - Trading pair symbol
+     * @returns Promise resolving to PnL percentage or null
+     */
+    getPositionMaxDrawdownPnlPercentage: (symbol: string) => Promise<number | null>;
+    /**
+     * Returns the PnL cost (in quote currency) at the moment the worst loss price was recorded during this position's life.
+     *
+     * Returns null if no pending signal exists.
+     *
+     * @param symbol - Trading pair symbol
+     * @returns Promise resolving to PnL cost or null
+     */
+    getPositionMaxDrawdownPnlCost: (symbol: string) => Promise<number | null>;
     /**
      * Disposes the strategy instance and cleans up resources.
      *
@@ -4106,6 +4181,10 @@ interface BacktestStatisticsModel {
     certaintyRatio: number | null;
     /** Expected yearly returns based on average trade duration and PNL, null if unsafe. Higher is better. */
     expectedYearlyReturns: number | null;
+    /** Average peak PNL percentage across all signals (_peak.pnlPercentage), null if unsafe. Higher is better. */
+    avgPeakPnl: number | null;
+    /** Average fall PNL percentage across all signals (_fall.pnlPercentage), null if unsafe. Lower (more negative) means deeper drawdowns. */
+    avgFallPnl: number | null;
 }
 
 /**
@@ -5349,6 +5428,115 @@ declare function getPositionHighestProfitBreakeven(symbol: string): Promise<bool
  * ```
  */
 declare function getPositionDrawdownMinutes(symbol: string): Promise<number>;
+/**
+ * Returns the number of minutes elapsed since the highest profit price was recorded.
+ *
+ * Alias for getPositionDrawdownMinutes — measures how long the position has been
+ * pulling back from its peak profit level.
+ * Zero when called at the exact moment the peak was set.
+ *
+ * Returns null if no pending signal exists.
+ *
+ * @param symbol - Trading pair symbol
+ * @returns Promise resolving to minutes since last profit peak or null
+ *
+ * @example
+ * ```typescript
+ * import { getPositionHighestProfitMinutes } from "backtest-kit";
+ *
+ * const minutes = await getPositionHighestProfitMinutes("BTCUSDT");
+ * // e.g. 30 (30 minutes since the highest profit price)
+ * ```
+ */
+declare function getPositionHighestProfitMinutes(symbol: string): Promise<number>;
+/**
+ * Returns the number of minutes elapsed since the worst loss price was recorded.
+ *
+ * Measures how long ago the deepest drawdown point occurred.
+ * Zero when called at the exact moment the trough was set.
+ *
+ * Returns null if no pending signal exists.
+ *
+ * @param symbol - Trading pair symbol
+ * @returns Promise resolving to minutes since last drawdown trough or null
+ *
+ * @example
+ * ```typescript
+ * import { getPositionMaxDrawdownMinutes } from "backtest-kit";
+ *
+ * const minutes = await getPositionMaxDrawdownMinutes("BTCUSDT");
+ * // e.g. 15 (15 minutes since the worst loss price)
+ * ```
+ */
+declare function getPositionMaxDrawdownMinutes(symbol: string): Promise<number>;
+/**
+ * Returns the worst price reached in the loss direction during this position's life.
+ *
+ * Returns null if no pending signal exists.
+ *
+ * @param symbol - Trading pair symbol
+ * @returns Promise resolving to price or null
+ *
+ * @example
+ * ```typescript
+ * import { getPositionMaxDrawdownPrice } from "backtest-kit";
+ *
+ * const price = await getPositionMaxDrawdownPrice("BTCUSDT");
+ * // e.g. 41000 (lowest price seen for a LONG position)
+ * ```
+ */
+declare function getPositionMaxDrawdownPrice(symbol: string): Promise<number>;
+/**
+ * Returns the timestamp when the worst loss price was recorded during this position's life.
+ *
+ * Returns null if no pending signal exists.
+ *
+ * @param symbol - Trading pair symbol
+ * @returns Promise resolving to timestamp in milliseconds or null
+ *
+ * @example
+ * ```typescript
+ * import { getPositionMaxDrawdownTimestamp } from "backtest-kit";
+ *
+ * const ts = await getPositionMaxDrawdownTimestamp("BTCUSDT");
+ * // e.g. 1700000000000
+ * ```
+ */
+declare function getPositionMaxDrawdownTimestamp(symbol: string): Promise<number>;
+/**
+ * Returns the PnL percentage at the moment the worst loss price was recorded during this position's life.
+ *
+ * Returns null if no pending signal exists.
+ *
+ * @param symbol - Trading pair symbol
+ * @returns Promise resolving to PnL percentage or null
+ *
+ * @example
+ * ```typescript
+ * import { getPositionMaxDrawdownPnlPercentage } from "backtest-kit";
+ *
+ * const pnl = await getPositionMaxDrawdownPnlPercentage("BTCUSDT");
+ * // e.g. -5.2 (deepest PnL percentage reached)
+ * ```
+ */
+declare function getPositionMaxDrawdownPnlPercentage(symbol: string): Promise<number>;
+/**
+ * Returns the PnL cost (in quote currency) at the moment the worst loss price was recorded during this position's life.
+ *
+ * Returns null if no pending signal exists.
+ *
+ * @param symbol - Trading pair symbol
+ * @returns Promise resolving to PnL cost or null
+ *
+ * @example
+ * ```typescript
+ * import { getPositionMaxDrawdownPnlCost } from "backtest-kit";
+ *
+ * const cost = await getPositionMaxDrawdownPnlCost("BTCUSDT");
+ * // e.g. -52 (deepest PnL in quote currency)
+ * ```
+ */
+declare function getPositionMaxDrawdownPnlCost(symbol: string): Promise<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.
@@ -5653,6 +5841,13 @@ declare const GLOBAL_CONFIG: {
      * Default: 250 events
      */
     CC_MAX_HIGHEST_PROFIT_MARKDOWN_ROWS: number;
+    /**
+     * Maximum number of events to keep in max drawdown markdown report storage.
+     * Older events are removed (FIFO) when this limit is exceeded.
+     *
+     * Default: 250 events
+     */
+    CC_MAX_MAX_DRAWDOWN_MARKDOWN_ROWS: number;
     /**
      * Maximum number of events to keep in live markdown report storage.
      * Older events are removed (FIFO) when this limit is exceeded.
@@ -5807,6 +6002,8 @@ declare const COLUMN_CONFIG: {
     sync_columns: ColumnModel<SyncEvent>[];
     /** Columns for highest profit milestone tracking events */
     highest_profit_columns: ColumnModel<HighestProfitEvent>[];
+    /** Columns for max drawdown milestone tracking events */
+    max_drawdown_columns: ColumnModel<MaxDrawdownEvent>[];
     /** Walker: PnL summary columns */
     walker_pnl_columns: ColumnModel<SignalData$1>[];
     /** Walker: strategy-level summary columns */
@@ -5886,6 +6083,7 @@ declare function getConfig(): {
     CC_MAX_BREAKEVEN_MARKDOWN_ROWS: number;
     CC_MAX_HEATMAP_MARKDOWN_ROWS: number;
     CC_MAX_HIGHEST_PROFIT_MARKDOWN_ROWS: number;
+    CC_MAX_MAX_DRAWDOWN_MARKDOWN_ROWS: number;
     CC_MAX_LIVE_MARKDOWN_ROWS: number;
     CC_MAX_PARTIAL_MARKDOWN_ROWS: number;
     CC_MAX_RISK_MARKDOWN_ROWS: number;
@@ -5941,6 +6139,7 @@ declare function getDefaultConfig(): Readonly<{
     CC_MAX_BREAKEVEN_MARKDOWN_ROWS: number;
     CC_MAX_HEATMAP_MARKDOWN_ROWS: number;
     CC_MAX_HIGHEST_PROFIT_MARKDOWN_ROWS: number;
+    CC_MAX_MAX_DRAWDOWN_MARKDOWN_ROWS: number;
     CC_MAX_LIVE_MARKDOWN_ROWS: number;
     CC_MAX_PARTIAL_MARKDOWN_ROWS: number;
     CC_MAX_RISK_MARKDOWN_ROWS: number;
@@ -6010,6 +6209,7 @@ declare function getColumns(): {
     strategy_columns: ColumnModel<StrategyEvent>[];
     sync_columns: ColumnModel<SyncEvent>[];
     highest_profit_columns: ColumnModel<HighestProfitEvent>[];
+    max_drawdown_columns: ColumnModel<MaxDrawdownEvent>[];
     walker_pnl_columns: ColumnModel<SignalData$1>[];
     walker_strategy_columns: ColumnModel<IStrategyResult>[];
 };
@@ -6039,6 +6239,7 @@ declare function getDefaultColumns(): Readonly<{
     strategy_columns: ColumnModel<StrategyEvent>[];
     sync_columns: ColumnModel<SyncEvent>[];
     highest_profit_columns: ColumnModel<HighestProfitEvent>[];
+    max_drawdown_columns: ColumnModel<MaxDrawdownEvent>[];
     walker_pnl_columns: ColumnModel<SignalData$1>[];
     walker_strategy_columns: ColumnModel<IStrategyResult>[];
 }>;
@@ -7112,6 +7313,35 @@ interface HighestProfitContract {
     backtest: boolean;
 }
 
+/**
+ * Contract for max drawdown updates emitted by the framework.
+ * This contract defines the structure of the data emitted when a new maximum drawdown is reached for an open position.
+ * It includes contextual information about the strategy, exchange, frame, and the associated signal.
+ * Consumers can use this information to implement custom logic based on drawdown milestones (e.g. dynamic stop-loss adjustments, risk management).
+ * The backtest flag allows consumers to differentiate between live and backtest updates for appropriate handling.
+ * Max drawdown events are crucial for monitoring and managing risk, as they indicate the largest peak-to-trough decline in the position's value.
+ * By tracking max drawdown, traders can make informed decisions to protect capital and optimize position management strategies.
+ * The framework emits max drawdown updates whenever a new drawdown level is reached, allowing consumers to react in real-time to changing market conditions and position performance.
+ */
+interface MaxDrawdownContract {
+    /** Trading symbol (e.g. "BTC/USDT") */
+    symbol: string;
+    /** Current price at the time of the max drawdown update */
+    currentPrice: number;
+    /** Timestamp of the max drawdown update (milliseconds since epoch) */
+    timestamp: number;
+    /** Strategy name for context */
+    strategyName: StrategyName;
+    /** Exchange name for context */
+    exchangeName: ExchangeName;
+    /** Frame name for context (e.g. "1m", "5m") */
+    frameName: FrameName;
+    /** Public signal data for the position associated with this max drawdown update */
+    signal: IPublicSignalRow;
+    /** Indicates if the update is from a backtest or live trading (true for backtest, false for live) */
+    backtest: boolean;
+}
+
 /**
  * Subscribes to all signal events with queued async processing.
  *
@@ -8148,6 +8378,25 @@ declare function listenHighestProfit(fn: (event: HighestProfitContract) => void)
  * @returns Unsubscribe function to cancel the listener before it fires
  */
 declare function listenHighestProfitOnce(filterFn: (event: HighestProfitContract) => boolean, fn: (event: HighestProfitContract) => void): () => void;
+/**
+ * Subscribes to max drawdown events with queued async processing.
+ * Emits when a signal reaches a new maximum drawdown level during its lifecycle.
+ * Events are processed sequentially in order received, even if callback is async.
+ * Uses queued wrapper to prevent concurrent execution of the callback.
+ * Useful for tracking drawdown milestones and implementing dynamic risk management logic.
+ * @param fn - Callback function to handle max drawdown events
+ * @return Unsubscribe function to stop listening to events
+ */
+declare function listenMaxDrawdown(fn: (event: MaxDrawdownContract) => void): () => void;
+/**
+ * Subscribes to filtered max drawdown events with one-time execution.
+ * Listens for events matching the filter predicate, then executes callback once
+ * and automatically unsubscribes. Useful for waiting for specific drawdown conditions.
+ * @param filterFn - Predicate to filter which events trigger the callback
+ * @param fn - Callback function to handle the filtered event (called only once)
+ * @return Unsubscribe function to cancel the listener before it fires
+ */
+declare function listenMaxDrawdownOnce(filterFn: (event: MaxDrawdownContract) => boolean, fn: (event: MaxDrawdownContract) => void): () => void;
 
 /**
  * Checks if trade context is active (execution and method contexts).
@@ -8743,6 +8992,52 @@ declare function dumpJson(dto: {
     description: string;
 }): Promise<void>;
 
+/**
+ * Full context required to run a function inside both method and execution scopes.
+ *
+ * Combines `IMethodContext` (schema routing: exchange, strategy, frame names) with
+ * `IExecutionContext` (runtime state: symbol, timestamp, backtest flag).
+ *
+ * Passed as a single object to `runInContextInternal`, which splits and distributes
+ * the fields between `MethodContextService` and `ExecutionContextService`.
+ */
+interface IRunContext extends IMethodContext, IExecutionContext {
+}
+/**
+ * A zero-argument function that may be synchronous or asynchronous.
+ *
+ * @template T - Return type of the function.
+ */
+type Function$1<T extends unknown = any> = () => T | Promise<T>;
+/**
+ * Runs a function inside a mock method and execution context.
+ *
+ * Useful in tests and scripts that need to call context-dependent services
+ * (e.g. `getBacktestTimeframe`) without a real backtest runner.
+ *
+ * All context fields are optional; the defaults produce a minimal live-mode
+ * environment pointing at placeholder schema names:
+ * - `exchangeName` → `"mock-exchange"`
+ * - `strategyName` → `"mock-strategy"`
+ * - `frameName`    → `"mock-frame"`
+ * - `symbol`       → `"BTCUSDT"`
+ * - `backtest`     → `false` (live mode)
+ * - `when`         → current minute boundary (`alignToInterval(new Date(), "1m")`)
+ *
+ * @param run - Zero-argument function to execute within the context.
+ * @param context - Partial `IRunContext`; any omitted field falls back to its default.
+ * @returns Promise resolving to the return value of `run`.
+ *
+ * @example
+ * ```typescript
+ * const price = await runInMockContext(
+ *   () => getEffectivePrice("BTCUSDT"),
+ *   { exchangeName: "binance", strategyName: "my-strategy", frameName: "1d" },
+ * );
+ * ```
+ */
+declare function runInMockContext<T extends unknown = any>(run: Function$1<T>, { exchangeName, frameName, strategyName, symbol, backtest: isBacktest, when, }: Partial<IRunContext>): Promise<T>;
+
 /**
  * Portfolio heatmap statistics for a single symbol.
  * Aggregated metrics across all strategies for one trading pair.
@@ -8780,6 +9075,10 @@ interface IHeatmapRow {
     maxLossStreak: number;
     /** Expectancy: (winRate * avgWin) - (lossRate * avgLoss) */
     expectancy: number | null;
+    /** Average peak PNL percentage across all trades (_peak.pnlPercentage). Higher is better. */
+    avgPeakPnl: number | null;
+    /** Average fall PNL percentage across all trades (_fall.pnlPercentage). Closer to 0 is better. */
+    avgFallPnl: number | null;
 }
 
 /**
@@ -10065,6 +10364,10 @@ interface TickEvent {
     pendingAt?: number;
     /** Timestamp when signal was created/scheduled (only for scheduled/waiting/opened/active/closed/cancelled) */
     scheduledAt?: number;
+    /** Peak PNL percentage at best price during position (_peak.pnlPercentage, only for closed) */
+    peakPnl?: number;
+    /** Fall PNL percentage at worst price during position (_fall.pnlPercentage, only for closed) */
+    fallPnl?: number;
 }
 /**
  * Statistical data calculated from live trading results.
@@ -10116,6 +10419,10 @@ interface LiveStatisticsModel {
     certaintyRatio: number | null;
     /** Expected yearly returns based on average trade duration and PNL, null if unsafe. Higher is better. */
     expectedYearlyReturns: number | null;
+    /** Average peak PNL percentage across all closed signals (_peak.pnlPercentage), null if unsafe. Higher is better. */
+    avgPeakPnl: number | null;
+    /** Average fall PNL percentage across all closed signals (_fall.pnlPercentage), null if unsafe. Closer to 0 is better. */
+    avgFallPnl: number | null;
 }
 
 /**
@@ -10133,6 +10440,10 @@ interface HeatmapStatisticsModel {
     portfolioSharpeRatio: number | null;
     /** Portfolio-wide total trades */
     portfolioTotalTrades: number;
+    /** Trade-count-weighted average peak PNL across all symbols. Higher is better. */
+    portfolioAvgPeakPnl: number | null;
+    /** Trade-count-weighted average fall PNL across all symbols. Closer to 0 is better. */
+    portfolioAvgFallPnl: number | null;
 }
 
 /**
@@ -10439,6 +10750,43 @@ interface HighestProfitStatisticsModel {
     totalEvents: number;
 }
 
+/**
+ * Single max drawdown event recorded for a position.
+ */
+interface MaxDrawdownEvent {
+    /** Unix timestamp in milliseconds when the record was set */
+    timestamp: number;
+    /** Trading pair symbol */
+    symbol: string;
+    /** Strategy name */
+    strategyName: string;
+    /** Signal unique identifier */
+    signalId: string;
+    /** Position direction */
+    position: IPublicSignalRow["position"];
+    /** Unrealized PNL at the time the record was set */
+    pnl: IStrategyPnL;
+    /** Record price reached in the loss direction */
+    currentPrice: number;
+    /** Effective entry price at the time of the update */
+    priceOpen: number;
+    /** Take profit price */
+    priceTakeProfit: number;
+    /** Stop loss price */
+    priceStopLoss: number;
+    /** Whether the event occurred in backtest mode */
+    backtest: boolean;
+}
+/**
+ * Aggregated statistics model for max drawdown events.
+ */
+interface MaxDrawdownStatisticsModel {
+    /** Full list of recorded events (newest first) */
+    eventList: MaxDrawdownEvent[];
+    /** Total number of recorded events */
+    totalEvents: number;
+}
+
 /**
  * Risk rejection event data for report generation.
  * Contains all information about rejected signals due to risk limits.
@@ -11836,6 +12184,8 @@ interface IReportTarget {
     sync: boolean;
     /** Enable highest profit milestone event logging */
     highest_profit: boolean;
+    /** Enable max drawdown milestone event logging */
+    max_drawdown: boolean;
 }
 /**
  * Union type of all valid report names.
@@ -11987,7 +12337,7 @@ declare class ReportUtils {
      *
      * @returns Cleanup function that unsubscribes from all enabled services
      */
-    enable: ({ backtest: bt, breakeven, heat, live, partial, performance, risk, schedule, walker, strategy, sync, highest_profit, }?: Partial<IReportTarget>) => (...args: any[]) => any;
+    enable: ({ backtest: bt, breakeven, heat, live, partial, performance, risk, schedule, walker, strategy, sync, highest_profit, max_drawdown, }?: Partial<IReportTarget>) => (...args: any[]) => any;
     /**
      * Disables report services selectively.
      *
@@ -12024,7 +12374,7 @@ declare class ReportUtils {
      * Report.disable();
      * ```
      */
-    disable: ({ backtest: bt, breakeven, heat, live, partial, performance, risk, schedule, walker, strategy, sync, highest_profit, }?: Partial<IReportTarget>) => void;
+    disable: ({ backtest: bt, breakeven, heat, live, partial, performance, risk, schedule, walker, strategy, sync, highest_profit, max_drawdown, }?: Partial<IReportTarget>) => void;
 }
 /**
  * Report adapter with pluggable storage backend and instance memoization.
@@ -12124,6 +12474,8 @@ interface IMarkdownTarget {
     sync: boolean;
     /** Enable highest profit milestone tracking reports */
     highest_profit: boolean;
+    /** Enable max drawdown milestone tracking reports */
+    max_drawdown: boolean;
 }
 /** Symbol key for the singleshot waitForInit function on MarkdownFileBase instances. */
 declare const WAIT_FOR_INIT_SYMBOL: unique symbol;
@@ -12321,7 +12673,7 @@ declare class MarkdownUtils {
      *
      * @returns Cleanup function that unsubscribes from all enabled services
      */
-    enable: ({ backtest: bt, breakeven, heat, live, partial, performance, strategy, risk, schedule, walker, sync, highest_profit, }?: Partial<IMarkdownTarget>) => (...args: any[]) => any;
+    enable: ({ backtest: bt, breakeven, heat, live, partial, performance, strategy, risk, schedule, walker, sync, highest_profit, max_drawdown, }?: Partial<IMarkdownTarget>) => (...args: any[]) => any;
     /**
      * Disables markdown report services selectively.
      *
@@ -12359,7 +12711,7 @@ declare class MarkdownUtils {
      * Markdown.disable();
      * ```
      */
-    disable: ({ backtest: bt, breakeven, heat, live, partial, performance, risk, strategy, schedule, walker, sync, highest_profit, }?: Partial<IMarkdownTarget>) => void;
+    disable: ({ backtest: bt, breakeven, heat, live, partial, performance, risk, strategy, schedule, walker, sync, highest_profit, max_drawdown, }?: Partial<IMarkdownTarget>) => void;
 }
 /**
  * Markdown adapter with pluggable storage backend and instance memoization.
@@ -12571,7 +12923,7 @@ declare const Log: LogAdapter;
  * @see ColumnModel for the base interface
  * @see IStrategyTickResultClosed for the signal data structure
  */
-type Columns$a = ColumnModel<IStrategyTickResultClosed>;
+type Columns$b = ColumnModel<IStrategyTickResultClosed>;
 /**
  * Service for generating and saving backtest markdown reports.
  *
@@ -12665,7 +13017,7 @@ declare class BacktestMarkdownService {
      * console.log(markdown);
      * ```
      */
-    getReport: (symbol: string, strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, columns?: Columns$a[]) => Promise<string>;
+    getReport: (symbol: string, strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, columns?: Columns$b[]) => Promise<string>;
     /**
      * Saves symbol-strategy report to disk.
      * Creates directory if it doesn't exist.
@@ -12690,7 +13042,7 @@ declare class BacktestMarkdownService {
      * await service.dump("BTCUSDT", "my-strategy", "binance", "1h", true, "./custom/path");
      * ```
      */
-    dump: (symbol: string, strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, path?: string, columns?: Columns$a[]) => Promise<void>;
+    dump: (symbol: string, strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, path?: string, columns?: Columns$b[]) => Promise<void>;
     /**
      * Clears accumulated signal data from storage.
      * If payload is provided, clears only that specific symbol-strategy-exchange-frame-backtest combination's data.
@@ -13231,61 +13583,152 @@ declare class BacktestUtils {
         frameName: FrameName;
     }) => Promise<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 the number of minutes elapsed since the highest profit price was recorded.
      *
-     * 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.
+     * Alias for getPositionDrawdownMinutes — measures how long the position has been
+     * pulling back from its peak profit level.
+     * Zero when called at the exact moment the peak was set.
+     *
+     * Returns null 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)
+     * @returns Minutes since last profit peak, or null if no active position
      */
-    getPositionEntryOverlap: (symbol: string, currentPrice: number, context: {
+    getPositionHighestProfitMinutes: (symbol: string, context: {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
         frameName: FrameName;
-    }, ladder?: IPositionOverlapLadder) => Promise<boolean>;
+    }) => Promise<number>;
     /**
-     * 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 the number of minutes elapsed since the worst loss price was recorded.
      *
-     * 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.
+     * Measures how long ago the deepest drawdown point occurred.
+     * Zero when called at the exact moment the trough was set.
+     *
+     * Returns null if no pending signal exists.
      *
      * @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)
+     * @returns Minutes since last drawdown trough, or null if no active position
      */
-    getPositionPartialOverlap: (symbol: string, currentPrice: number, context: {
+    getPositionMaxDrawdownMinutes: (symbol: string, context: {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
         frameName: FrameName;
-    }, ladder?: IPositionOverlapLadder) => Promise<boolean>;
+    }) => Promise<number>;
     /**
-     * Stops the strategy from generating new signals.
+     * Returns the worst price reached in the loss direction during this position's life.
      *
-     * Sets internal flag to prevent strategy from opening new signals.
-     * Current active signal (if any) will complete normally.
-     * Backtest will stop at the next safe point (idle state or after signal closes).
+     * Returns null if no pending signal exists.
      *
      * @param symbol - Trading pair symbol
-     * @param strategyName - Strategy name to stop
-     * @param context - Execution context with exchangeName and frameName
-     * @returns Promise that resolves when stop flag is set
-     *
-     * @example
-     * ```typescript
-     * // Stop strategy after some condition
-     * await Backtest.stop("BTCUSDT", "my-strategy", {
-     *   exchangeName: "binance",
-     *   frameName: "frame1",
+     * @param context - Execution context with strategyName, exchangeName, and frameName
+     * @returns price or null if no active position
+     */
+    getPositionMaxDrawdownPrice: (symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<number>;
+    /**
+     * Returns the timestamp when the worst loss price was recorded during this position's life.
+     *
+     * Returns null if no pending signal exists.
+     *
+     * @param symbol - Trading pair symbol
+     * @param context - Execution context with strategyName, exchangeName, and frameName
+     * @returns timestamp in milliseconds or null if no active position
+     */
+    getPositionMaxDrawdownTimestamp: (symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<number>;
+    /**
+     * Returns the PnL percentage at the moment the worst loss price was recorded during this position's life.
+     *
+     * Returns null if no pending signal exists.
+     *
+     * @param symbol - Trading pair symbol
+     * @param context - Execution context with strategyName, exchangeName, and frameName
+     * @returns PnL percentage or null if no active position
+     */
+    getPositionMaxDrawdownPnlPercentage: (symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<number>;
+    /**
+     * Returns the PnL cost (in quote currency) at the moment the worst loss price was recorded during this position's life.
+     *
+     * Returns null if no pending signal exists.
+     *
+     * @param symbol - Trading pair symbol
+     * @param context - Execution context with strategyName, exchangeName, and frameName
+     * @returns PnL cost or null if no active position
+     */
+    getPositionMaxDrawdownPnlCost: (symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<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.
+     *
+     * Sets internal flag to prevent strategy from opening new signals.
+     * Current active signal (if any) will complete normally.
+     * Backtest will stop at the next safe point (idle state or after signal closes).
+     *
+     * @param symbol - Trading pair symbol
+     * @param strategyName - Strategy name to stop
+     * @param context - Execution context with exchangeName and frameName
+     * @returns Promise that resolves when stop flag is set
+     *
+     * @example
+     * ```typescript
+     * // Stop strategy after some condition
+     * await Backtest.stop("BTCUSDT", "my-strategy", {
+     *   exchangeName: "binance",
+     *   frameName: "frame1",
      *   strategyName: "my-strategy"
      * });
      * ```
@@ -13747,7 +14190,7 @@ declare class BacktestUtils {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
         frameName: FrameName;
-    }, columns?: Columns$a[]) => Promise<string>;
+    }, columns?: Columns$b[]) => Promise<string>;
     /**
      * Saves strategy report to disk.
      *
@@ -13778,7 +14221,7 @@ declare class BacktestUtils {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
         frameName: FrameName;
-    }, path?: string, columns?: Columns$a[]) => Promise<void>;
+    }, path?: string, columns?: Columns$b[]) => Promise<void>;
     /**
      * Lists all active backtest instances with their current status.
      *
@@ -13852,7 +14295,7 @@ declare const Backtest: BacktestUtils;
  * @see ColumnModel for the base interface
  * @see TickEvent for the event data structure
  */
-type Columns$9 = ColumnModel<TickEvent>;
+type Columns$a = ColumnModel<TickEvent>;
 /**
  * Service for generating and saving live trading markdown reports.
  *
@@ -13979,7 +14422,7 @@ declare class LiveMarkdownService {
      * console.log(markdown);
      * ```
      */
-    getReport: (symbol: string, strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, columns?: Columns$9[]) => Promise<string>;
+    getReport: (symbol: string, strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, columns?: Columns$a[]) => Promise<string>;
     /**
      * Saves symbol-strategy report to disk.
      * Creates directory if it doesn't exist.
@@ -14004,7 +14447,7 @@ declare class LiveMarkdownService {
      * await service.dump("BTCUSDT", "my-strategy", "binance", "1h", false, "./custom/path");
      * ```
      */
-    dump: (symbol: string, strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, path?: string, columns?: Columns$9[]) => Promise<void>;
+    dump: (symbol: string, strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, path?: string, columns?: Columns$a[]) => Promise<void>;
     /**
      * Clears accumulated event data from storage.
      * If payload is provided, clears only that specific symbol-strategy-exchange-frame-backtest combination's data.
@@ -14503,6 +14946,91 @@ declare class LiveUtils {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
     }) => Promise<number>;
+    /**
+     * Returns the number of minutes elapsed since the highest profit price was recorded.
+     *
+     * Alias for getPositionDrawdownMinutes — measures how long the position has been
+     * pulling back from its peak profit level.
+     * Zero when called at the exact moment the peak was set.
+     *
+     * Returns null if no pending signal exists.
+     *
+     * @param symbol - Trading pair symbol
+     * @param context - Execution context with strategyName and exchangeName
+     * @returns Minutes since last profit peak, or null if no active position
+     */
+    getPositionHighestProfitMinutes: (symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+    }) => Promise<number>;
+    /**
+     * Returns the number of minutes elapsed since the worst loss price was recorded.
+     *
+     * Measures how long ago the deepest drawdown point occurred.
+     * Zero when called at the exact moment the trough was set.
+     *
+     * Returns null if no pending signal exists.
+     *
+     * @param symbol - Trading pair symbol
+     * @param context - Execution context with strategyName and exchangeName
+     * @returns Minutes since last drawdown trough, or null if no active position
+     */
+    getPositionMaxDrawdownMinutes: (symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+    }) => Promise<number>;
+    /**
+     * Returns the worst price reached in the loss direction during this position's life.
+     *
+     * Returns null if no pending signal exists.
+     *
+     * @param symbol - Trading pair symbol
+     * @param context - Execution context with strategyName and exchangeName
+     * @returns price or null if no active position
+     */
+    getPositionMaxDrawdownPrice: (symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+    }) => Promise<number>;
+    /**
+     * Returns the timestamp when the worst loss price was recorded during this position's life.
+     *
+     * Returns null if no pending signal exists.
+     *
+     * @param symbol - Trading pair symbol
+     * @param context - Execution context with strategyName and exchangeName
+     * @returns timestamp in milliseconds or null if no active position
+     */
+    getPositionMaxDrawdownTimestamp: (symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+    }) => Promise<number>;
+    /**
+     * Returns the PnL percentage at the moment the worst loss price was recorded during this position's life.
+     *
+     * Returns null if no pending signal exists.
+     *
+     * @param symbol - Trading pair symbol
+     * @param context - Execution context with strategyName and exchangeName
+     * @returns PnL percentage or null if no active position
+     */
+    getPositionMaxDrawdownPnlPercentage: (symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+    }) => Promise<number>;
+    /**
+     * Returns the PnL cost (in quote currency) at the moment the worst loss price was recorded during this position's life.
+     *
+     * Returns null if no pending signal exists.
+     *
+     * @param symbol - Trading pair symbol
+     * @param context - Execution context with strategyName and exchangeName
+     * @returns PnL cost or null if no active position
+     */
+    getPositionMaxDrawdownPnlCost: (symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+    }) => Promise<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.
@@ -14988,7 +15516,7 @@ declare class LiveUtils {
     getReport: (symbol: string, context: {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
-    }, columns?: Columns$9[]) => Promise<string>;
+    }, columns?: Columns$a[]) => Promise<string>;
     /**
      * Saves strategy report to disk.
      *
@@ -15018,7 +15546,7 @@ declare class LiveUtils {
     dump: (symbol: string, context: {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
-    }, path?: string, columns?: Columns$9[]) => Promise<void>;
+    }, path?: string, columns?: Columns$a[]) => Promise<void>;
     /**
      * Lists all active live trading instances with their current status.
      *
@@ -15088,7 +15616,7 @@ declare const Live: LiveUtils;
  * @see ColumnModel for the base interface
  * @see ScheduledEvent for the event data structure
  */
-type Columns$8 = ColumnModel<ScheduledEvent>;
+type Columns$9 = ColumnModel<ScheduledEvent>;
 /**
  * Service for generating and saving scheduled signals markdown reports.
  *
@@ -15199,7 +15727,7 @@ declare class ScheduleMarkdownService {
      * console.log(markdown);
      * ```
      */
-    getReport: (symbol: string, strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, columns?: Columns$8[]) => Promise<string>;
+    getReport: (symbol: string, strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, columns?: Columns$9[]) => Promise<string>;
     /**
      * Saves symbol-strategy report to disk.
      * Creates directory if it doesn't exist.
@@ -15224,7 +15752,7 @@ declare class ScheduleMarkdownService {
      * await service.dump("BTCUSDT", "my-strategy", "binance", "1h", false, "./custom/path");
      * ```
      */
-    dump: (symbol: string, strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, path?: string, columns?: Columns$8[]) => Promise<void>;
+    dump: (symbol: string, strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, path?: string, columns?: Columns$9[]) => Promise<void>;
     /**
      * Clears accumulated event data from storage.
      * If payload is provided, clears only that specific symbol-strategy-exchange-frame-backtest combination's data.
@@ -15314,7 +15842,7 @@ declare class ScheduleUtils {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
         frameName: FrameName;
-    }, backtest?: boolean, columns?: Columns$8[]) => Promise<string>;
+    }, backtest?: boolean, columns?: Columns$9[]) => Promise<string>;
     /**
      * Saves strategy report to disk.
      *
@@ -15336,7 +15864,7 @@ declare class ScheduleUtils {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
         frameName: FrameName;
-    }, backtest?: boolean, path?: string, columns?: Columns$8[]) => Promise<void>;
+    }, backtest?: boolean, path?: string, columns?: Columns$9[]) => Promise<void>;
 }
 /**
  * Singleton instance of ScheduleUtils for convenient scheduled signals reporting.
@@ -15382,7 +15910,7 @@ declare const Schedule: ScheduleUtils;
  * @see ColumnModel for the base interface
  * @see MetricStats for the metric data structure
  */
-type Columns$7 = ColumnModel<MetricStats>;
+type Columns$8 = ColumnModel<MetricStats>;
 /**
  * Service for collecting and analyzing performance metrics.
  *
@@ -15489,7 +16017,7 @@ declare class PerformanceMarkdownService {
      * console.log(markdown);
      * ```
      */
-    getReport: (symbol: string, strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, columns?: Columns$7[]) => Promise<string>;
+    getReport: (symbol: string, strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, columns?: Columns$8[]) => Promise<string>;
     /**
      * Saves performance report to disk.
      *
@@ -15510,7 +16038,7 @@ declare class PerformanceMarkdownService {
      * await performanceService.dump("BTCUSDT", "my-strategy", "binance", "1h", false, "./custom/path");
      * ```
      */
-    dump: (symbol: string, strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, path?: string, columns?: Columns$7[]) => Promise<void>;
+    dump: (symbol: string, strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, path?: string, columns?: Columns$8[]) => Promise<void>;
     /**
      * Clears accumulated performance data from storage.
      *
@@ -15618,7 +16146,7 @@ declare class Performance {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
         frameName: FrameName;
-    }, backtest?: boolean, columns?: Columns$7[]): Promise<string>;
+    }, backtest?: boolean, columns?: Columns$8[]): Promise<string>;
     /**
      * Saves performance report to disk.
      *
@@ -15643,7 +16171,7 @@ declare class Performance {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
         frameName: FrameName;
-    }, backtest?: boolean, path?: string, columns?: Columns$7[]): Promise<void>;
+    }, backtest?: boolean, path?: string, columns?: Columns$8[]): Promise<void>;
 }
 
 /**
@@ -16074,7 +16602,7 @@ declare const Walker: WalkerUtils;
  * @see ColumnModel for the base interface
  * @see IHeatmapRow for the row data structure
  */
-type Columns$6 = ColumnModel<IHeatmapRow>;
+type Columns$7 = ColumnModel<IHeatmapRow>;
 /**
  * Portfolio Heatmap Markdown Service.
  *
@@ -16209,7 +16737,7 @@ declare class HeatMarkdownService {
      * // | ETHUSDT | +12.3%  | 1.85   | -3.1%  | 38     |
      * ```
      */
-    getReport: (strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, columns?: Columns$6[]) => Promise<string>;
+    getReport: (strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, columns?: Columns$7[]) => Promise<string>;
     /**
      * Generates the heatmap report and writes it to disk.
      *
@@ -16237,7 +16765,7 @@ declare class HeatMarkdownService {
      * await service.dump("my-strategy", "binance", "frame1", true, "./reports");
      * ```
      */
-    dump: (strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, path?: string, columns?: Columns$6[]) => Promise<void>;
+    dump: (strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, path?: string, columns?: Columns$7[]) => Promise<void>;
     /**
      * Evicts memoized `HeatmapStorage` instances, releasing all accumulated signal data.
      *
@@ -16373,7 +16901,7 @@ declare class HeatUtils {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
         frameName: FrameName;
-    }, backtest?: boolean, columns?: Columns$6[]) => Promise<string>;
+    }, backtest?: boolean, columns?: Columns$7[]) => Promise<string>;
     /**
      * Saves heatmap report to disk for a strategy.
      *
@@ -16406,7 +16934,7 @@ declare class HeatUtils {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
         frameName: FrameName;
-    }, backtest?: boolean, path?: string, columns?: Columns$6[]) => Promise<void>;
+    }, backtest?: boolean, path?: string, columns?: Columns$7[]) => Promise<void>;
 }
 /**
  * Singleton instance of HeatUtils for convenient heatmap operations.
@@ -16560,7 +17088,7 @@ declare const PositionSize: typeof PositionSizeUtils;
  * @see ColumnModel for the base interface
  * @see PartialEvent for the event data structure
  */
-type Columns$5 = ColumnModel<PartialEvent>;
+type Columns$6 = ColumnModel<PartialEvent>;
 /**
  * Service for generating and saving partial profit/loss markdown reports.
  *
@@ -16682,7 +17210,7 @@ declare class PartialMarkdownService {
      * console.log(markdown);
      * ```
      */
-    getReport: (symbol: string, strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, columns?: Columns$5[]) => Promise<string>;
+    getReport: (symbol: string, strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, columns?: Columns$6[]) => Promise<string>;
     /**
      * Saves symbol-strategy report to disk.
      * Creates directory if it doesn't exist.
@@ -16707,7 +17235,7 @@ declare class PartialMarkdownService {
      * await service.dump("BTCUSDT", "my-strategy", "binance", "1h", false, "./custom/path");
      * ```
      */
-    dump: (symbol: string, strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, path?: string, columns?: Columns$5[]) => Promise<void>;
+    dump: (symbol: string, strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, path?: string, columns?: Columns$6[]) => Promise<void>;
     /**
      * Clears accumulated event data from storage.
      * If payload is provided, clears only that specific symbol-strategy-exchange-frame-backtest combination's data.
@@ -16843,7 +17371,7 @@ declare class PartialUtils {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
         frameName: FrameName;
-    }, backtest?: boolean, columns?: Columns$5[]) => Promise<string>;
+    }, backtest?: boolean, columns?: Columns$6[]) => Promise<string>;
     /**
      * Generates and saves markdown report to file.
      *
@@ -16880,7 +17408,7 @@ declare class PartialUtils {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
         frameName: FrameName;
-    }, backtest?: boolean, path?: string, columns?: Columns$5[]) => Promise<void>;
+    }, backtest?: boolean, path?: string, columns?: Columns$6[]) => Promise<void>;
 }
 /**
  * Global singleton instance of PartialUtils.
@@ -16901,7 +17429,7 @@ declare const Partial$1: PartialUtils;
 /**
  * Type alias for column configuration used in highest profit markdown reports.
  */
-type Columns$4 = ColumnModel<HighestProfitEvent>;
+type Columns$5 = ColumnModel<HighestProfitEvent>;
 /**
  * Service for generating and saving highest profit markdown reports.
  *
@@ -16977,63 +17505,185 @@ declare class HighestProfitMarkdownService {
      *   `eventList` (newest first) and `totalEvents`
      * @throws {Error} If `subscribe()` has not been called before this method
      */
-    getData: (symbol: string, strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean) => Promise<HighestProfitStatisticsModel>;
+    getData: (symbol: string, strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean) => Promise<HighestProfitStatisticsModel>;
+    /**
+     * Generates a markdown highest profit report for the given context.
+     *
+     * Delegates to `ReportStorage.getReport`. The resulting string includes a
+     * markdown table (newest events first) followed by the total event count.
+     *
+     * @param symbol - Trading pair symbol (e.g. `"BTCUSDT"`)
+     * @param strategyName - Strategy identifier
+     * @param exchangeName - Exchange identifier (e.g. `"binance"`)
+     * @param frameName - Backtest frame identifier; empty string for live mode
+     * @param backtest - `true` for backtest mode, `false` for live mode
+     * @param columns - Column definitions controlling the table layout;
+     *   defaults to `COLUMN_CONFIG.highest_profit_columns`
+     * @returns Promise resolving to the full markdown string
+     * @throws {Error} If `subscribe()` has not been called before this method
+     */
+    getReport: (symbol: string, strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, columns?: Columns$5[]) => Promise<string>;
+    /**
+     * Generates the highest profit report and writes it to disk.
+     *
+     * Delegates to `ReportStorage.dump`. The filename follows the pattern:
+     * - Backtest: `{symbol}_{strategyName}_{exchangeName}_{frameName}_backtest-{timestamp}.md`
+     * - Live:     `{symbol}_{strategyName}_{exchangeName}_live-{timestamp}.md`
+     *
+     * @param symbol - Trading pair symbol (e.g. `"BTCUSDT"`)
+     * @param strategyName - Strategy identifier
+     * @param exchangeName - Exchange identifier (e.g. `"binance"`)
+     * @param frameName - Backtest frame identifier; empty string for live mode
+     * @param backtest - `true` for backtest mode, `false` for live mode
+     * @param path - Directory to write the file into; defaults to `"./dump/highest_profit"`
+     * @param columns - Column definitions for table formatting;
+     *   defaults to `COLUMN_CONFIG.highest_profit_columns`
+     * @throws {Error} If `subscribe()` has not been called before this method
+     */
+    dump: (symbol: string, strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, path?: string, columns?: Columns$5[]) => Promise<void>;
+    /**
+     * Evicts memoized `ReportStorage` instances, releasing all accumulated event data.
+     *
+     * - With `payload` — clears only the storage bucket identified by
+     *   `(symbol, strategyName, exchangeName, frameName, backtest)`;
+     *   subsequent calls for that combination start from an empty state.
+     * - Without `payload` — clears **all** storage buckets.
+     *
+     * Also called internally by the unsubscribe closure returned from `subscribe()`.
+     *
+     * @param payload - Optional scope to restrict which bucket is cleared;
+     *   omit to clear everything
+     *
+     * @example
+     * ```typescript
+     * // Clear one specific context
+     * await service.clear({ symbol: "BTCUSDT", strategyName: "my-strategy", exchangeName: "binance", frameName: "1m-btc", backtest: true });
+     *
+     * // Clear all contexts
+     * await service.clear();
+     * ```
+     */
+    clear: (payload?: {
+        symbol: string;
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+        backtest: boolean;
+    }) => Promise<void>;
+}
+
+/**
+ * Utility class for accessing highest profit reports and statistics.
+ *
+ * Provides static-like methods (via singleton instance) to retrieve data
+ * accumulated by HighestProfitMarkdownService from highestProfitSubject events.
+ *
+ * @example
+ * ```typescript
+ * import { HighestProfit } from "backtest-kit";
+ *
+ * const stats = await HighestProfit.getData("BTCUSDT", { strategyName, exchangeName, frameName });
+ * const report = await HighestProfit.getReport("BTCUSDT", { strategyName, exchangeName, frameName });
+ * await HighestProfit.dump("BTCUSDT", { strategyName, exchangeName, frameName });
+ * ```
+ */
+declare class HighestProfitUtils {
+    /**
+     * Retrieves statistical data from accumulated highest profit events.
+     *
+     * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+     * @param context - Execution context
+     * @param backtest - Whether to query backtest data
+     * @returns Promise resolving to HighestProfitStatisticsModel
+     */
+    getData: (symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }, backtest?: boolean) => Promise<HighestProfitStatisticsModel>;
+    /**
+     * Generates a markdown report with all highest profit events for a symbol-strategy pair.
+     *
+     * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+     * @param context - Execution context
+     * @param backtest - Whether to query backtest data
+     * @param columns - Optional column configuration
+     * @returns Promise resolving to markdown formatted report string
+     */
+    getReport: (symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }, backtest?: boolean, columns?: Columns$5[]) => Promise<string>;
+    /**
+     * Generates and saves a markdown report to file.
+     *
+     * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+     * @param context - Execution context
+     * @param backtest - Whether to query backtest data
+     * @param path - Output directory path (default: "./dump/highest_profit")
+     * @param columns - Optional column configuration
+     */
+    dump: (symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }, backtest?: boolean, path?: string, columns?: Columns$5[]) => Promise<void>;
+}
+/**
+ * Global singleton instance of HighestProfitUtils.
+ */
+declare const HighestProfit: HighestProfitUtils;
+
+/**
+ * Type alias for column configuration used in max drawdown markdown reports.
+ */
+type Columns$4 = ColumnModel<MaxDrawdownEvent>;
+/**
+ * Service for generating and saving max drawdown markdown reports.
+ *
+ * Listens to maxDrawdownSubject and accumulates events per
+ * symbol-strategy-exchange-frame combination. Provides getData(),
+ * getReport(), and dump() methods matching the HighestProfit pattern.
+ */
+declare class MaxDrawdownMarkdownService {
+    private readonly loggerService;
+    private getStorage;
+    /**
+     * Subscribes to `maxDrawdownSubject` to start receiving `MaxDrawdownContract`
+     * events. Protected against multiple subscriptions via `singleshot`.
+     *
+     * @returns Unsubscribe function; calling it tears down the subscription and
+     *   clears all accumulated data
+     */
+    subscribe: (() => () => void) & functools_kit.ISingleshotClearable;
+    /**
+     * Detaches from `maxDrawdownSubject` and clears all accumulated data.
+     *
+     * If `subscribe()` was never called, does nothing.
+     */
+    unsubscribe: () => Promise<void>;
+    /**
+     * Handles a single `MaxDrawdownContract` event emitted by `maxDrawdownSubject`.
+     */
+    private tick;
     /**
-     * Generates a markdown highest profit report for the given context.
-     *
-     * Delegates to `ReportStorage.getReport`. The resulting string includes a
-     * markdown table (newest events first) followed by the total event count.
-     *
-     * @param symbol - Trading pair symbol (e.g. `"BTCUSDT"`)
-     * @param strategyName - Strategy identifier
-     * @param exchangeName - Exchange identifier (e.g. `"binance"`)
-     * @param frameName - Backtest frame identifier; empty string for live mode
-     * @param backtest - `true` for backtest mode, `false` for live mode
-     * @param columns - Column definitions controlling the table layout;
-     *   defaults to `COLUMN_CONFIG.highest_profit_columns`
-     * @returns Promise resolving to the full markdown string
-     * @throws {Error} If `subscribe()` has not been called before this method
+     * Returns accumulated max drawdown statistics for the given context.
+     */
+    getData: (symbol: string, strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean) => Promise<MaxDrawdownStatisticsModel>;
+    /**
+     * Generates a markdown max drawdown report for the given context.
      */
     getReport: (symbol: string, strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, columns?: Columns$4[]) => Promise<string>;
     /**
-     * Generates the highest profit report and writes it to disk.
-     *
-     * Delegates to `ReportStorage.dump`. The filename follows the pattern:
-     * - Backtest: `{symbol}_{strategyName}_{exchangeName}_{frameName}_backtest-{timestamp}.md`
-     * - Live:     `{symbol}_{strategyName}_{exchangeName}_live-{timestamp}.md`
-     *
-     * @param symbol - Trading pair symbol (e.g. `"BTCUSDT"`)
-     * @param strategyName - Strategy identifier
-     * @param exchangeName - Exchange identifier (e.g. `"binance"`)
-     * @param frameName - Backtest frame identifier; empty string for live mode
-     * @param backtest - `true` for backtest mode, `false` for live mode
-     * @param path - Directory to write the file into; defaults to `"./dump/highest_profit"`
-     * @param columns - Column definitions for table formatting;
-     *   defaults to `COLUMN_CONFIG.highest_profit_columns`
-     * @throws {Error} If `subscribe()` has not been called before this method
+     * Generates the max drawdown report and writes it to disk.
      */
     dump: (symbol: string, strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, path?: string, columns?: Columns$4[]) => Promise<void>;
     /**
      * Evicts memoized `ReportStorage` instances, releasing all accumulated event data.
      *
-     * - With `payload` — clears only the storage bucket identified by
-     *   `(symbol, strategyName, exchangeName, frameName, backtest)`;
-     *   subsequent calls for that combination start from an empty state.
+     * - With `payload` — clears only the storage bucket for that combination.
      * - Without `payload` — clears **all** storage buckets.
-     *
-     * Also called internally by the unsubscribe closure returned from `subscribe()`.
-     *
-     * @param payload - Optional scope to restrict which bucket is cleared;
-     *   omit to clear everything
-     *
-     * @example
-     * ```typescript
-     * // Clear one specific context
-     * await service.clear({ symbol: "BTCUSDT", strategyName: "my-strategy", exchangeName: "binance", frameName: "1m-btc", backtest: true });
-     *
-     * // Clear all contexts
-     * await service.clear();
-     * ```
      */
     clear: (payload?: {
         symbol: string;
@@ -17045,36 +17695,36 @@ declare class HighestProfitMarkdownService {
 }
 
 /**
- * Utility class for accessing highest profit reports and statistics.
+ * Utility class for accessing max drawdown reports and statistics.
  *
  * Provides static-like methods (via singleton instance) to retrieve data
- * accumulated by HighestProfitMarkdownService from highestProfitSubject events.
+ * accumulated by MaxDrawdownMarkdownService from maxDrawdownSubject events.
  *
  * @example
  * ```typescript
- * import { HighestProfit } from "backtest-kit";
+ * import { MaxDrawdown } from "backtest-kit";
  *
- * const stats = await HighestProfit.getData("BTCUSDT", { strategyName, exchangeName, frameName });
- * const report = await HighestProfit.getReport("BTCUSDT", { strategyName, exchangeName, frameName });
- * await HighestProfit.dump("BTCUSDT", { strategyName, exchangeName, frameName });
+ * const stats = await MaxDrawdown.getData("BTCUSDT", { strategyName, exchangeName, frameName });
+ * const report = await MaxDrawdown.getReport("BTCUSDT", { strategyName, exchangeName, frameName });
+ * await MaxDrawdown.dump("BTCUSDT", { strategyName, exchangeName, frameName });
  * ```
  */
-declare class HighestProfitUtils {
+declare class MaxDrawdownUtils {
     /**
-     * Retrieves statistical data from accumulated highest profit events.
+     * Retrieves statistical data from accumulated max drawdown events.
      *
      * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
      * @param context - Execution context
      * @param backtest - Whether to query backtest data
-     * @returns Promise resolving to HighestProfitStatisticsModel
+     * @returns Promise resolving to MaxDrawdownStatisticsModel
      */
     getData: (symbol: string, context: {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
         frameName: FrameName;
-    }, backtest?: boolean) => Promise<HighestProfitStatisticsModel>;
+    }, backtest?: boolean) => Promise<MaxDrawdownStatisticsModel>;
     /**
-     * Generates a markdown report with all highest profit events for a symbol-strategy pair.
+     * Generates a markdown report with all max drawdown events for a symbol-strategy pair.
      *
      * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
      * @param context - Execution context
@@ -17093,7 +17743,7 @@ declare class HighestProfitUtils {
      * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
      * @param context - Execution context
      * @param backtest - Whether to query backtest data
-     * @param path - Output directory path (default: "./dump/highest_profit")
+     * @param path - Output directory path (default: "./dump/max_drawdown")
      * @param columns - Optional column configuration
      */
     dump: (symbol: string, context: {
@@ -17103,9 +17753,9 @@ declare class HighestProfitUtils {
     }, backtest?: boolean, path?: string, columns?: Columns$4[]) => Promise<void>;
 }
 /**
- * Global singleton instance of HighestProfitUtils.
+ * Global singleton instance of MaxDrawdownUtils.
  */
-declare const HighestProfit: HighestProfitUtils;
+declare const MaxDrawdown: MaxDrawdownUtils;
 
 /**
  * Utility class containing predefined trading constants for take-profit and stop-loss levels.
@@ -21946,6 +22596,12 @@ declare const backtestScheduleOpenSubject: Subject<IStrategyTickResultOpened>;
  * Allows users to track profit milestones and implement custom management logic based on profit levels.
  */
 declare const highestProfitSubject: Subject<HighestProfitContract>;
+/**
+ * Max drawdown emitter for real-time risk tracking.
+ * Emits updates on the maximum drawdown experienced for an open position.
+ * Allows users to track drawdown levels and implement custom risk management logic based on drawdown thresholds.
+ */
+declare const maxDrawdownSubject: Subject<MaxDrawdownContract>;
 
 declare const emitters_activePingSubject: typeof activePingSubject;
 declare const emitters_backtestScheduleOpenSubject: typeof backtestScheduleOpenSubject;
@@ -21956,6 +22612,7 @@ declare const emitters_doneWalkerSubject: typeof doneWalkerSubject;
 declare const emitters_errorEmitter: typeof errorEmitter;
 declare const emitters_exitEmitter: typeof exitEmitter;
 declare const emitters_highestProfitSubject: typeof highestProfitSubject;
+declare const emitters_maxDrawdownSubject: typeof maxDrawdownSubject;
 declare const emitters_partialLossSubject: typeof partialLossSubject;
 declare const emitters_partialProfitSubject: typeof partialProfitSubject;
 declare const emitters_performanceEmitter: typeof performanceEmitter;
@@ -21974,7 +22631,7 @@ declare const emitters_walkerCompleteSubject: typeof walkerCompleteSubject;
 declare const emitters_walkerEmitter: typeof walkerEmitter;
 declare const emitters_walkerStopSubject: typeof walkerStopSubject;
 declare namespace emitters {
-  export { emitters_activePingSubject as activePingSubject, emitters_backtestScheduleOpenSubject as backtestScheduleOpenSubject, emitters_breakevenSubject as breakevenSubject, emitters_doneBacktestSubject as doneBacktestSubject, emitters_doneLiveSubject as doneLiveSubject, emitters_doneWalkerSubject as doneWalkerSubject, emitters_errorEmitter as errorEmitter, emitters_exitEmitter as exitEmitter, emitters_highestProfitSubject as highestProfitSubject, emitters_partialLossSubject as partialLossSubject, emitters_partialProfitSubject as partialProfitSubject, emitters_performanceEmitter as performanceEmitter, emitters_progressBacktestEmitter as progressBacktestEmitter, emitters_progressWalkerEmitter as progressWalkerEmitter, emitters_riskSubject as riskSubject, emitters_schedulePingSubject as schedulePingSubject, emitters_shutdownEmitter as shutdownEmitter, emitters_signalBacktestEmitter as signalBacktestEmitter, emitters_signalEmitter as signalEmitter, emitters_signalLiveEmitter as signalLiveEmitter, emitters_strategyCommitSubject as strategyCommitSubject, emitters_syncSubject as syncSubject, emitters_validationSubject as validationSubject, emitters_walkerCompleteSubject as walkerCompleteSubject, emitters_walkerEmitter as walkerEmitter, emitters_walkerStopSubject as walkerStopSubject };
+  export { emitters_activePingSubject as activePingSubject, emitters_backtestScheduleOpenSubject as backtestScheduleOpenSubject, emitters_breakevenSubject as breakevenSubject, emitters_doneBacktestSubject as doneBacktestSubject, emitters_doneLiveSubject as doneLiveSubject, emitters_doneWalkerSubject as doneWalkerSubject, emitters_errorEmitter as errorEmitter, emitters_exitEmitter as exitEmitter, emitters_highestProfitSubject as highestProfitSubject, emitters_maxDrawdownSubject as maxDrawdownSubject, emitters_partialLossSubject as partialLossSubject, emitters_partialProfitSubject as partialProfitSubject, emitters_performanceEmitter as performanceEmitter, emitters_progressBacktestEmitter as progressBacktestEmitter, emitters_progressWalkerEmitter as progressWalkerEmitter, emitters_riskSubject as riskSubject, emitters_schedulePingSubject as schedulePingSubject, emitters_shutdownEmitter as shutdownEmitter, emitters_signalBacktestEmitter as signalBacktestEmitter, emitters_signalEmitter as signalEmitter, emitters_signalLiveEmitter as signalLiveEmitter, emitters_strategyCommitSubject as strategyCommitSubject, emitters_syncSubject as syncSubject, emitters_validationSubject as validationSubject, emitters_walkerCompleteSubject as walkerCompleteSubject, emitters_walkerEmitter as walkerEmitter, emitters_walkerStopSubject as walkerStopSubject };
 }
 
 /**
@@ -24010,6 +24667,110 @@ declare class StrategyConnectionService implements TStrategy$1 {
         exchangeName: ExchangeName;
         frameName: FrameName;
     }) => Promise<number | null>;
+    /**
+     * Returns the number of minutes elapsed since the highest profit price was recorded.
+     *
+     * Alias for getPositionDrawdownMinutes — measures how long the position has been
+     * pulling back from its peak profit level.
+     *
+     * Resolves current timestamp via timeMetaService and delegates to
+     * ClientStrategy.getPositionHighestProfitMinutes().
+     * 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 minutes since last profit peak or null
+     */
+    getPositionHighestProfitMinutes: (backtest: boolean, symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<number | null>;
+    /**
+     * Returns the number of minutes elapsed since the worst loss price was recorded.
+     *
+     * Measures how long ago the deepest drawdown point occurred.
+     * Zero when called at the exact moment the trough was set.
+     *
+     * Resolves current timestamp via timeMetaService and delegates to
+     * ClientStrategy.getPositionMaxDrawdownMinutes().
+     * 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 minutes since last drawdown trough or null
+     */
+    getPositionMaxDrawdownMinutes: (backtest: boolean, symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<number | null>;
+    /**
+     * Returns the worst price reached in the loss direction during this position's life.
+     *
+     * Delegates to ClientStrategy.getPositionMaxDrawdownPrice().
+     * 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 price or null
+     */
+    getPositionMaxDrawdownPrice: (backtest: boolean, symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<number | null>;
+    /**
+     * Returns the timestamp when the worst loss price was recorded during this position's life.
+     *
+     * Delegates to ClientStrategy.getPositionMaxDrawdownTimestamp().
+     * 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 timestamp in milliseconds or null
+     */
+    getPositionMaxDrawdownTimestamp: (backtest: boolean, symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<number | null>;
+    /**
+     * Returns the PnL percentage at the moment the worst loss price was recorded during this position's life.
+     *
+     * Delegates to ClientStrategy.getPositionMaxDrawdownPnlPercentage().
+     * 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 PnL percentage or null
+     */
+    getPositionMaxDrawdownPnlPercentage: (backtest: boolean, symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<number | null>;
+    /**
+     * Returns the PnL cost (in quote currency) at the moment the worst loss price was recorded during this position's life.
+     *
+     * Delegates to ClientStrategy.getPositionMaxDrawdownPnlCost().
+     * 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 PnL cost or null
+     */
+    getPositionMaxDrawdownPnlCost: (backtest: boolean, symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<number | null>;
     /**
      * Disposes the ClientStrategy instance for the given context.
      *
@@ -25887,6 +26648,96 @@ declare class StrategyCoreService implements TStrategy {
         exchangeName: ExchangeName;
         frameName: FrameName;
     }) => Promise<number | null>;
+    /**
+     * Returns the number of minutes elapsed since the highest profit price was recorded.
+     *
+     * Alias for getPositionDrawdownMinutes — measures how long the position has been
+     * pulling back from its peak profit level.
+     *
+     * Validates strategy existence and delegates to connection service.
+     * 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 minutes since last profit peak or null
+     */
+    getPositionHighestProfitMinutes: (backtest: boolean, symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<number | null>;
+    /**
+     * Returns the number of minutes elapsed since the worst loss price was recorded.
+     *
+     * Measures how long ago the deepest drawdown point occurred.
+     * Zero when called at the exact moment the trough was set.
+     *
+     * Validates strategy existence and delegates to connection service.
+     * 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 minutes since last drawdown trough or null
+     */
+    getPositionMaxDrawdownMinutes: (backtest: boolean, symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<number | null>;
+    /**
+     * Returns the worst price reached in the loss direction during this position's life.
+     *
+     * @param backtest - Whether running in backtest mode
+     * @param symbol - Trading pair symbol
+     * @param context - Execution context with strategyName, exchangeName, frameName
+     * @returns Promise resolving to price or null
+     */
+    getPositionMaxDrawdownPrice: (backtest: boolean, symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<number | null>;
+    /**
+     * Returns the timestamp when the worst loss price was recorded during this position's life.
+     *
+     * @param backtest - Whether running in backtest mode
+     * @param symbol - Trading pair symbol
+     * @param context - Execution context with strategyName, exchangeName, frameName
+     * @returns Promise resolving to timestamp in milliseconds or null
+     */
+    getPositionMaxDrawdownTimestamp: (backtest: boolean, symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<number | null>;
+    /**
+     * Returns the PnL percentage at the moment the worst loss price was recorded during this position's life.
+     *
+     * @param backtest - Whether running in backtest mode
+     * @param symbol - Trading pair symbol
+     * @param context - Execution context with strategyName, exchangeName, frameName
+     * @returns Promise resolving to PnL percentage or null
+     */
+    getPositionMaxDrawdownPnlPercentage: (backtest: boolean, symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<number | null>;
+    /**
+     * Returns the PnL cost (in quote currency) at the moment the worst loss price was recorded during this position's life.
+     *
+     * @param backtest - Whether running in backtest mode
+     * @param symbol - Trading pair symbol
+     * @param context - Execution context with strategyName, exchangeName, frameName
+     * @returns Promise resolving to PnL cost or null
+     */
+    getPositionMaxDrawdownPnlCost: (backtest: boolean, symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<number | null>;
 }
 
 /**
@@ -28426,6 +29277,52 @@ declare class HighestProfitReportService {
     unsubscribe: () => Promise<void>;
 }
 
+/**
+ * Service for logging max drawdown events to the JSONL report database.
+ *
+ * Listens to maxDrawdownSubject and writes each new drawdown record to
+ * Report.writeData() for persistence and analytics.
+ */
+declare class MaxDrawdownReportService {
+    private readonly loggerService;
+    /**
+     * Handles a single `MaxDrawdownContract` event emitted by `maxDrawdownSubject`.
+     *
+     * Writes a JSONL record to the `"max_drawdown"` report database via
+     * `Report.writeData`, capturing the full signal snapshot at the moment
+     * the new drawdown record was set:
+     * - `timestamp`, `symbol`, `strategyName`, `exchangeName`, `frameName`, `backtest`
+     * - `signalId`, `position`, `currentPrice`
+     * - `priceOpen`, `priceTakeProfit`, `priceStopLoss` (effective values from the signal)
+     *
+     * `strategyName` and signal-level fields are sourced from `data.signal`
+     * rather than the contract root.
+     *
+     * @param data - `MaxDrawdownContract` payload containing `symbol`,
+     *   `signal`, `currentPrice`, `backtest`, `timestamp`, `exchangeName`,
+     *   `frameName`
+     */
+    private tick;
+    /**
+     * Subscribes to `maxDrawdownSubject` to start persisting drawdown records.
+     * Protected against multiple subscriptions via `singleshot` — subsequent
+     * calls return the same unsubscribe function without re-subscribing.
+     *
+     * The returned unsubscribe function clears the `singleshot` state and
+     * detaches from `maxDrawdownSubject`.
+     *
+     * @returns Unsubscribe function; calling it tears down the subscription
+     */
+    subscribe: (() => () => void) & functools_kit.ISingleshotClearable;
+    /**
+     * Detaches from `maxDrawdownSubject`, stopping further JSONL writes.
+     *
+     * Calls the unsubscribe closure returned by `subscribe()`.
+     * If `subscribe()` was never called, does nothing.
+     */
+    unsubscribe: () => Promise<void>;
+}
+
 declare const backtest: {
     exchangeValidationService: ExchangeValidationService;
     strategyValidationService: StrategyValidationService;
@@ -28448,6 +29345,7 @@ declare const backtest: {
     strategyReportService: StrategyReportService;
     syncReportService: SyncReportService;
     highestProfitReportService: HighestProfitReportService;
+    maxDrawdownReportService: MaxDrawdownReportService;
     backtestMarkdownService: BacktestMarkdownService;
     liveMarkdownService: LiveMarkdownService;
     scheduleMarkdownService: ScheduleMarkdownService;
@@ -28460,6 +29358,7 @@ declare const backtest: {
     strategyMarkdownService: StrategyMarkdownService;
     syncMarkdownService: SyncMarkdownService;
     highestProfitMarkdownService: HighestProfitMarkdownService;
+    maxDrawdownMarkdownService: MaxDrawdownMarkdownService;
     backtestLogicPublicService: BacktestLogicPublicService;
     liveLogicPublicService: LiveLogicPublicService;
     walkerLogicPublicService: WalkerLogicPublicService;
@@ -28579,4 +29478,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, type BreakevenEvent, type BreakevenStatisticsModel, Broker, type BrokerAverageBuyPayload, BrokerBase, type BrokerBreakevenPayload, type BrokerPartialLossPayload, type BrokerPartialProfitPayload, type BrokerSignalClosePayload, type BrokerSignalOpenPayload, type BrokerTrailingStopPayload, type BrokerTrailingTakePayload, Cache, type CancelScheduledCommit, type CancelScheduledCommitNotification, type CandleData, type CandleInterval, type ClosePendingCommit, type ClosePendingCommitNotification, type ColumnConfig, type ColumnModel, Constant, type CriticalErrorNotification, type DoneContract, Dump, type EntityId, Exchange, ExecutionContextService, type FrameInterval, type GlobalConfig, Heat, type HeatmapStatisticsModel, HighestProfit, type HighestProfitContract, type HighestProfitEvent, type HighestProfitStatisticsModel, type IActionSchema, type IActivateScheduledCommitRow, type IAggregatedTradeData, type IBidData, type IBreakevenCommitRow, type IBroker, type ICandleData, type ICommitRow, type IDumpContext, type IDumpInstance, type IExchangeSchema, type IFrameSchema, type IHeatmapRow, type ILog, type ILogEntry, type ILogger, type IMarkdownDumpOptions, type IMemoryInstance, 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, Memory, type MemoryData, type MessageModel, type MessageRole, type MessageToolCall, 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, PersistMemoryAdapter, 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 TDumpInstanceCtor, type TLogCtor, type TMarkdownBase, type TMemoryInstanceCtor, 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, dumpAgentAnswer, dumpError, dumpJson, dumpRecord, dumpTable, dumpText, emitters, formatPrice, formatQuantity, get, getActionSchema, getAggregatedTrades, getAveragePrice, getBacktestTimeframe, getBreakeven, getCandles, getColumns, getConfig, getContext, getDate, getDefaultColumns, getDefaultConfig, getEffectivePriceOpen, getExchangeSchema, getFrameSchema, getMode, getNextCandles, getOrderBook, getPendingSignal, getPositionCountdownMinutes, getPositionDrawdownMinutes, getPositionEffectivePrice, getPositionEntries, getPositionEntryOverlap, getPositionEstimateMinutes, getPositionHighestPnlCost, getPositionHighestPnlPercentage, getPositionHighestProfitBreakeven, getPositionHighestProfitPrice, getPositionHighestProfitTimestamp, getPositionInvestedCost, getPositionInvestedCount, getPositionLevels, getPositionPartialOverlap, getPositionPartials, getPositionPnlCost, getPositionPnlPercent, getRawCandles, getRiskSchema, getScheduledSignal, getSizingSchema, getStrategySchema, getSymbol, getTimestamp, getTotalClosed, getTotalCostClosed, getTotalPercentClosed, getWalkerSchema, hasNoPendingSignal, hasNoScheduledSignal, hasTradeContext, investedCostToPercent, backtest as lib, listExchangeSchema, listFrameSchema, listMemory, listRiskSchema, listSizingSchema, listStrategySchema, listWalkerSchema, listenActivePing, listenActivePingOnce, listenBacktestProgress, listenBreakevenAvailable, listenBreakevenAvailableOnce, listenDoneBacktest, listenDoneBacktestOnce, listenDoneLive, listenDoneLiveOnce, listenDoneWalker, listenDoneWalkerOnce, listenError, listenExit, listenHighestProfit, listenHighestProfitOnce, 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, readMemory, removeMemory, roundTicks, searchMemory, set, setColumns, setConfig, setLogger, shutdown, slPercentShiftToPrice, slPriceToPercentShift, stopStrategy, toProfitLossDto, tpPercentShiftToPrice, tpPriceToPercentShift, validate, validateCommonSignal, validatePendingSignal, validateScheduledSignal, validateSignal, waitForCandle, warmCandles, writeMemory };
+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, type BreakevenEvent, type BreakevenStatisticsModel, Broker, type BrokerAverageBuyPayload, BrokerBase, type BrokerBreakevenPayload, type BrokerPartialLossPayload, type BrokerPartialProfitPayload, type BrokerSignalClosePayload, type BrokerSignalOpenPayload, type BrokerTrailingStopPayload, type BrokerTrailingTakePayload, Cache, type CancelScheduledCommit, type CancelScheduledCommitNotification, type CandleData, type CandleInterval, type ClosePendingCommit, type ClosePendingCommitNotification, type ColumnConfig, type ColumnModel, Constant, type CriticalErrorNotification, type DoneContract, Dump, type EntityId, Exchange, ExecutionContextService, type FrameInterval, type GlobalConfig, Heat, type HeatmapStatisticsModel, HighestProfit, type HighestProfitContract, type HighestProfitEvent, type HighestProfitStatisticsModel, type IActionSchema, type IActivateScheduledCommitRow, type IAggregatedTradeData, type IBidData, type IBreakevenCommitRow, type IBroker, type ICandleData, type ICommitRow, type IDumpContext, type IDumpInstance, type IExchangeSchema, type IFrameSchema, type IHeatmapRow, type ILog, type ILogEntry, type ILogger, type IMarkdownDumpOptions, type IMemoryInstance, 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, MaxDrawdown, type MaxDrawdownContract, type MaxDrawdownEvent, type MaxDrawdownStatisticsModel, type MeasureData, Memory, type MemoryData, type MessageModel, type MessageRole, type MessageToolCall, 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, PersistMemoryAdapter, 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 TDumpInstanceCtor, type TLogCtor, type TMarkdownBase, type TMemoryInstanceCtor, 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, dumpAgentAnswer, dumpError, dumpJson, dumpRecord, dumpTable, dumpText, emitters, formatPrice, formatQuantity, get, getActionSchema, getAggregatedTrades, getAveragePrice, getBacktestTimeframe, getBreakeven, getCandles, getColumns, getConfig, getContext, getDate, getDefaultColumns, getDefaultConfig, getEffectivePriceOpen, getExchangeSchema, getFrameSchema, getMode, getNextCandles, getOrderBook, getPendingSignal, getPositionCountdownMinutes, getPositionDrawdownMinutes, getPositionEffectivePrice, getPositionEntries, getPositionEntryOverlap, getPositionEstimateMinutes, getPositionHighestPnlCost, getPositionHighestPnlPercentage, getPositionHighestProfitBreakeven, getPositionHighestProfitMinutes, getPositionHighestProfitPrice, getPositionHighestProfitTimestamp, getPositionInvestedCost, getPositionInvestedCount, getPositionLevels, getPositionMaxDrawdownMinutes, getPositionMaxDrawdownPnlCost, getPositionMaxDrawdownPnlPercentage, getPositionMaxDrawdownPrice, getPositionMaxDrawdownTimestamp, getPositionPartialOverlap, getPositionPartials, getPositionPnlCost, getPositionPnlPercent, getRawCandles, getRiskSchema, getScheduledSignal, getSizingSchema, getStrategySchema, getSymbol, getTimestamp, getTotalClosed, getTotalCostClosed, getTotalPercentClosed, getWalkerSchema, hasNoPendingSignal, hasNoScheduledSignal, hasTradeContext, investedCostToPercent, backtest as lib, listExchangeSchema, listFrameSchema, listMemory, listRiskSchema, listSizingSchema, listStrategySchema, listWalkerSchema, listenActivePing, listenActivePingOnce, listenBacktestProgress, listenBreakevenAvailable, listenBreakevenAvailableOnce, listenDoneBacktest, listenDoneBacktestOnce, listenDoneLive, listenDoneLiveOnce, listenDoneWalker, listenDoneWalkerOnce, listenError, listenExit, listenHighestProfit, listenHighestProfitOnce, listenMaxDrawdown, listenMaxDrawdownOnce, 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, readMemory, removeMemory, roundTicks, runInMockContext, searchMemory, set, setColumns, setConfig, setLogger, shutdown, slPercentShiftToPrice, slPriceToPercentShift, stopStrategy, toProfitLossDto, tpPercentShiftToPrice, tpPriceToPercentShift, validate, validateCommonSignal, validatePendingSignal, validateScheduledSignal, validateSignal, waitForCandle, warmCandles, writeMemory };