backtest-kit 3.6.0 → 3.7.1

package/types.d.ts

@@ -1959,6 +1959,23 @@ interface ISignalRow extends ISignalDto {
         percent: number;
         /** Price at which this partial was executed */
         price: number;
+        /** Debug only timestamp in milliseconds */
+        debugTimestamp?: number;
+        /**
+         * Effective entry price (DCA average) at the moment this partial close was executed.
+         * Captured from GET_EFFECTIVE_PRICE_OPEN at partial close time.
+         * Used in PNL calculation when averageBuy() is called after partial closes,
+         * so each partial's profit is calculated against the correct entry price at that moment.
+         */
+        effectivePrice: number;
+        /**
+         * Entry count (number of entries in _entry history) at the moment this partial close was executed.
+         * Used to determine which entries are included in the effective price calculation for this partial close.
+         * When averageBuy() is called after partial closes, new entries are added to _entry, but they should not affect the effective price used for already executed partial closes.
+         * By capturing entryCountAtClose, we can slice the _entry array to include only the entries that were part of the position at the time of this partial close when calculating the effective price for PNL.
+         * This ensures that each partial close's PNL is calculated against the correct average entry price, even if more averaging happens after the partial close.
+         */
+        entryCountAtClose: number;
     }>;
     /**
      * Trailing stop-loss price that overrides priceStopLoss when set.
@@ -1979,6 +1996,8 @@ interface ISignalRow extends ISignalDto {
     _entry?: Array<{
         /** Price at which this entry was executed */
         price: number;
+        /** Debug only timestamp in milliseconds */
+        debugTimestamp?: number;
     }>;
     /**
      * Trailing take-profit price that overrides priceTakeProfit when set.
@@ -2568,6 +2587,30 @@ interface IStrategy {
      * @returns Promise resolving to true if strategy is stopped, false otherwise
      */
     getStopped: (symbol: string) => Promise<boolean>;
+    /**
+     * Returns how much of the position is still held, as a percentage of totalInvested.
+     *
+     * Uses dollar-basis cost-basis replay (DCA-aware).
+     * 100% means nothing was closed yet. Decreases with each partial close.
+     *
+     * Returns 100 if no pending signal or no partial closes.
+     *
+     * @param symbol - Trading pair symbol
+     * @returns Promise resolving to held percentage (0–100)
+     */
+    getTotalPercentClosed: (symbol: string) => Promise<number | null>;
+    /**
+     * Returns how many dollars of cost basis are still held (not yet closed by partials).
+     *
+     * Full position open: equals totalInvested (entries × $100).
+     * Decreases with each partial close, increases with each averageBuy().
+     *
+     * Returns totalInvested if no pending signal or no partial closes.
+     *
+     * @param symbol - Trading pair symbol
+     * @returns Promise resolving to held cost basis in dollars
+     */
+    getTotalCostClosed: (symbol: string) => Promise<number | null>;
     /**
      * Fast backtest using historical candles.
      * Iterates through candles, calculates VWAP, checks TP/SL on each candle.
@@ -2989,10 +3032,12 @@ interface ILogEntry {
     id: string;
     /** Log level */
     type: "log" | "debug" | "info" | "warn";
-    /** Unix timestamp in milliseconds when the entry was created */
-    timestamp: number;
+    /** Current Unix timestamp in milliseconds for storage rotate */
+    priority: number;
     /** Date taken from backtest context to improve user experience */
     createdAt: string;
+    /** Unix timestamp in milliseconds taken from backtest context to improve user experience */
+    timestamp: number;
     /** Optional method context associated with the log entry, providing additional details about the execution environment or state when the log was recorded */
     methodContext: IMethodContext | null;
     /** Optional execution context associated with the log entry, providing additional details about the execution environment or state when the log was recorded */
