@tradejs/core 3.0.1 → 3.1.0

package/README.md

@@ -36,6 +36,8 @@ Import only explicit public subpaths:
 - `@tradejs/core/constants`
 - `@tradejs/core/data`
 - `@tradejs/core/async`
+- `@tradejs/core/http`
+- `@tradejs/core/runtimeTrades`
 - `@tradejs/core/tickers`
 
 There is no root `@tradejs/core` import surface.

package/dist/backtest.mjs

@@ -1,3 +1,7 @@
+import {
+  compactOrderLog,
+  getTimeline
+} from "./chunk-S4KHOAXM.mjs";
 import {
   absReturns,
   equityPoints,
@@ -6,10 +10,6 @@ import {
   round,
   sum
 } from "./chunk-AYC2QVKI.mjs";
-import {
-  compactOrderLog,
-  getTimeline
-} from "./chunk-S4KHOAXM.mjs";
 import {
   TestThresholdsConfig
 } from "./chunk-MKCQSB4H.mjs";

package/dist/chunk-NYJU3J7Y.mjs

@@ -0,0 +1,265 @@
+import {
+  intervalToMs
+} from "./chunk-M7QGVZ3J.mjs";
+import {
+  BACKTEST_BASE_SLIPPAGE_BPS,
+  BACKTEST_DELAY_RISK_LOOKBACK_CANDLES,
+  BACKTEST_DELAY_RISK_MAX_BPS,
+  BACKTEST_DELAY_RISK_MULTIPLIER,
+  BACKTEST_EXPECTED_DELAY_MS,
+  BACKTEST_MARKET_IMPACT_BPS,
+  BACKTEST_SPREAD_SLIPPAGE_MULTIPLIER
+} from "./chunk-MKCQSB4H.mjs";
+
+// src/utils/executionSlippage.ts
+var toNonNegativeFiniteNumber = (value, fallback = 0) => typeof value === "number" && Number.isFinite(value) && value > 0 ? value : fallback;
+var toFiniteNumberOrNull = (value) => typeof value === "number" && Number.isFinite(value) ? value : null;
+var toRecord = (value) => value && typeof value === "object" ? value : null;
+var getMedian = (values) => {
+  if (!values.length) {
+    return null;
+  }
+  const sorted = [...values].sort((left, right) => left - right);
+  const middle = Math.floor(sorted.length / 2);
+  if (sorted.length % 2 === 0) {
+    const left = sorted[middle - 1];
+    const right = sorted[middle];
+    return left == null || right == null ? null : (left + right) / 2;
+  }
+  return sorted[middle] ?? null;
+};
+var extractCandleClose = (value) => {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return value;
+  }
+  const record = toRecord(value);
+  return toFiniteNumberOrNull(record?.close);
+};
+var extractCloseSeries = ({
+  closes,
+  candles
+}) => {
+  const source = Array.isArray(closes) && closes.length ? closes : candles;
+  if (!Array.isArray(source)) {
+    return [];
+  }
+  return source.map(extractCandleClose).filter((value) => value != null && value > 0);
+};
+var getSignalIntervalMs = (interval) => {
+  if (typeof interval !== "string") {
+    return null;
+  }
+  try {
+    return intervalToMs(interval);
+  } catch {
+    return null;
+  }
+};
+var getSignalCandleSeries = (signal) => {
+  const indicators = toRecord(signal?.indicators);
+  if (!indicators) {
+    return null;
+  }
+  const intervalKey = (() => {
+    switch (signal?.interval) {
+      case "15":
+        return "candles15m";
+      case "60":
+        return "candles1h";
+      case "240":
+        return "candles4h";
+      case "D":
+        return "candles1d";
+      default:
+        return null;
+    }
+  })();
+  const keys = [
+    intervalKey,
+    "candles15m",
+    "candles1h",
+    "candles4h",
+    "candles1d"
+  ].filter((key) => Boolean(key));
+  for (const key of keys) {
+    const value = indicators[key];
+    if (Array.isArray(value) && value.length > 1) {
+      return value;
+    }
+  }
+  const candle = indicators.candle;
+  const prevCandle = indicators.prevCandle;
+  return prevCandle && candle ? [prevCandle, candle] : null;
+};
+var calculateEffectiveSlippageBps = ({
+  baseSlippageBps = BACKTEST_BASE_SLIPPAGE_BPS,
+  spreadBps,
+  spreadMultiplier = BACKTEST_SPREAD_SLIPPAGE_MULTIPLIER,
+  marketImpactBps = BACKTEST_MARKET_IMPACT_BPS,
+  delayRiskBps
+} = {}) => {
+  const base = toNonNegativeFiniteNumber(baseSlippageBps);
+  const spread = toNonNegativeFiniteNumber(spreadBps);
+  const multiplier = toNonNegativeFiniteNumber(spreadMultiplier);
+  const marketImpact = toNonNegativeFiniteNumber(marketImpactBps);
+  const delayRisk = toNonNegativeFiniteNumber(delayRiskBps);
+  return base + spread * multiplier + marketImpact + delayRisk;
+};
+var calculateExecutionSlippageBreakdown = ({
+  baseSlippageBps = BACKTEST_BASE_SLIPPAGE_BPS,
+  spreadBps,
+  spreadMultiplier = BACKTEST_SPREAD_SLIPPAGE_MULTIPLIER,
+  marketImpactBps = BACKTEST_MARKET_IMPACT_BPS,
+  delayRiskBps
+} = {}) => {
+  const base = toNonNegativeFiniteNumber(baseSlippageBps);
+  const spread = toNonNegativeFiniteNumber(spreadBps);
+  const multiplier = toNonNegativeFiniteNumber(spreadMultiplier);
+  const spreadSlippage = spread * multiplier;
+  const marketImpact = toNonNegativeFiniteNumber(marketImpactBps);
+  const delayRisk = toNonNegativeFiniteNumber(delayRiskBps);
+  return {
+    baseSlippageBps: base,
+    spreadBps: spread,
+    spreadMultiplier: multiplier,
+    spreadSlippageBps: spreadSlippage,
+    marketImpactBps: marketImpact,
+    delayRiskBps: delayRisk,
+    effectiveSlippageBps: base + spreadSlippage + marketImpact + delayRisk
+  };
+};
+var calculateDelayRiskBps = ({
+  closes,
+  candles,
+  intervalMs,
+  expectedDelayMs = BACKTEST_EXPECTED_DELAY_MS,
+  lookbackCandles = BACKTEST_DELAY_RISK_LOOKBACK_CANDLES,
+  multiplier = BACKTEST_DELAY_RISK_MULTIPLIER,
+  maxBps = BACKTEST_DELAY_RISK_MAX_BPS
+} = {}) => {
+  const normalizedLookback = Math.max(
+    1,
+    Math.trunc(toNonNegativeFiniteNumber(lookbackCandles, 1))
+  );
+  const closeSeries = extractCloseSeries({ closes, candles }).slice(
+    -(normalizedLookback + 1)
+  );
+  if (closeSeries.length < 2) {
+    return null;
+  }
+  const moveBps = [];
+  for (let index = 1; index < closeSeries.length; index += 1) {
+    const previous = closeSeries[index - 1];
+    const current = closeSeries[index];
+    if (previous != null && current != null && previous > 0 && current > 0) {
+      moveBps.push(Math.abs(current / previous - 1) * 1e4);
+    }
+  }
+  const medianMoveBps = getMedian(moveBps);
+  if (medianMoveBps == null) {
+    return null;
+  }
+  const delayScale = typeof intervalMs === "number" && Number.isFinite(intervalMs) && intervalMs > 0 && typeof expectedDelayMs === "number" && Number.isFinite(expectedDelayMs) && expectedDelayMs > 0 ? Math.sqrt(expectedDelayMs / intervalMs) : 1;
+  const rawDelayRisk = medianMoveBps * delayScale * toNonNegativeFiniteNumber(multiplier);
+  const cappedDelayRisk = Math.min(
+    rawDelayRisk,
+    toNonNegativeFiniteNumber(maxBps, Number.POSITIVE_INFINITY)
+  );
+  return Number.isFinite(cappedDelayRisk) ? cappedDelayRisk : null;
+};
+var slippageBpsToRate = (slippageBps) => toNonNegativeFiniteNumber(slippageBps) / 1e4;
+var applyExecutionSlippage = ({
+  price,
+  direction,
+  stage,
+  ...modelParams
+}) => {
+  const slippageRate = slippageBpsToRate(
+    calculateExecutionSlippageBreakdown(modelParams).effectiveSlippageBps
+  );
+  if (!slippageRate) {
+    return price;
+  }
+  const sign = direction === "LONG" ? stage === "entry" ? 1 : -1 : stage === "entry" ? -1 : 1;
+  return price * (1 + sign * slippageRate);
+};
+var extractExecutionSpreadBps = (signal) => {
+  const additionalIndicators = toRecord(signal?.additionalIndicators);
+  const explicitSlippage = toRecord(additionalIndicators?.executionSlippage);
+  return toFiniteNumberOrNull(explicitSlippage?.spreadBps);
+};
+var extractExecutionMarketImpactBps = (signal) => {
+  const additionalIndicators = toRecord(signal?.additionalIndicators);
+  const explicitSlippage = toRecord(additionalIndicators?.executionSlippage);
+  return toFiniteNumberOrNull(explicitSlippage?.marketImpactBps);
+};
+var extractExecutionDelayRiskBps = (signal) => {
+  const additionalIndicators = toRecord(signal?.additionalIndicators);
+  const explicitSlippage = toRecord(additionalIndicators?.executionSlippage);
+  const explicitDelayRisk = toFiniteNumberOrNull(
+    explicitSlippage?.delayRiskBps
+  );
+  if (explicitDelayRisk != null) {
+    return explicitDelayRisk;
+  }
+  return calculateDelayRiskBps({
+    candles: getSignalCandleSeries(signal),
+    intervalMs: getSignalIntervalMs(signal?.interval)
+  });
+};
+
+// src/trade.ts
+var ORDER_LINK_PREFIX = "tjs-";
+var ORDER_LINK_SEPARATOR = "--";
+var STRATEGY_SLUG_LENGTH = 10;
+var STRATEGY_HASH_LENGTH = 5;
+var toBase36Hash = (value) => {
+  let hash = 0;
+  for (let index = 0; index < value.length; index += 1) {
+    hash = hash * 31 + value.charCodeAt(index) >>> 0;
+  }
+  return hash.toString(36).padStart(STRATEGY_HASH_LENGTH, "0");
+};
+var normalizeStrategyOrderLinkKey = (strategyName) => {
+  const normalized = String(strategyName ?? "").trim().toLowerCase();
+  if (!normalized) {
+    return null;
+  }
+  const slug = normalized.replace(/[^a-z0-9]+/g, "").slice(0, STRATEGY_SLUG_LENGTH) || "strategy";
+  const hash = toBase36Hash(normalized).slice(0, STRATEGY_HASH_LENGTH);
+  return `${slug}-${hash}`;
+};
+var createRuntimeOrderLinkPrefix = (strategyName) => {
+  const strategyKey = normalizeStrategyOrderLinkKey(strategyName);
+  return strategyKey ? `${ORDER_LINK_PREFIX}${strategyKey}${ORDER_LINK_SEPARATOR}` : ORDER_LINK_PREFIX;
+};
+var parseStrategyOrderLinkKey = (orderLinkId) => {
+  const normalized = String(orderLinkId ?? "").trim().toLowerCase();
+  if (!normalized.startsWith(ORDER_LINK_PREFIX)) {
+    return null;
+  }
+  const remainder = normalized.slice(ORDER_LINK_PREFIX.length);
+  const separatorIndex = remainder.indexOf(ORDER_LINK_SEPARATOR);
+  if (separatorIndex <= 0) {
+    return null;
+  }
+  const strategyPart = remainder.slice(0, separatorIndex).trim();
+  if (!strategyPart) {
+    return null;
+  }
+  return strategyPart;
+};
+
+export {
+  calculateEffectiveSlippageBps,
+  calculateExecutionSlippageBreakdown,
+  calculateDelayRiskBps,
+  slippageBpsToRate,
+  applyExecutionSlippage,
+  extractExecutionSpreadBps,
+  extractExecutionMarketImpactBps,
+  extractExecutionDelayRiskBps,
+  normalizeStrategyOrderLinkKey,
+  createRuntimeOrderLinkPrefix,
+  parseStrategyOrderLinkKey
+};