@@ -4208,6 +4253,107 @@ declare function commitActivateScheduled(symbol: string, activateId?: string): P
  * ```
  */
 declare function commitAverageBuy(symbol: string): Promise<boolean>;
+/**
+ * Returns the percentage of the position currently held (not closed).
+ * 100 = nothing has been closed (full position), 0 = fully closed.
+ * Correctly accounts for DCA entries between partial closes.
+ *
+ * Automatically detects backtest/live mode from execution context.
+ *
+ * @param symbol - Trading pair symbol
+ * @returns Promise<number> - held percentage (0–100)
+ *
+ * @example
+ * ```typescript
+ * import { getTotalPercentClosed } from "backtest-kit";
+ *
+ * const heldPct = await getTotalPercentClosed("BTCUSDT");
+ * console.log(`Holding ${heldPct}% of position`);
+ * ```
+ */
+declare function getTotalPercentClosed(symbol: string): Promise<number>;
+/**
+ * Returns the cost basis in dollars of the position currently held (not closed).
+ * Correctly accounts for DCA entries between partial closes.
+ *
+ * Automatically detects backtest/live mode from execution context.
+ *
+ * @param symbol - Trading pair symbol
+ * @returns Promise<number> - held cost basis in dollars
+ *
+ * @example
+ * ```typescript
+ * import { getTotalCostClosed } from "backtest-kit";
+ *
+ * const heldCost = await getTotalCostClosed("BTCUSDT");
+ * console.log(`Holding $${heldCost} of position`);
+ * ```
+ */
+declare function getTotalCostClosed(symbol: string): Promise<number>;
+/**
+ * Returns the currently active pending signal for the strategy.
+ * If no active signal exists, returns null.
+ *
+ * Automatically detects backtest/live mode from execution context.
+ *
+ * @param symbol - Trading pair symbol
+ * @returns Promise resolving to pending signal or null
+ *
+ * @example
+ * ```typescript
+ * import { getPendingSignal } from "backtest-kit";
+ *
+ * const pending = await getPendingSignal("BTCUSDT");
+ * if (pending) {
+ *   console.log("Active signal:", pending.id);
+ * }
+ * ```
+ */
+declare function getPendingSignal(symbol: string): Promise<ISignalRow>;
+/**
+ * Returns the currently active scheduled signal for the strategy.
+ * If no scheduled signal exists, returns null.
+ *
+ * Automatically detects backtest/live mode from execution context.
+ *
+ * @param symbol - Trading pair symbol
+ * @returns Promise resolving to scheduled signal or null
+ *
+ * @example
+ * ```typescript
+ * import { getScheduledSignal } from "backtest-kit";
+ *
+ * const scheduled = await getScheduledSignal("BTCUSDT");
+ * if (scheduled) {
+ *   console.log("Scheduled signal:", scheduled.id);
+ * }
+ * ```
+ */
+declare function getScheduledSignal(symbol: string): Promise<IScheduledSignalRow>;
+/**
+ * Checks if breakeven threshold has been reached for the current pending signal.
+ *
+ * Returns true if price has moved far enough in profit direction to cover
+ * transaction costs. Threshold is calculated as: (CC_PERCENT_SLIPPAGE + CC_PERCENT_FEE) * 2
+ *
+ * Automatically detects backtest/live mode from execution context.
+ *
+ * @param symbol - Trading pair symbol
+ * @param currentPrice - Current market price to check against threshold
+ * @returns Promise<boolean> - true if breakeven threshold reached, false otherwise
+ *
+ * @example
+ * ```typescript
+ * import { getBreakeven, getAveragePrice } from "backtest-kit";
+ *
+ * const price = await getAveragePrice("BTCUSDT");
+ * const canBreakeven = await getBreakeven("BTCUSDT", price);
+ * if (canBreakeven) {
+ *   console.log("Breakeven available");
+ * }
+ * ```
+ */
+declare function getBreakeven(symbol: string, currentPrice: number): Promise<boolean>;
 
 /**
  * Stops the strategy from generating new signals.
@@ -4481,6 +4627,14 @@ declare const GLOBAL_CONFIG: {
      * Default: true (mutex locking enabled for candle fetching)
      */
     CC_ENABLE_CANDLE_FETCH_MUTEX: boolean;
+    /**
+     * Enables DCA (Dollar-Cost Averaging) logic even if antirecord is not broken.
+     * Allows to commitAverageBuy if currentPrice is not the lowest price since entry, but still lower than priceOpen.
+     * This can help improve average entry price in cases where price has rebounded after entry but is still below priceOpen, without waiting for a new lower price.
+     *
+     * Default: true (DCA logic enabled everywhere, not just when antirecord is broken)
+     */
+    CC_ENABLE_DCA_EVERYWHERE: boolean;
 };
 /**
  * Type for global configuration object.
@@ -4592,6 +4746,7 @@ declare function getConfig(): {
     CC_MAX_SIGNALS: number;
     CC_MAX_LOG_LINES: number;
     CC_ENABLE_CANDLE_FETCH_MUTEX: boolean;
+    CC_ENABLE_DCA_EVERYWHERE: boolean;
 };
 /**
  * Retrieves the default configuration object for the framework.
@@ -4631,6 +4786,7 @@ declare function getDefaultConfig(): Readonly<{
     CC_MAX_SIGNALS: number;
     CC_MAX_LOG_LINES: number;
     CC_ENABLE_CANDLE_FETCH_MUTEX: boolean;
+    CC_ENABLE_DCA_EVERYWHERE: boolean;
 }>;
 /**
  * Sets custom column configurations for markdown report generation.
@@ -4738,7 +4894,6 @@ declare function getDefaultColumns(): Readonly<{
  *     priceTakeProfit: 51000,
  *     priceStopLoss: 49000,
  *     minuteEstimatedTime: 60,
- *     timestamp: Date.now(),
  *   }),
  *   callbacks: {
  *     onOpen: (symbol, signal, currentPrice, backtest) => console.log("Signal opened"),
@@ -6859,6 +7014,20 @@ declare function formatQuantity(symbol: string, quantity: number): Promise<strin
  * ```
  */
 declare function getDate(): Promise<Date>;
+/**
+ * Gets the current timestamp from execution context.
+ *
+ * In backtest mode: returns the current timeframe timestamp being processed
+ * In live mode: returns current real-time timestamp
+ *
+ * @returns Promise resolving to current execution context timestamp in milliseconds
+ * @example
+ * ```typescript
+ * const timestamp = await getTimestamp();
+ * console.log(timestamp); // 1700000000000
+ * ```
+ */
+declare function getTimestamp(): Promise<number>;
 /**
  * Gets the current execution mode.
  *
@@ -8443,6 +8612,10 @@ declare const BASE_WAIT_FOR_INIT_SYMBOL: unique symbol;
  * Contains nullable signal for atomic updates.
  */
 type SignalData = ISignalRow | null;