package/dist/http.d.mts

@@ -0,0 +1,8 @@
+type FetchWithRetryOptions = RequestInit & {
+    attempts?: number;
+    baseDelayMs?: number;
+    maxDelayMs?: number;
+};
+declare const fetchWithRetry: (url: string, options?: FetchWithRetryOptions) => Promise<Response>;
+
+export { type FetchWithRetryOptions, fetchWithRetry };

package/dist/http.d.ts

@@ -0,0 +1,8 @@
+type FetchWithRetryOptions = RequestInit & {
+    attempts?: number;
+    baseDelayMs?: number;
+    maxDelayMs?: number;
+};
+declare const fetchWithRetry: (url: string, options?: FetchWithRetryOptions) => Promise<Response>;
+
+export { type FetchWithRetryOptions, fetchWithRetry };

package/dist/http.js

@@ -0,0 +1,79 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/http.ts
+var http_exports = {};
+__export(http_exports, {
+  fetchWithRetry: () => fetchWithRetry
+});
+module.exports = __toCommonJS(http_exports);
+var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var parseRetryAfterMs = (value) => {
+  if (!value) return 0;
+  const seconds = Number(value);
+  if (Number.isFinite(seconds)) {
+    return Math.max(0, seconds * 1e3);
+  }
+  const dateMs = Date.parse(value);
+  if (Number.isFinite(dateMs)) {
+    return Math.max(0, dateMs - Date.now());
+  }
+  return 0;
+};
+var fetchWithRetry = async (url, options = {}) => {
+  const {
+    attempts = 5,
+    baseDelayMs = 300,
+    maxDelayMs = 5e3,
+    ...fetchOptions
+  } = options;
+  let lastError;
+  for (let i = 0; i < attempts; i++) {
+    try {
+      const response = await fetch(url, fetchOptions);
+      if (response.ok) {
+        return response;
+      }
+      const shouldRetry = response.status === 429 || response.status >= 500;
+      if (!shouldRetry || i === attempts - 1) {
+        return response;
+      }
+      const retryAfterMs = parseRetryAfterMs(
+        response.headers.get("retry-after")
+      );
+      const backoffMs = Math.min(maxDelayMs, baseDelayMs * 2 ** i);
+      await sleep(Math.max(retryAfterMs, backoffMs));
+    } catch (error) {
+      lastError = error;
+      if (i === attempts - 1) {
+        throw error;
+      }
+      const backoffMs = Math.min(maxDelayMs, baseDelayMs * 2 ** i);
+      await sleep(backoffMs);
+    }
+  }
+  if (lastError) {
+    throw lastError;
+  }
+  return fetch(url, fetchOptions);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  fetchWithRetry
+});