+/**
+ * Cache.file data type stored in persistence layer.
+ */
+type MeasureData = unknown;
 /**
  * Type helper for PersistBase instance.
  */
@@ -9314,6 +9487,57 @@ declare class PersistLogUtils {
  * Used by LogPersistUtils for log entry persistence.
  */
 declare const PersistLogAdapter: PersistLogUtils;
+/**
+ * Utility class for managing external API response cache persistence.
+ *
+ * Features:
+ * - Memoized storage instances per cache bucket (aligned timestamp + symbol)
+ * - Custom adapter support
+ * - Atomic read/write operations
+ * - Crash-safe cache state management
+ *
+ * Used by Cache.file for persistent caching of external API responses.
+ */
+declare class PersistMeasureUtils {
+    private PersistMeasureFactory;
+    private getMeasureStorage;
+    /**
+     * Registers a custom persistence adapter.
+     *
+     * @param Ctor - Custom PersistBase constructor
+     */
+    usePersistMeasureAdapter(Ctor: TPersistBaseCtor<string, unknown>): void;
+    /**
+     * Reads cached measure data for a given bucket and key.
+     *
+     * @param bucket - Storage bucket (e.g. aligned timestamp + symbol)
+     * @param key - Dynamic cache key within the bucket
+     * @returns Promise resolving to cached value or null if not found
+     */
+    readMeasureData: (bucket: string, key: string) => Promise<MeasureData | null>;
+    /**
+     * Writes measure data to disk with atomic file writes.
+     *
+     * @param data - Data to cache
+     * @param bucket - Storage bucket (e.g. aligned timestamp + symbol)
+     * @param key - Dynamic cache key within the bucket
+     * @returns Promise that resolves when write is complete
+     */
+    writeMeasureData: (data: MeasureData, bucket: string, key: string) => Promise<void>;
+    /**
+     * Switches to the default JSON persist adapter.
+     */
+    useJson(): void;
+    /**
+     * Switches to a dummy persist adapter that discards all writes.
+     */
+    useDummy(): void;
+}
+/**
+ * Global singleton instance of PersistMeasureUtils.
+ * Used by Cache.file for persistent caching of external API responses.
+ */
+declare const PersistMeasureAdapter: PersistMeasureUtils;
 
 declare const WAIT_FOR_INIT_SYMBOL$1: unique symbol;
 declare const WRITE_SAFE_SYMBOL$1: unique symbol;
@@ -10312,6 +10536,45 @@ declare class BacktestUtils {
         exchangeName: ExchangeName;
         frameName: FrameName;
     }) => Promise<ISignalRow>;
+    /**
+     * Returns the percentage of the position currently held (not closed).
+     * 100 = nothing has been closed (full position), 0 = fully closed.
+     * Correctly accounts for DCA entries between partial closes.
+     *
+     * @param symbol - Trading pair symbol
+     * @param context - Context with strategyName, exchangeName, frameName
+     * @returns Promise<number> - held percentage (0–100)
+     *
+     * @example
+     * ```typescript
+     * const heldPct = await Backtest.getTotalPercentClosed("BTCUSDT", { strategyName, exchangeName, frameName });
+     * console.log(`Holding ${heldPct}% of position`);
+     * ```
+     */
+    getTotalPercentClosed: (symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<number>;
+    /**
+     * Returns the cost basis in dollars of the position currently held (not closed).
+     * Correctly accounts for DCA entries between partial closes.
+     *
+     * @param symbol - Trading pair symbol
+     * @param context - Context with strategyName, exchangeName, frameName
+     * @returns Promise<number> - held cost basis in dollars
+     *
+     * @example
+     * ```typescript
+     * const heldCost = await Backtest.getTotalCostClosed("BTCUSDT", { strategyName, exchangeName, frameName });
+     * console.log(`Holding $${heldCost} of position`);
+     * ```
+     */
+    getTotalCostClosed: (symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<number>;
     /**
      * Retrieves the currently active scheduled signal for the strategy.
      * If no scheduled signal exists, returns null.
@@ -11116,6 +11379,43 @@ declare class LiveUtils {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
     }) => Promise<ISignalRow>;
+    /**
+     * Returns the percentage of the position currently held (not closed).
+     * 100 = nothing has been closed (full position), 0 = fully closed.
+     * Correctly accounts for DCA entries between partial closes.
+     *
+     * @param symbol - Trading pair symbol
+     * @param context - Context with strategyName and exchangeName
+     * @returns Promise<number> - held percentage (0–100)
+     *
+     * @example
+     * ```typescript
+     * const heldPct = await Live.getTotalPercentClosed("BTCUSDT", { strategyName, exchangeName });
+     * console.log(`Holding ${heldPct}% of position`);
+     * ```
+     */
+    getTotalPercentClosed: (symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+    }) => Promise<number>;
+    /**
+     * Returns the cost basis in dollars of the position currently held (not closed).
+     * Correctly accounts for DCA entries between partial closes.
+     *
+     * @param symbol - Trading pair symbol
+     * @param context - Context with strategyName and exchangeName
+     * @returns Promise<number> - held cost basis in dollars
+     *
+     * @example
+     * ```typescript
+     * const heldCost = await Live.getTotalCostClosed("BTCUSDT", { strategyName, exchangeName });
+     * console.log(`Holding $${heldCost} of position`);
+     * ```
+     */
+    getTotalCostClosed: (symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+    }) => Promise<number>;
     /**
      * Retrieves the currently active scheduled signal for the strategy.
      * If no scheduled signal exists, returns null.
@@ -14559,6 +14859,30 @@ declare const Exchange: ExchangeUtils;
  * Used as a constraint for cached functions.
  */
 type Function = (...args: any[]) => any;
+/**
+ * Async function type for file-cached functions.
+ * First argument is always `symbol: string`, followed by optional spread args.
+ */
+type CacheFileFunction = (symbol: string, ...args: any[]) => Promise<any>;
+/**
+ * Utility type to drop the first argument from a function type.
+ * For example, for a function type `(symbol: string, arg1: number, arg2: string) => Promise<void>`,
+ * this type will infer the rest of the arguments as `[arg1: number, arg2: string]`.
+ */
+type DropFirst<T extends (...args: any) => any> = T extends (first: any, ...rest: infer R) => any ? R : never;
+/**
+ * Extracts the `key` generator argument tuple from a `CacheFileFunction`.
+ * The first two arguments are always `symbol: string` and `alignMs: number` (aligned timestamp),
+ * followed by the rest of the original function's arguments.
+ *
+ * For example, for a function type `(symbol: string, arg1: number, arg2: string) => Promise<void>`,
+ * this type will produce the tuple `[symbol: string, alignMs: number, arg1: number, arg2: string]`.
+ */
+type CacheFileKeyArgs<T extends CacheFileFunction> = [
+    symbol: string,
+    alignMs: number,
+    ...rest: DropFirst<T>
+];
 /**
  * Utility class for function caching with timeframe-based invalidation.
  *
@@ -14579,7 +14903,12 @@ declare class CacheUtils {
      * Memoized function to get or create CacheInstance for a function.
      * Each function gets its own isolated cache instance.
      */