package/dist/http.mjs

@@ -0,0 +1,54 @@
+// src/http.ts
+var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var parseRetryAfterMs = (value) => {
+  if (!value) return 0;
+  const seconds = Number(value);
+  if (Number.isFinite(seconds)) {
+    return Math.max(0, seconds * 1e3);
+  }
+  const dateMs = Date.parse(value);
+  if (Number.isFinite(dateMs)) {
+    return Math.max(0, dateMs - Date.now());
+  }
+  return 0;
+};
+var fetchWithRetry = async (url, options = {}) => {
+  const {
+    attempts = 5,
+    baseDelayMs = 300,
+    maxDelayMs = 5e3,
+    ...fetchOptions
+  } = options;
+  let lastError;
+  for (let i = 0; i < attempts; i++) {
+    try {
+      const response = await fetch(url, fetchOptions);
+      if (response.ok) {
+        return response;
+      }
+      const shouldRetry = response.status === 429 || response.status >= 500;
+      if (!shouldRetry || i === attempts - 1) {
+        return response;
+      }
+      const retryAfterMs = parseRetryAfterMs(
+        response.headers.get("retry-after")
+      );
+      const backoffMs = Math.min(maxDelayMs, baseDelayMs * 2 ** i);
+      await sleep(Math.max(retryAfterMs, backoffMs));
+    } catch (error) {
+      lastError = error;
+      if (i === attempts - 1) {
+        throw error;
+      }
+      const backoffMs = Math.min(maxDelayMs, baseDelayMs * 2 ** i);
+      await sleep(backoffMs);
+    }
+  }
+  if (lastError) {
+    throw lastError;
+  }
+  return fetch(url, fetchOptions);
+};
+export {
+  fetchWithRetry
+};