-    private _getInstance;
+    private _getFnInstance;
+    /**
+     * Memoized function to get or create CacheFileInstance for an async function.
+     * Each function gets its own isolated file-cache instance.
+     */
+    private _getFileInstance;
     /**
      * Wrap a function with caching based on timeframe intervals.
      *
@@ -14617,6 +14946,49 @@ declare class CacheUtils {
         interval: CandleInterval;
         key?: (args: Parameters<T>) => K;
     }) => T;
+    /**
+     * Wrap an async function with persistent file-based caching.
+     *
+     * Returns a wrapped version of the function that reads from disk on cache hit
+     * and writes the result to disk on cache miss. Files are stored under
+     * `./dump/data/measure/{name}_{interval}_{index}/`.
+     *
+     * The `run` function reference is used as the memoization key for the underlying
+     * `CacheFileInstance`, so each unique function reference gets its own isolated instance.
+     * Pass the same function reference each time to reuse the same cache.
+     *
+     * @template T - Async function type to cache
+     * @param run - Async function to wrap with file caching
+     * @param context.interval - Candle interval for cache invalidation
+     * @param context.name - Human-readable bucket name; becomes the directory prefix
+     * @param context.key - Optional entity key generator. Receives `[symbol, alignMs, ...rest]`
+     *                      where `alignMs` is the timestamp aligned to `interval`.
+     *                      Default: `([symbol, alignMs]) => \`${symbol}_${alignMs}\``
+     * @returns Wrapped async function with automatic persistent caching
+     *
+     * @example
+     * ```typescript
+     * const fetchData = async (symbol: string, period: number) => {
+     *   return await externalApi.fetch(symbol, period);
+     * };
+     *
+     * // Default key — one cache file per symbol per aligned candle
+     * const cachedFetch = Cache.file(fetchData, { interval: "1h", name: "fetchData" });
+     *
+     * // Custom key — one cache file per symbol + period combination
+     * const cachedFetch = Cache.file(fetchData, {
+     *   interval: "1h",
+     *   name: "fetchData",
+     *   key: ([symbol, alignMs, period]) => `${symbol}_${alignMs}_${period}`,
+     * });
+     * const result = await cachedFetch("BTCUSDT", 14);
+     * ```
+     */
+    file: <T extends CacheFileFunction>(run: T, context: {
+        interval: CandleInterval;
+        name: string;
+        key?: (args: CacheFileKeyArgs<T>) => string;
+    }) => T;
     /**
      * Flush (remove) cached CacheInstance for a specific function or all functions.
      *
@@ -15175,6 +15547,35 @@ declare class StrategyCoreService implements TStrategy$1 {
         exchangeName: ExchangeName;
         frameName: FrameName;
     }) => Promise<ISignalRow | null>;
+    /**
+     * Returns the percentage of the position currently held (not closed).
+     * 100 = nothing has been closed (full position), 0 = fully closed.
+     * Correctly accounts for DCA entries between partial closes.
+     *
+     * @param backtest - Whether running in backtest mode
+     * @param symbol - Trading pair symbol
+     * @param context - Execution context with strategyName, exchangeName, frameName
+     * @returns Promise<number> - held percentage (0–100)
+     */
+    getTotalPercentClosed: (backtest: boolean, symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<number | null>;
+    /**
+     * Returns the cost basis in dollars of the position currently held (not closed).
+     * Correctly accounts for DCA entries between partial closes.
+     *
+     * @param backtest - Whether running in backtest mode
+     * @param symbol - Trading pair symbol
+     * @param context - Execution context with strategyName, exchangeName, frameName
+     * @returns Promise<number> - held cost basis in dollars
+     */
+    getTotalCostClosed: (backtest: boolean, symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<number | null>;
     /**
      * Retrieves the currently active scheduled signal for the symbol.
      * If no scheduled signal exists, returns null.
@@ -16582,7 +16983,7 @@ declare class ActionBase implements IPublicAction {
      * @example
      * ```typescript
      * pingScheduled(event: SchedulePingContract) {
-     *   const waitTime = Date.now() - event.data.timestampScheduled;
+     *   const waitTime = getTimestamp() - event.data.timestampScheduled;
      *   const waitMinutes = Math.floor(waitTime / 60000);
      *   console.log(`Scheduled signal waiting ${waitMinutes} minutes`);
      * }
@@ -16606,7 +17007,7 @@ declare class ActionBase implements IPublicAction {
      * @example
      * ```typescript
      * pingActive(event: ActivePingContract) {
-     *   const holdTime = Date.now() - event.data.pendingAt;
+     *   const holdTime = getTimestamp() - event.data.pendingAt;
      *   const holdMinutes = Math.floor(holdTime / 60000);
      *   console.log(`Active signal holding ${holdMinutes} minutes`);
      * }
@@ -18028,6 +18429,35 @@ declare class StrategyConnectionService implements TStrategy {
         exchangeName: ExchangeName;
         frameName: FrameName;
     }) => Promise<ISignalRow | null>;
+    /**
+     * Returns the percentage of the position currently held (not closed).
+     * 100 = nothing has been closed (full position), 0 = fully closed.
+     * Correctly accounts for DCA entries between partial closes.
+     *
+     * @param backtest - Whether running in backtest mode
+     * @param symbol - Trading pair symbol
+     * @param context - Execution context with strategyName, exchangeName, frameName
+     * @returns Promise<number> - held percentage (0–100)
+     */
+    getTotalPercentClosed: (backtest: boolean, symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<number | null>;
+    /**
+     * Returns the cost basis in dollars of the position currently held (not closed).
+     * Correctly accounts for DCA entries between partial closes.
+     *
+     * @param backtest - Whether running in backtest mode
+     * @param symbol - Trading pair symbol
+     * @param context - Execution context with strategyName, exchangeName, frameName
+     * @returns Promise<number> - held cost basis in dollars
+     */
+    getTotalCostClosed: (backtest: boolean, symbol: string, context: {
+        strategyName: StrategyName;
+        exchangeName: ExchangeName;
+        frameName: FrameName;
+    }) => Promise<number | null>;
     /**
      * Retrieves the currently active scheduled signal for the strategy.
      * If no scheduled signal exists, returns null.
@@ -21612,4 +22042,75 @@ declare const backtest: {
     loggerService: LoggerService;
 };
 
-export { ActionBase, type ActivateScheduledCommit, type ActivateScheduledCommitNotification, type ActivePingContract, type AverageBuyCommit, Backtest, type BacktestStatisticsModel, Breakeven, type BreakevenAvailableNotification, type BreakevenCommit, type BreakevenCommitNotification, type BreakevenContract, type BreakevenData, Cache, type CancelScheduledCommit, type CandleData, type CandleInterval, type ClosePendingCommit, type ColumnConfig, type ColumnModel, Constant, type CriticalErrorNotification, type DoneContract, type EntityId, Exchange, ExecutionContextService, type FrameInterval, type GlobalConfig, Heat, type HeatmapStatisticsModel, type IActionSchema, type IActivateScheduledCommitRow, type IAggregatedTradeData, type IBidData, type IBreakevenCommitRow, type ICandleData, type ICommitRow, type IExchangeSchema, type IFrameSchema, type IHeatmapRow, type ILog, type ILogEntry, type ILogger, type IMarkdownDumpOptions, type INotificationUtils, type IOrderBookData, type IPartialLossCommitRow, type IPartialProfitCommitRow, type IPersistBase, type IPositionSizeATRParams, type IPositionSizeFixedPercentageParams, type IPositionSizeKellyParams, type IPublicAction, type IPublicCandleData, type IPublicSignalRow, type IReportDumpOptions, type IRiskActivePosition, type IRiskCheckArgs, type IRiskSchema, type IRiskSignalRow, type IRiskValidation, type IRiskValidationFn, type IRiskValidationPayload, type IScheduledSignalCancelRow, type IScheduledSignalRow, type ISignalDto, type ISignalRow, type ISizingCalculateParams, type ISizingCalculateParamsATR, type ISizingCalculateParamsFixedPercentage, type ISizingCalculateParamsKelly, type ISizingParams, type ISizingParamsATR, type ISizingParamsFixedPercentage, type ISizingParamsKelly, type ISizingSchema, type ISizingSchemaATR, type ISizingSchemaFixedPercentage, type ISizingSchemaKelly, type IStorageSignalRow, type IStorageUtils, type IStrategyPnL, type IStrategyResult, type IStrategySchema, type IStrategyTickResult, type IStrategyTickResultActive, type IStrategyTickResultCancelled, type IStrategyTickResultClosed, type IStrategyTickResultIdle, type IStrategyTickResultOpened, type IStrategyTickResultScheduled, type IStrategyTickResultWaiting, type ITrailingStopCommitRow, type ITrailingTakeCommitRow, type IWalkerResults, type IWalkerSchema, type IWalkerStrategyResult, type InfoErrorNotification, Live, type LiveStatisticsModel, Log, type LogData, Markdown, MarkdownFileBase, MarkdownFolderBase, type MarkdownName, 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, PersistNotificationAdapter, PersistPartialAdapter, PersistRiskAdapter, PersistScheduleAdapter, PersistSignalAdapter, PersistStorageAdapter, PositionSize, type ProgressBacktestContract, type ProgressWalkerContract, Report, ReportBase, type ReportName, Risk, type RiskContract, type RiskData, type RiskEvent, type RiskRejectionNotification, type RiskStatisticsModel, Schedule, type ScheduleData, type SchedulePingContract, type ScheduleStatisticsModel, type ScheduledEvent, type SignalCancelledNotification, type SignalClosedNotification, type SignalData, type SignalInterval, type SignalOpenedNotification, type SignalScheduledNotification, Storage, StorageBacktest, type StorageData, StorageLive, Strategy, type StrategyActionType, type StrategyCancelReason, type StrategyCloseReason, type StrategyCommitContract, type StrategyEvent, type StrategyStatisticsModel, type TLogCtor, type TMarkdownBase, type TNotificationUtilsCtor, type TPersistBase, type TPersistBaseCtor, type TReportBase, type TStorageUtilsCtor, type TickEvent, type TrailingStopCommit, type TrailingStopCommitNotification, type TrailingTakeCommit, type TrailingTakeCommitNotification, type ValidationErrorNotification, Walker, type WalkerCompleteContract, type WalkerContract, type WalkerMetric, type SignalData$1 as WalkerSignalData, type WalkerStatisticsModel, addActionSchema, addExchangeSchema, addFrameSchema, addRiskSchema, addSizingSchema, addStrategySchema, addWalkerSchema, alignToInterval, checkCandles, commitActivateScheduled, commitAverageBuy, commitBreakeven, commitCancelScheduled, commitClosePending, commitPartialLoss, commitPartialProfit, commitTrailingStop, commitTrailingTake, dumpMessages, emitters, formatPrice, formatQuantity, get, getActionSchema, getAggregatedTrades, getAveragePrice, getBacktestTimeframe, getCandles, getColumns, getConfig, getContext, getDate, getDefaultColumns, getDefaultConfig, getExchangeSchema, getFrameSchema, getMode, getNextCandles, getOrderBook, getRawCandles, getRiskSchema, getSizingSchema, getStrategySchema, getSymbol, getWalkerSchema, hasTradeContext, backtest as lib, listExchangeSchema, listFrameSchema, listRiskSchema, listSizingSchema, listStrategySchema, listWalkerSchema, listenActivePing, listenActivePingOnce, listenBacktestProgress, listenBreakevenAvailable, listenBreakevenAvailableOnce, listenDoneBacktest, listenDoneBacktestOnce, listenDoneLive, listenDoneLiveOnce, listenDoneWalker, listenDoneWalkerOnce, listenError, listenExit, listenPartialLossAvailable, listenPartialLossAvailableOnce, listenPartialProfitAvailable, listenPartialProfitAvailableOnce, listenPerformance, listenRisk, listenRiskOnce, listenSchedulePing, listenSchedulePingOnce, listenSignal, listenSignalBacktest, listenSignalBacktestOnce, listenSignalLive, listenSignalLiveOnce, listenSignalOnce, listenStrategyCommit, listenStrategyCommitOnce, listenValidation, listenWalker, listenWalkerComplete, listenWalkerOnce, listenWalkerProgress, overrideActionSchema, overrideExchangeSchema, overrideFrameSchema, overrideRiskSchema, overrideSizingSchema, overrideStrategySchema, overrideWalkerSchema, parseArgs, roundTicks, set, setColumns, setConfig, setLogger, shutdown, stopStrategy, validate, waitForCandle, warmCandles };
+/**
+ * Calculates profit/loss for a closed signal with slippage and fees.
+ *
+ * For signals with partial closes:
+ * - Weights are calculated by ACTUAL DOLLAR VALUE of each partial relative to total invested.
+ *   This correctly handles DCA entries that occur before or after partial closes.
+ *
+ * Cost basis is reconstructed by replaying the partial sequence via entryCountAtClose + percent:
+ *   costBasis = 0
+ *   for each partial[i]:
+ *     costBasis += (entryCountAtClose[i] - entryCountAtClose[i-1]) × $100
+ *     partialDollarValue[i] = (percent[i] / 100) × costBasis
+ *     weight[i]             = partialDollarValue[i] / totalInvested
+ *     costBasis            *= (1 - percent[i] / 100)
+ *
+ * Fee structure:
+ *   - Open fee:  CC_PERCENT_FEE (charged once)
+ *   - Close fee: CC_PERCENT_FEE × weight × (closeWithSlip / openWithSlip) per partial/remaining
+ *
+ * @param signal - Closed signal with position details and optional partial history
+ * @param priceClose - Actual close price at final exit
+ * @returns PNL data with percentage and prices
+ */
+declare const toProfitLossDto: (signal: ISignalRow, priceClose: number) => IStrategyPnL;
+
+/**
+ * Returns the effective entry price for price calculations.
+ *
+ * Uses harmonic mean (correct for fixed-dollar DCA: $100 per entry).
+ *
+ * When partial closes exist, replays the partial sequence to reconstruct
+ * the running cost basis at each partial — no extra stored fields needed.
+ *
+ * Cost basis replay:
+ *   costBasis starts at 0
+ *   for each partial[i]:
+ *     newEntries = entryCountAtClose[i] - entryCountAtClose[i-1]  (or entryCountAtClose[0] for i=0)
+ *     costBasis += newEntries × $100          ← add DCA entries up to this partial
+ *     positionCostBasisAtClose[i] = costBasis ← snapshot BEFORE close
+ *     costBasis × = (1 - percent[i] / 100)    ← reduce after close
+ *
+ * @param signal - Signal row
+ * @returns Effective entry price for PNL calculations
+ */
+declare const getEffectivePriceOpen: (signal: ISignalRow) => number;
+
+/**
+ * Returns the total closed state of a position using cost-basis replay.
+ *
+ * Correctly accounts for DCA entries added between partial closes via averageBuy().
+ * Simple percent summation (sum of _partial[i].percent) is INCORRECT when averageBuy()
+ * is called between partials — this function uses the same cost-basis replay as
+ * toProfitLossDto to compute the true dollar-weighted closed fraction.
+ *
+ * Cost-basis replay:
+ *   costBasis = 0
+ *   for each partial[i]:
+ *     costBasis += (entryCountAtClose[i] - entryCountAtClose[i-1]) × $100
+ *     closedDollar += (percent[i] / 100) × costBasis
+ *     costBasis ×= (1 - percent[i] / 100)
+ *   // then add entries added AFTER the last partial
+ *   costBasis += (currentEntryCount - lastPartialEntryCount) × $100
+ *
+ * @param signal - Signal row with _partial and _entry arrays
+ * @returns Object with totalClosedPercent (0–100+) and remainingCostBasis (dollar value still open)
+ */
+declare const getTotalClosed: (signal: ISignalRow) => {
+    totalClosedPercent: number;
+    remainingCostBasis: number;
+};
+
+export { ActionBase, type ActivateScheduledCommit, type ActivateScheduledCommitNotification, type ActivePingContract, type AverageBuyCommit, Backtest, type BacktestStatisticsModel, Breakeven, type BreakevenAvailableNotification, type BreakevenCommit, type BreakevenCommitNotification, type BreakevenContract, type BreakevenData, Cache, type CancelScheduledCommit, type CandleData, type CandleInterval, type ClosePendingCommit, type ColumnConfig, type ColumnModel, Constant, type CriticalErrorNotification, type DoneContract, type EntityId, Exchange, ExecutionContextService, type FrameInterval, type GlobalConfig, Heat, type HeatmapStatisticsModel, type IActionSchema, type IActivateScheduledCommitRow, type IAggregatedTradeData, type IBidData, type IBreakevenCommitRow, type ICandleData, type ICommitRow, type IExchangeSchema, type IFrameSchema, type IHeatmapRow, type ILog, type ILogEntry, type ILogger, type IMarkdownDumpOptions, type INotificationUtils, type IOrderBookData, type IPartialLossCommitRow, type IPartialProfitCommitRow, type IPersistBase, type IPositionSizeATRParams, type IPositionSizeFixedPercentageParams, type IPositionSizeKellyParams, type IPublicAction, type IPublicCandleData, type IPublicSignalRow, type IReportDumpOptions, type IRiskActivePosition, type IRiskCheckArgs, type IRiskSchema, type IRiskSignalRow, type IRiskValidation, type IRiskValidationFn, type IRiskValidationPayload, type IScheduledSignalCancelRow, type IScheduledSignalRow, type ISignalDto, type ISignalRow, type ISizingCalculateParams, type ISizingCalculateParamsATR, type ISizingCalculateParamsFixedPercentage, type ISizingCalculateParamsKelly, type ISizingParams, type ISizingParamsATR, type ISizingParamsFixedPercentage, type ISizingParamsKelly, type ISizingSchema, type ISizingSchemaATR, type ISizingSchemaFixedPercentage, type ISizingSchemaKelly, type IStorageSignalRow, type IStorageUtils, type IStrategyPnL, type IStrategyResult, type IStrategySchema, type IStrategyTickResult, type IStrategyTickResultActive, type IStrategyTickResultCancelled, type IStrategyTickResultClosed, type IStrategyTickResultIdle, type IStrategyTickResultOpened, type IStrategyTickResultScheduled, type IStrategyTickResultWaiting, type ITrailingStopCommitRow, type ITrailingTakeCommitRow, type IWalkerResults, type IWalkerSchema, type IWalkerStrategyResult, type InfoErrorNotification, Live, type LiveStatisticsModel, Log, type LogData, Markdown, MarkdownFileBase, MarkdownFolderBase, type MarkdownName, type MeasureData, MethodContextService, type MetricStats, Notification, NotificationBacktest, type NotificationData, NotificationLive, type NotificationModel, Partial$1 as Partial, type PartialData, type PartialEvent, type PartialLossAvailableNotification, type PartialLossCommit, type PartialLossCommitNotification, type PartialLossContract, type PartialProfitAvailableNotification, type PartialProfitCommit, type PartialProfitCommitNotification, type PartialProfitContract, type PartialStatisticsModel, Performance, type PerformanceContract, type PerformanceMetricType, type PerformanceStatisticsModel, PersistBase, PersistBreakevenAdapter, PersistCandleAdapter, PersistLogAdapter, PersistMeasureAdapter, PersistNotificationAdapter, PersistPartialAdapter, PersistRiskAdapter, PersistScheduleAdapter, PersistSignalAdapter, PersistStorageAdapter, PositionSize, type ProgressBacktestContract, type ProgressWalkerContract, Report, ReportBase, type ReportName, Risk, type RiskContract, type RiskData, type RiskEvent, type RiskRejectionNotification, type RiskStatisticsModel, Schedule, type ScheduleData, type SchedulePingContract, type ScheduleStatisticsModel, type ScheduledEvent, type SignalCancelledNotification, type SignalClosedNotification, type SignalData, type SignalInterval, type SignalOpenedNotification, type SignalScheduledNotification, Storage, StorageBacktest, type StorageData, StorageLive, Strategy, type StrategyActionType, type StrategyCancelReason, type StrategyCloseReason, type StrategyCommitContract, type StrategyEvent, type StrategyStatisticsModel, type TLogCtor, type TMarkdownBase, type TNotificationUtilsCtor, type TPersistBase, type TPersistBaseCtor, type TReportBase, type TStorageUtilsCtor, type TickEvent, type TrailingStopCommit, type TrailingStopCommitNotification, type TrailingTakeCommit, type TrailingTakeCommitNotification, type ValidationErrorNotification, Walker, type WalkerCompleteContract, type WalkerContract, type WalkerMetric, type SignalData$1 as WalkerSignalData, type WalkerStatisticsModel, addActionSchema, addExchangeSchema, addFrameSchema, addRiskSchema, addSizingSchema, addStrategySchema, addWalkerSchema, alignToInterval, checkCandles, commitActivateScheduled, commitAverageBuy, commitBreakeven, commitCancelScheduled, commitClosePending, commitPartialLoss, commitPartialProfit, commitTrailingStop, commitTrailingTake, dumpMessages, emitters, formatPrice, formatQuantity, get, getActionSchema, getAggregatedTrades, getAveragePrice, getBacktestTimeframe, getBreakeven, getCandles, getColumns, getConfig, getContext, getDate, getDefaultColumns, getDefaultConfig, getEffectivePriceOpen, getExchangeSchema, getFrameSchema, getMode, getNextCandles, getOrderBook, getPendingSignal, getRawCandles, getRiskSchema, getScheduledSignal, getSizingSchema, getStrategySchema, getSymbol, getTimestamp, getTotalClosed, getTotalCostClosed, getTotalPercentClosed, getWalkerSchema, hasTradeContext, backtest as lib, listExchangeSchema, listFrameSchema, listRiskSchema, listSizingSchema, listStrategySchema, listWalkerSchema, listenActivePing, listenActivePingOnce, listenBacktestProgress, listenBreakevenAvailable, listenBreakevenAvailableOnce, listenDoneBacktest, listenDoneBacktestOnce, listenDoneLive, listenDoneLiveOnce, listenDoneWalker, listenDoneWalkerOnce, listenError, listenExit, listenPartialLossAvailable, listenPartialLossAvailableOnce, listenPartialProfitAvailable, listenPartialProfitAvailableOnce, listenPerformance, listenRisk, listenRiskOnce, listenSchedulePing, listenSchedulePingOnce, listenSignal, listenSignalBacktest, listenSignalBacktestOnce, listenSignalLive, listenSignalLiveOnce, listenSignalOnce, listenStrategyCommit, listenStrategyCommitOnce, listenValidation, listenWalker, listenWalkerComplete, listenWalkerOnce, listenWalkerProgress, overrideActionSchema, overrideExchangeSchema, overrideFrameSchema, overrideRiskSchema, overrideSizingSchema, overrideStrategySchema, overrideWalkerSchema, parseArgs, roundTicks, set, setColumns, setConfig, setLogger, shutdown, stopStrategy, toProfitLossDto, validate, waitForCandle, warmCandles };