package/dist/indicators.mjs

@@ -39,10 +39,10 @@ import {
   toArrayData,
   toCoinalyzeTimestampMs,
   toFiniteNumber
-} from "./chunk-QRRQA4TU.mjs";
+} from "./chunk-OLHUGX7X.mjs";
 import "./chunk-M7QGVZ3J.mjs";
-import "./chunk-AYC2QVKI.mjs";
 import "./chunk-S4KHOAXM.mjs";
+import "./chunk-AYC2QVKI.mjs";
 import "./chunk-MKCQSB4H.mjs";
 export {
   COINALYZE_MIN_INTRADAY_RETENTION_POINTS,

package/dist/runtimeTrades.d.mts

@@ -0,0 +1,82 @@
+import { RuntimeTradeRecord, SimpleOrderLogData, TestStat, RuntimeStrategyTradeSummary, RuntimeStrategyTradeView, MarketUniverse, RuntimeLineage } from '@tradejs/types';
+
+declare const resolveStrategyNameByOrderLinkId: ({ orderLinkId, strategyNames, }: {
+    orderLinkId: string | null | undefined;
+    strategyNames: string[];
+}) => string | null;
+declare const isRuntimeTradeRecord: (value: unknown) => value is RuntimeTradeRecord;
+declare const selectTradesForWindow: (trades: RuntimeTradeRecord[], startTime: number, activeOrderIds?: Set<string>) => RuntimeTradeRecord[];
+declare const buildRuntimeStrategyAnalytics: ({ trades, startTime, endTime, }: {
+    trades: RuntimeTradeRecord[];
+    startTime: number;
+    endTime: number;
+}) => {
+    orderLog: SimpleOrderLogData;
+    stat: TestStat;
+    summary: RuntimeStrategyTradeSummary;
+};
+declare const toRuntimeTradeView: (trade: RuntimeTradeRecord, endTime?: number) => RuntimeStrategyTradeView;
+
+interface RuntimeStrategyLineageScope {
+    strategy: string;
+    symbol: string;
+    runtimeConfigId?: string;
+    lineage: RuntimeLineage & {
+        maxLossValue?: number | null;
+    };
+    firstTimestamp: number;
+    lastTimestamp: number;
+}
+interface RuntimeStrategyAiGateChange {
+    timestamp: number;
+    previousFingerprint: string;
+    fingerprint: string;
+}
+interface RuntimeStrategyMaxLossValueChange {
+    timestamp: number;
+    previousValue: number;
+    value: number;
+}
+interface RuntimeStrategyMaxLossValueTimeline {
+    observedFrom: number | null;
+    initialValue: number | null;
+    changes: RuntimeStrategyMaxLossValueChange[];
+}
+interface RuntimeStrategyAccountScope {
+    strategyName: string;
+    configId: string;
+    universe: MarketUniverse;
+    accountId?: string;
+}
+declare const buildRuntimeStrategyIdentityKey: ({ strategyName, configId, universe, accountId, deploymentId, policyProfileId, }: {
+    strategyName: string;
+    configId?: string;
+    universe?: MarketUniverse;
+    accountId?: string;
+    deploymentId?: string;
+    policyProfileId?: string;
+}) => string;
+declare const assignLegacyRuntimeTradeAccountScopes: (trades: RuntimeTradeRecord[], scopes: RuntimeStrategyAccountScope[]) => RuntimeTradeRecord[];
+declare const getRuntimeStrategyAiGateObservedFrom: ({ scopes, strategyName, configId, endTime, }: {
+    scopes: RuntimeStrategyLineageScope[];
+    strategyName: string;
+    configId?: string;
+    endTime: number;
+}) => number | null;
+declare const buildRuntimeStrategyMaxLossValueTimeline: ({ scopes, strategyName, configId, startTime, endTime, }: {
+    scopes: RuntimeStrategyLineageScope[];
+    strategyName: string;
+    configId?: string;
+    startTime: number;
+    endTime: number;
+}) => RuntimeStrategyMaxLossValueTimeline;
+declare const isRuntimeStrategyLineageScope: (value: unknown) => value is RuntimeStrategyLineageScope;
+declare const buildRuntimeStrategyAiGateChanges: ({ scopes, strategyName, configId, startTime, endTime, }: {
+    scopes: RuntimeStrategyLineageScope[];
+    strategyName: string;
+    configId?: string;
+    startTime: number;
+    endTime: number;
+}) => RuntimeStrategyAiGateChange[];
+
+export { type RuntimeStrategyAccountScope, type RuntimeStrategyAiGateChange, type RuntimeStrategyLineageScope, type RuntimeStrategyMaxLossValueChange, type RuntimeStrategyMaxLossValueTimeline, assignLegacyRuntimeTradeAccountScopes, buildRuntimeStrategyAiGateChanges, buildRuntimeStrategyAnalytics, buildRuntimeStrategyIdentityKey, buildRuntimeStrategyMaxLossValueTimeline, getRuntimeStrategyAiGateObservedFrom, isRuntimeStrategyLineageScope, isRuntimeTradeRecord, resolveStrategyNameByOrderLinkId, selectTradesForWindow, toRuntimeTradeView };

package/dist/runtimeTrades.d.ts

@@ -0,0 +1,82 @@
+import { RuntimeTradeRecord, SimpleOrderLogData, TestStat, RuntimeStrategyTradeSummary, RuntimeStrategyTradeView, MarketUniverse, RuntimeLineage } from '@tradejs/types';
+
+declare const resolveStrategyNameByOrderLinkId: ({ orderLinkId, strategyNames, }: {
+    orderLinkId: string | null | undefined;
+    strategyNames: string[];
+}) => string | null;
+declare const isRuntimeTradeRecord: (value: unknown) => value is RuntimeTradeRecord;
+declare const selectTradesForWindow: (trades: RuntimeTradeRecord[], startTime: number, activeOrderIds?: Set<string>) => RuntimeTradeRecord[];
+declare const buildRuntimeStrategyAnalytics: ({ trades, startTime, endTime, }: {
+    trades: RuntimeTradeRecord[];
+    startTime: number;
+    endTime: number;
+}) => {
+    orderLog: SimpleOrderLogData;
+    stat: TestStat;
+    summary: RuntimeStrategyTradeSummary;
+};
+declare const toRuntimeTradeView: (trade: RuntimeTradeRecord, endTime?: number) => RuntimeStrategyTradeView;
+
+interface RuntimeStrategyLineageScope {
+    strategy: string;
+    symbol: string;
+    runtimeConfigId?: string;
+    lineage: RuntimeLineage & {
+        maxLossValue?: number | null;
+    };
+    firstTimestamp: number;
+    lastTimestamp: number;
+}
+interface RuntimeStrategyAiGateChange {
+    timestamp: number;
+    previousFingerprint: string;
+    fingerprint: string;
+}
+interface RuntimeStrategyMaxLossValueChange {
+    timestamp: number;
+    previousValue: number;
+    value: number;
+}
+interface RuntimeStrategyMaxLossValueTimeline {
+    observedFrom: number | null;
+    initialValue: number | null;
+    changes: RuntimeStrategyMaxLossValueChange[];
+}
+interface RuntimeStrategyAccountScope {
+    strategyName: string;
+    configId: string;
+    universe: MarketUniverse;
+    accountId?: string;
+}
+declare const buildRuntimeStrategyIdentityKey: ({ strategyName, configId, universe, accountId, deploymentId, policyProfileId, }: {
+    strategyName: string;
+    configId?: string;
+    universe?: MarketUniverse;
+    accountId?: string;
+    deploymentId?: string;
+    policyProfileId?: string;
+}) => string;
+declare const assignLegacyRuntimeTradeAccountScopes: (trades: RuntimeTradeRecord[], scopes: RuntimeStrategyAccountScope[]) => RuntimeTradeRecord[];
+declare const getRuntimeStrategyAiGateObservedFrom: ({ scopes, strategyName, configId, endTime, }: {
+    scopes: RuntimeStrategyLineageScope[];
+    strategyName: string;
+    configId?: string;
+    endTime: number;
+}) => number | null;
+declare const buildRuntimeStrategyMaxLossValueTimeline: ({ scopes, strategyName, configId, startTime, endTime, }: {
+    scopes: RuntimeStrategyLineageScope[];
+    strategyName: string;
+    configId?: string;
+    startTime: number;
+    endTime: number;
+}) => RuntimeStrategyMaxLossValueTimeline;
+declare const isRuntimeStrategyLineageScope: (value: unknown) => value is RuntimeStrategyLineageScope;
+declare const buildRuntimeStrategyAiGateChanges: ({ scopes, strategyName, configId, startTime, endTime, }: {
+    scopes: RuntimeStrategyLineageScope[];
+    strategyName: string;
+    configId?: string;
+    startTime: number;
+    endTime: number;
+}) => RuntimeStrategyAiGateChange[];
+
+export { type RuntimeStrategyAccountScope, type RuntimeStrategyAiGateChange, type RuntimeStrategyLineageScope, type RuntimeStrategyMaxLossValueChange, type RuntimeStrategyMaxLossValueTimeline, assignLegacyRuntimeTradeAccountScopes, buildRuntimeStrategyAiGateChanges, buildRuntimeStrategyAnalytics, buildRuntimeStrategyIdentityKey, buildRuntimeStrategyMaxLossValueTimeline, getRuntimeStrategyAiGateObservedFrom, isRuntimeStrategyLineageScope, isRuntimeTradeRecord, resolveStrategyNameByOrderLinkId, selectTradesForWindow, toRuntimeTradeView };