@tradejs/types 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,842 @@
+import { KlineIntervalV3 } from 'bybit-api';
+
+interface Metrics {
+    periodDays: number;
+    periodMonths: number;
+    orders: number;
+    ordersPerMonth: number;
+    wins: number;
+    losses: number;
+    exposure: number;
+    amount: number;
+    maxAmount: number;
+    minAmount: number;
+    netProfit: number;
+    totalReturn: number;
+    cagr: number;
+    maxDrawdown: number;
+    calmar: number | null;
+    winRate: number;
+    riskRewardRatio: number | null;
+    expectancy: number;
+    maxConsecutiveWins: number;
+    maxConsecutiveLosses: number;
+    sharpeRatio: number | null;
+}
+interface EOMPoint {
+    month: string;
+    ts: number;
+    amount: number;
+}
+interface MonthlyEquityStats {
+    eomSeries: EOMPoint[];
+    monthlyReturns: number[];
+    monthlyMean: number;
+    monthlyStd: number;
+    monthlyDownsideStd: number;
+    sharpeMonthly: number | null;
+    sharpeMonthlyAnnualized: number | null;
+    sortinoMonthly: number | null;
+    sortinoMonthlyAnnualized: number | null;
+    positiveMonths: number;
+    maxMonthlyGain: number;
+    maxMonthlyDrop: number;
+}
+type ThresholdLevel = 'error' | 'warning' | 'success';
+interface MetricThreshold {
+    thresholds: [number, number];
+    direction: 'higher' | 'lower';
+    isPercent?: boolean;
+    isAmount?: boolean;
+    precision: number;
+}
+
+type Interval = KlineIntervalV3;
+type Provider = 'bybit' | 'binance' | 'coinbase';
+interface Candle {
+    open: number;
+    high: number;
+    low: number;
+    close: number;
+    volume: number;
+    timestamp: number;
+    turnover: number;
+}
+interface KlineChartItem extends Candle {
+    dt: string;
+    [key: string]: unknown;
+}
+type KlineChartData = Array<KlineChartItem>;
+interface KlineRequest {
+    symbol: string;
+    interval: Interval;
+    start?: number;
+    end: number;
+    silent?: boolean;
+    cacheOnly?: boolean;
+}
+interface Tp {
+    price: number;
+    rate: number;
+    done?: boolean;
+}
+type Sl = number | null;
+type Direction = 'LONG' | 'SHORT';
+type Trend = 'BULL' | 'BEAR';
+type Order = {
+    symbol: string;
+    isLimit?: boolean;
+    qty: number;
+    price: number;
+    timestamp: number;
+    direction: Direction;
+    signal?: Signal;
+};
+type Position = {
+    symbol: string;
+    qty: number;
+    price: number;
+    direction: Direction;
+};
+type OrderType = 'OPEN_LONG' | 'OPEN_SHORT' | 'CLOSE_LONG' | 'CLOSE_SHORT' | 'TAKE_PROFIT_LONG' | 'TAKE_PROFIT_SHORT' | 'STOP_LOSS_LONG' | 'STOP_LOSS_SHORT';
+type ConnectorCreator = (config: ConnectorConfig) => Promise<Connector>;
+interface ConnectorConfig {
+    userName: string;
+}
+interface ConnectorRegistryEntry {
+    name: string;
+    creator: ConnectorCreator;
+    providers?: string[];
+}
+interface ConnectorPluginDefinition {
+    connectorEntries: ConnectorRegistryEntry[];
+}
+type GetPosition = (symbol: string) => Promise<Position | null>;
+type GetPositions = () => Promise<Position[]>;
+type PlaceOrder = (order: Order, tp?: Tp[], slPrice?: Sl) => Promise<boolean>;
+type ClosePosition = (order: Omit<Order, 'qty'>) => Promise<boolean>;
+type Kline = (options: KlineRequest) => Promise<KlineChartData>;
+type GetTickers = () => Promise<Ticker[]>;
+interface Connector {
+    kline: Kline;
+    getState: () => Promise<object>;
+    setState: (state: object) => Promise<void>;
+    getPosition: GetPosition;
+    getPositions: GetPositions;
+    placeOrder: PlaceOrder;
+    closePosition: ClosePosition;
+    getTickers: GetTickers;
+}
+interface Indicator {
+    id: string;
+    label: string;
+    enabled: boolean;
+    periods?: Array<number>;
+}
+type Indicators = Indicator[];
+interface Filters {
+    provider?: Provider;
+    symbol: string;
+    interval: Interval;
+    start: number;
+    end: number;
+}
+interface Ticker {
+    symbol: string;
+    lastPrice: number;
+    indexPrice: number;
+    markPrice: number;
+    prevPrice24h: number;
+    price24hPcnt: number;
+    highPrice24h: number;
+    lowPrice24h: number;
+    prevPrice1h: number;
+    openInterest: number;
+    openInterestValue: number;
+    turnover24h: number;
+    volume24h: number;
+    fundingRate: number;
+    nextFundingTime: number;
+    predictedDeliveryPrice: string;
+    basisRate: string;
+    deliveryFeeRate: string;
+    deliveryTime: number;
+    ask1Size: number;
+    bid1Price: number;
+    ask1Price: number;
+    bid1Size: number;
+    basis: string;
+    preOpenPrice: string;
+    preQty: string;
+}
+type TrendLineMode = 'lows' | 'highs';
+type TrendLine = {
+    id: string;
+    mode: TrendLineMode;
+    distance: number;
+    touches: {
+        timestamp: number;
+        value: number;
+    }[];
+    points: {
+        timestamp: number;
+        value: number;
+    }[];
+    alpha?: number[];
+};
+interface StrategyFigurePoint {
+    timestamp: number;
+    value: number;
+}
+interface StrategyFigureLine {
+    id?: string;
+    kind?: string;
+    points: StrategyFigurePoint[];
+    color?: string;
+    width?: number;
+    style?: 'solid' | 'dashed';
+}
+interface StrategyFigurePoints {
+    id?: string;
+    kind?: string;
+    points: StrategyFigurePoint[];
+    color?: string;
+    radius?: number;
+}
+interface StrategyFigureZone {
+    id?: string;
+    kind?: string;
+    start: StrategyFigurePoint;
+    end: StrategyFigurePoint;
+    color?: string;
+    borderColor?: string;
+}
+interface StrategyEntryModelFigures {
+    lines?: StrategyFigureLine[];
+    points?: StrategyFigurePoints[];
+    zones?: StrategyFigureZone[];
+}
+interface TrendLineOptions {
+    mode: TrendLineMode;
+    maxLines?: number;
+    range?: number;
+    epsilon?: number;
+    epsilonOffset?: number;
+    minTouches?: number;
+    minDistance?: number;
+    firstRange?: number;
+    offset?: number;
+    minTouchGap?: number;
+    maxTouchGap?: number;
+    capture?: boolean;
+    bestLines?: number;
+    maxDistance?: number;
+}
+interface Signal {
+    signalId: string;
+    symbol: string;
+    interval: Interval;
+    strategy: string;
+    direction: Direction;
+    timestamp: number;
+    orderStatus?: 'completed' | 'failed' | 'skipped' | 'canceled';
+    orderSkipReason?: string;
+    isConfigFromBacktest?: boolean;
+    ml?: {
+        probability: number;
+        threshold: number;
+        passed: boolean;
+    };
+    figures: {
+        trendLine?: TrendLine;
+        lines?: StrategyFigureLine[];
+        points?: StrategyFigurePoints[];
+        zones?: StrategyFigureZone[];
+        [key: string]: any;
+    };
+    prices: {
+        currentPrice: number;
+        takeProfitPrice: number;
+        stopLossPrice: number;
+        riskRatio: number;
+    };
+    indicators: Record<string, any>;
+    additionalIndicators?: Record<string, any>;
+}
+interface SignalAnalysis {
+    direction: Direction | null;
+    quality: 1 | 2 | 3 | 4 | 5 | number;
+    needRetest: boolean;
+    retestPrice: number | null;
+    takeProfitPrice: number | null;
+    stopLossPrice: number | null;
+    setup?: string;
+    confirmations?: string;
+    btcContext?: string;
+    retestPlan?: string;
+    riskLevels?: string;
+    qualityReason?: string;
+    triggerInvalidation?: string;
+    comment: string;
+}
+
+type Strategy = (candle: KlineChartItem, btcCandle: KlineChartItem) => Promise<string | Signal>;
+type BacktestPriceMode = 'mid' | 'close' | 'open' | 'rand';
+interface StrategyConfig {
+    BACKTEST_PRICE_MODE?: BacktestPriceMode;
+    ML_ENABLED?: boolean;
+    [key: string]: any;
+}
+type StrategyResultConfig = StrategyConfig;
+type StrategyConfigGrid = Record<string, unknown[]>;
+interface StrategyCreatorParams {
+    userName: string;
+    symbol: string;
+    config: StrategyConfig;
+    connector: Connector;
+    data: KlineChartData;
+    btcData: KlineChartData;
+    btcBinanceData?: KlineChartData;
+    btcCoinbaseData?: KlineChartData;
+}
+type StrategyCreator = (params: StrategyCreatorParams) => Promise<Strategy>;
+type TestingOptions = Pick<KlineRequest, 'start' | 'end'>;
+interface BacktestRunConfig {
+    strategyName: string;
+    strategyConfig: StrategyConfig;
+    connectorName: string;
+}
+interface Test extends BacktestRunConfig {
+    userName: string;
+    name: string;
+    testId: string;
+    testSuiteId: string;
+    symbol: string;
+    options: TestingOptions;
+    ml?: boolean;
+    chunkId?: string;
+}
+type TestSuite = Test[];
+interface TestStat extends Metrics {
+    score?: number;
+}
+interface StrategyResultEntry {
+    config: StrategyResultConfig;
+    stats: TestStat;
+}
+type StrategyResults = Record<string, StrategyResultEntry>;
+interface MinimalStat {
+    amount: number;
+    profit: number;
+    orders: number;
+}
+interface TestingBoxResult {
+    orderLogId: string;
+    stat: MinimalStat;
+}
+type TestingBox = (test: Test) => Promise<TestingBoxResult | null>;
+interface TestWorkerResult extends TestingBoxResult {
+    test: Test;
+}
+interface CompletedTest extends Omit<TestWorkerResult, 'stat'> {
+    stat: TestStat;
+}
+type OrderLog = Order & {
+    type: OrderType;
+    profit: number;
+    amount: number;
+    fee?: number;
+    index: number;
+};
+type OrderLogData = OrderLog[];
+type SimpleOrderLogData = [number, number][];
+interface TestResult extends Omit<CompletedTest, 'orderLogId'> {
+    orderLog: SimpleOrderLogData;
+}
+interface PositionLog {
+    direction: Direction;
+    open: {
+        amount: number;
+        timestamp: number;
+    };
+    close: {
+        amount: number;
+        timestamp: number;
+    };
+}
+type PositionLogData = PositionLog[];
+type TestThresholds = Record<keyof TestStat, MetricThreshold>;
+type TestThresholdsKey = keyof TestThresholds;
+interface TestConnector extends Connector {
+    getResult: () => Promise<TestingBoxResult>;
+    checkTp: (candle: Candle) => Promise<void>;
+    checkSl: (candle: Candle) => Promise<void>;
+    drainMlResultsBatch: () => Promise<Array<{
+        signalId: string;
+        profit: number;
+    }>>;
+}
+interface TestConnectorContext {
+    userName?: string;
+    mlEnabled?: boolean;
+}
+type TestConnectorCreator = (connector: Connector, context?: TestConnectorContext) => TestConnector;
+type ChartColor = string;
+interface TestCompare {
+    testResult: TestResult;
+    color: ChartColor;
+}
+type TestCompareList = TestCompare[];
+type OnChangeCompare = (testId: string) => void;
+
+interface Bot {
+    symbol: string;
+    disabled?: boolean;
+    strategyName: string;
+    strategyConfig: StrategyConfig;
+    connectorName: string;
+}
+interface BotStatus {
+    symbol: string;
+    status: string;
+}
+type BotResults = BotStatus[];
+type BotConfig = Bot[];
+
+interface Item<T = Record<string, string | number | boolean>> {
+    label: string;
+    value: string;
+    description?: string;
+    data?: T;
+}
+type Items = Item[];
+interface Figure {
+    ctx: CanvasRenderingContext2D;
+    x: number;
+    y: number;
+    color: string;
+    width: number;
+    height: number;
+    text?: string;
+}
+interface UIFilters extends Filters {
+    backtestId: string | null;
+    backtestStrategy: string | null;
+}
+type OnChangeFilters = (filters: Partial<UIFilters>) => void;
+
+interface AIChatMessage {
+    from: 'user' | 'ai';
+    text: string;
+    command?: string;
+}
+type AIChatHistory = AIChatMessage[];
+
+interface AiPayload {
+    signal: {
+        symbol: Signal['symbol'];
+        signalId: Signal['signalId'];
+        interval: Signal['interval'];
+        direction: Signal['direction'];
+        timestamp: Signal['timestamp'];
+        strategy: Signal['strategy'];
+        prices: {
+            currentPrice: Signal['prices']['currentPrice'];
+            takeProfitPrice: Signal['prices']['takeProfitPrice'];
+            stopLossPrice: Signal['prices']['stopLossPrice'];
+        };
+    };
+    figures: Record<string, unknown>;
+    indicators: unknown;
+    additionalIndicators: unknown;
+}
+interface StrategyAiAdapter {
+    buildPayload?: (params: {
+        signal: Signal;
+        basePayload: AiPayload;
+    }) => AiPayload;
+    buildSystemPromptAddon?: (params: {
+        signal: Signal;
+    }) => string;
+    buildHumanPromptAddon?: (params: {
+        signal: Signal;
+        payload: AiPayload;
+    }) => string;
+    mapEntryRuntimeFromConfig?: (config: StrategyConfig) => StrategyRuntimeAiOptions | undefined;
+}
+interface StrategyMlAdapter {
+    normalizeSignal?: (signal: Signal) => Signal;
+    normalizeStrategyConfig?: (strategyConfig?: Record<string, any>) => Record<string, any> | undefined;
+    mapEntryRuntimeFromConfig?: (config: StrategyConfig) => StrategyRuntimeMlOptions | undefined;
+}
+interface StrategyHookGateResult {
+    allow?: boolean;
+    reason?: string;
+}
+interface StrategyHookBaseContext {
+    connector: Connector;
+    strategyName: string;
+    userName: string;
+    symbol: string;
+    config: StrategyConfig;
+    env: string;
+    isConfigFromBacktest: boolean;
+}
+interface StrategyHookErrorContext extends StrategyHookBaseContext {
+    stage: string;
+    error: unknown;
+    decision?: StrategyDecision;
+    signal?: Signal;
+}
+interface StrategyHookInitContext extends StrategyHookBaseContext {
+    data: KlineChartItem[];
+    btcData: KlineChartItem[];
+}
+interface StrategyHookAfterDecisionContext extends StrategyHookBaseContext {
+    decision: StrategyDecision;
+    candle: KlineChartItem;
+    btcCandle: KlineChartItem;
+}
+interface StrategyHookSkipContext extends StrategyHookAfterDecisionContext {
+    decision: Extract<StrategyDecision, {
+        kind: 'skip';
+    }>;
+}
+interface StrategyHookBeforeCloseContext extends StrategyHookBaseContext {
+    decision: Extract<StrategyDecision, {
+        kind: 'exit';
+    }>;
+}
+interface StrategyHookEnrichContext extends StrategyHookBaseContext {
+    decision: Extract<StrategyDecision, {
+        kind: 'entry';
+    }>;
+    runtime: StrategyEntryRuntimeOptions | undefined;
+    signal?: Signal;
+}
+interface StrategyHookAfterAiContext extends StrategyHookEnrichContext {
+    quality?: number;
+}
+interface StrategyHookBeforeEntryGateContext extends StrategyHookAfterAiContext {
+    makeOrdersEnabled: boolean;
+    minAiQuality: number;
+}
+interface StrategyHookBeforePlaceOrderContext extends StrategyHookBaseContext {
+    entryContext: StrategyEntrySignalContext;
+    runtime: StrategyEntryRuntimeOptions | undefined;
+    decision: Extract<StrategyDecision, {
+        kind: 'entry';
+    }>;
+    signal?: Signal;
+}
+interface StrategyHookAfterPlaceOrderContext extends StrategyHookEnrichContext {
+    orderResult: unknown;
+}
+interface StrategyManifest {
+    name: string;
+    entryRuntimeDefaults?: {
+        ai?: StrategyRuntimeAiOptions;
+        ml?: Pick<StrategyRuntimeMlOptions, 'enabled'>;
+    };
+    hooks?: {
+        onInit?: (params: StrategyHookInitContext) => Promise<void> | void;
+        afterCoreDecision?: (params: StrategyHookAfterDecisionContext) => Promise<void> | void;
+        onSkip?: (params: StrategyHookSkipContext) => Promise<void> | void;
+        beforeClosePosition?: (params: StrategyHookBeforeCloseContext) => Promise<StrategyHookGateResult | void> | StrategyHookGateResult | void;
+        afterEnrichMl?: (params: StrategyHookEnrichContext) => Promise<void> | void;
+        afterEnrichAi?: (params: StrategyHookAfterAiContext) => Promise<void> | void;
+        beforeEntryGate?: (params: StrategyHookBeforeEntryGateContext) => Promise<StrategyHookGateResult | void> | StrategyHookGateResult | void;
+        beforePlaceOrder?: (params: StrategyHookBeforePlaceOrderContext) => Promise<void> | void;
+        afterPlaceOrder?: (params: StrategyHookAfterPlaceOrderContext) => Promise<void> | void;
+        onRuntimeError?: (params: StrategyHookErrorContext) => Promise<void> | void;
+    };
+    aiAdapter?: StrategyAiAdapter;
+    mlAdapter?: StrategyMlAdapter;
+}
+
+interface StrategySignalMetaParams {
+    symbol: string;
+    interval: Interval;
+    direction: Direction;
+    timestamp: number;
+    isConfigFromBacktest: boolean;
+}
+interface StrategySignalPriceParams {
+    currentPrice: number;
+    takeProfitPrice: number;
+    stopLossPrice: number;
+    riskRatio: number;
+}
+interface StrategyEntryBaseParams {
+    qty: number;
+}
+interface StrategyEntryTakeProfitsParams {
+    takeProfits: Tp[];
+}
+interface StrategyEntryRuntimeBaseParams {
+    symbol: string;
+    direction: Direction;
+    timestamp: number;
+    currentPrice: number;
+}
+type StrategyEntryRuntimeBuilderParams<TExtra extends object = {}> = StrategyEntryRuntimeBaseParams & TExtra;
+type StrategyEntrySignalDecisionBuilderParams<TPriceFields extends object = StrategySignalPriceParams, TExtra extends object = {}> = StrategySignalMetaParams & StrategyEntryBaseParams & TPriceFields & TExtra;
+type StrategyIndicatorsMap = Signal['indicators'];
+type StrategyAdditionalIndicatorsMap = NonNullable<Signal['additionalIndicators']>;
+interface BuildStrategySignalParams {
+    signalId: string;
+    strategy: Signal['strategy'];
+    symbol: string;
+    interval: Signal['interval'];
+    direction: Direction;
+    timestamp: number;
+    prices: Signal['prices'];
+    figures?: Signal['figures'];
+    indicators?: Signal['indicators'];
+    additionalIndicators?: NonNullable<Signal['additionalIndicators']>;
+    isConfigFromBacktest?: boolean;
+}
+type BuildStrategySignalDraft = Omit<BuildStrategySignalParams, 'signalId'> & {
+    signalId?: string;
+};
+interface StrategyEntrySignalContext {
+    strategy: Signal['strategy'];
+    symbol: Signal['symbol'];
+    interval: Signal['interval'];
+    direction: Signal['direction'];
+    timestamp: Signal['timestamp'];
+    prices: Signal['prices'];
+    isConfigFromBacktest?: Signal['isConfigFromBacktest'];
+}
+interface StrategyAPIEntryParams {
+    code?: string;
+    direction: Direction;
+    figures?: BuildStrategySignalDraft['figures'];
+    indicators?: BuildStrategySignalDraft['indicators'];
+    additionalIndicators?: BuildStrategySignalDraft['additionalIndicators'];
+    signalId?: BuildStrategySignalDraft['signalId'];
+    orderPlan: StrategyEntryOrderPlan;
+    runtime?: StrategyEntryRuntimeOptions;
+}
+interface StrategyAPIMarketDataParams {
+    preloadStart?: number;
+    backtestPriceMode?: BacktestPriceMode;
+}
+interface StrategyMarketSnapshot {
+    fullData: KlineChartData;
+    lastCandle: KlineChartItem;
+    timestamp: number;
+    currentPrice: number;
+}
+interface MlCandleIndicatorsSnapshot {
+    candles15m: Candle[];
+    candles1h: Candle[];
+    candles4h: Candle[];
+    candles1d: Candle[];
+    btcCandles15m: Candle[];
+    btcCandles1h: Candle[];
+    btcCandles4h: Candle[];
+    btcCandles1d: Candle[];
+}
+interface BaseIndicatorsHistorySnapshot {
+    maFast?: number[];
+    maMedium?: number[];
+    maSlow?: number[];
+    atr?: number[];
+    atrPct?: number[];
+    bbUpper?: number[];
+    bbMiddle?: number[];
+    bbLower?: number[];
+    obv?: number[];
+    smaObv?: number[];
+    macd?: number[];
+    macdSignal?: number[];
+    macdHistogram?: number[];
+    price24hPcnt?: number[];
+    price1hPcnt?: number[];
+    highPrice1h?: number[];
+    lowPrice1h?: number[];
+    volume1h?: number[];
+    highPrice24h?: number[];
+    lowPrice24h?: number[];
+    volume24h?: number[];
+    highLevel?: number[];
+    lowLevel?: number[];
+    prevClose?: number[];
+    correlation?: number[];
+    spread?: number[];
+}
+type IndicatorsHistorySnapshot = Record<string, number[] | Candle[]> & BaseIndicatorsHistorySnapshot & Partial<MlCandleIndicatorsSnapshot>;
+interface IndicatorSnapshot {
+    maFast: number;
+    maMedium: number;
+    maSlow: number;
+    atr: number;
+    atrPct: number | null;
+    bbUpper: number;
+    bbMiddle: number;
+    bbLower: number;
+    obv: number;
+    smaObv: number;
+    macd: number | undefined;
+    macdSignal: number | undefined;
+    macdHistogram: number | undefined;
+    price24hPcnt: number;
+    price1hPcnt: number;
+    highPrice1h: number | null;
+    lowPrice1h: number | null;
+    volume1h: number | null;
+    highPrice24h: number | null;
+    lowPrice24h: number | null;
+    volume24h: number | null;
+    candle: Candle;
+    prevCandle: Candle | null;
+    highLevel: number | null;
+    lowLevel: number | null;
+    correlation: number;
+    spread: number | null;
+}
+interface StrategyDirectionalTpSlParams {
+    price: number;
+    direction: Direction;
+    takeProfitDelta: number;
+    stopLossDelta: number;
+    unit?: 'percent' | 'ratio';
+    maxLossValue?: number;
+    feePercent?: number;
+}
+interface StrategyDirectionalTpSlResult {
+    stopLossPrice: number;
+    takeProfitPrice: number;
+    riskRatio: number;
+    qty?: number;
+}
+interface StrategyLastTradeController {
+    isInCooldown: (timestamp: number) => boolean;
+    markTrade: (timestamp: number) => void;
+    getLastTradeTimestamp: () => number | null;
+}
+interface StrategyLastTradeControllerParams {
+    env?: string;
+    enabled?: boolean;
+    cooldownMs?: number;
+}
+interface StrategyAPI {
+    skip: (code: string) => Extract<StrategyDecision, {
+        kind: 'skip';
+    }>;
+    entry: (params: StrategyAPIEntryParams) => Promise<Extract<StrategyDecision, {
+        kind: 'entry';
+    }>>;
+    getMarketData: (params?: StrategyAPIMarketDataParams) => Promise<StrategyMarketSnapshot>;
+    nextIndicators: (candle: KlineChartData[number], btcCandle: KlineChartData[number]) => unknown;
+    getCurrentPosition: () => ReturnType<Connector['getPosition']>;
+    isCurrentPositionExists: () => Promise<boolean>;
+    getDirectionalTpSlPrices: (params: StrategyDirectionalTpSlParams) => StrategyDirectionalTpSlResult;
+    createLastTradeController: (params?: StrategyLastTradeControllerParams) => StrategyLastTradeController;
+}
+interface StrategyIndicatorsState<TNext = unknown, TSnapshot = Record<string, any> | undefined> {
+    isInitialized: () => boolean;
+    setCurrentBar: (candle: KlineChartData[number], btcCandle: KlineChartData[number]) => void;
+    onBar: (candle?: KlineChartData[number], btcCandle?: KlineChartData[number]) => void;
+    next: (candle: KlineChartData[number], btcCandle: KlineChartData[number]) => TNext;
+    ensureInitializedWithCurrentBar: () => {
+        snapshot: () => TSnapshot;
+    };
+    snapshot: () => TSnapshot;
+    latestNumber: <K extends Extract<keyof NonNullable<TSnapshot>, string>>(key: K) => number | undefined;
+}
+interface StrategyRuntimeMlOptions {
+    enabled?: boolean;
+    strategyConfig?: StrategyConfig;
+    mlThreshold?: number;
+}
+interface StrategyRuntimeAiOptions {
+    enabled?: boolean;
+    minQuality?: number;
+}
+interface StrategyEntryRuntimeOptions {
+    ml?: StrategyRuntimeMlOptions;
+    ai?: StrategyRuntimeAiOptions;
+    beforePlaceOrder?: () => Promise<void>;
+}
+interface StrategyEntryOrderPlan {
+    qty: number;
+    stopLossPrice: number;
+    takeProfits: Tp[];
+}
+interface StrategyClosePlan {
+    price: number;
+    timestamp: number;
+    direction: Direction;
+}
+type StrategyDecision = {
+    kind: 'skip';
+    code: string;
+} | {
+    kind: 'entry';
+    code: string;
+    entryContext: StrategyEntrySignalContext;
+    orderPlan: StrategyEntryOrderPlan;
+    signal?: Signal;
+    runtime?: StrategyEntryRuntimeOptions;
+} | {
+    kind: 'exit';
+    code: string;
+    closePlan: StrategyClosePlan;
+};
+interface CreateStrategyCoreParams<TConfig extends StrategyConfig, TIndicatorsState extends StrategyIndicatorsState = StrategyIndicatorsState> {
+    userName: string;
+    symbol: string;
+    config: TConfig;
+    isConfigFromBacktest: boolean;
+    connector: Connector;
+    data: KlineChartData;
+    btcData: KlineChartData;
+    loadPineScript: (fileNameOrPath: string, fallback?: string) => string;
+    strategyApi: StrategyAPI;
+    indicatorsState: TIndicatorsState;
+}
+type StrategyCoreRunner = (candle: KlineChartItem, btcCandle: KlineChartItem) => Promise<StrategyDecision> | StrategyDecision;
+type CreateStrategyCore<TConfig extends StrategyConfig, TSnapshot extends Record<string, any> | undefined = Record<string, any> | undefined, TNext = unknown> = (params: CreateStrategyCoreParams<TConfig, StrategyIndicatorsState<TNext, TSnapshot>>) => Promise<StrategyCoreRunner> | StrategyCoreRunner;
+interface StrategyRegistryEntry {
+    manifest: StrategyManifest;
+    creator: StrategyCreator;
+}
+interface StrategyPluginDefinition {
+    strategyEntries: StrategyRegistryEntry[];
+}
+interface IndicatorPluginComputeParams {
+    candle: Candle;
+    btcCandle?: Candle;
+    data: Candle[];
+    btcData: Candle[];
+    baseResult: Partial<IndicatorSnapshot>;
+}
+interface IndicatorPluginFigureRenderer {
+    key: string;
+    title?: string;
+    type?: 'line' | 'bar';
+    color?: string;
+    lineWidth?: number;
+    dashed?: boolean;
+    constant?: number;
+}
+interface IndicatorPluginRenderer {
+    indicatorName?: string;
+    shortName?: string;
+    paneId?: string;
+    minHeight?: number;
+    figures: IndicatorPluginFigureRenderer[];
+}
+interface IndicatorPluginEntry {
+    indicator: Indicator;
+    historyKey?: string;
+    compute?: (params: IndicatorPluginComputeParams) => number | null | undefined;
+    renderer?: IndicatorPluginRenderer;
+}
+interface IndicatorPluginDefinition {
+    indicatorEntries: IndicatorPluginEntry[];
+}
+
+export type { AIChatHistory, AIChatMessage, AiPayload, BacktestPriceMode, BacktestRunConfig, BaseIndicatorsHistorySnapshot, Bot, BotConfig, BotResults, BotStatus, BuildStrategySignalDraft, BuildStrategySignalParams, Candle, ChartColor, CompletedTest, Connector, ConnectorConfig, ConnectorCreator, ConnectorPluginDefinition, ConnectorRegistryEntry, CreateStrategyCore, CreateStrategyCoreParams, Direction, EOMPoint, Figure, Filters, GetTickers, Indicator, IndicatorPluginComputeParams, IndicatorPluginDefinition, IndicatorPluginEntry, IndicatorPluginFigureRenderer, IndicatorPluginRenderer, IndicatorSnapshot, Indicators, IndicatorsHistorySnapshot, Interval, Item, Items, Kline, KlineChartData, KlineChartItem, KlineRequest, MetricThreshold, Metrics, MinimalStat, MlCandleIndicatorsSnapshot, MonthlyEquityStats, OnChangeCompare, OnChangeFilters, Order, OrderLog, OrderLogData, OrderType, Position, PositionLog, PositionLogData, Provider, Signal, SignalAnalysis, SimpleOrderLogData, Sl, Strategy, StrategyAPI, StrategyAPIEntryParams, StrategyAPIMarketDataParams, StrategyAdditionalIndicatorsMap, StrategyAiAdapter, StrategyClosePlan, StrategyConfig, StrategyConfigGrid, StrategyCoreRunner, StrategyCreator, StrategyCreatorParams, StrategyDecision, StrategyDirectionalTpSlParams, StrategyDirectionalTpSlResult, StrategyEntryBaseParams, StrategyEntryModelFigures, StrategyEntryOrderPlan, StrategyEntryRuntimeBaseParams, StrategyEntryRuntimeBuilderParams, StrategyEntryRuntimeOptions, StrategyEntrySignalContext, StrategyEntrySignalDecisionBuilderParams, StrategyEntryTakeProfitsParams, StrategyFigureLine, StrategyFigurePoint, StrategyFigurePoints, StrategyFigureZone, StrategyHookAfterAiContext, StrategyHookAfterDecisionContext, StrategyHookAfterPlaceOrderContext, StrategyHookBaseContext, StrategyHookBeforeCloseContext, StrategyHookBeforeEntryGateContext, StrategyHookBeforePlaceOrderContext, StrategyHookEnrichContext, StrategyHookErrorContext, StrategyHookGateResult, StrategyHookInitContext, StrategyHookSkipContext, StrategyIndicatorsMap, StrategyIndicatorsState, StrategyLastTradeController, StrategyLastTradeControllerParams, StrategyManifest, StrategyMarketSnapshot, StrategyMlAdapter, StrategyPluginDefinition, StrategyRegistryEntry, StrategyResultConfig, StrategyResultEntry, StrategyResults, StrategyRuntimeAiOptions, StrategyRuntimeMlOptions, StrategySignalMetaParams, StrategySignalPriceParams, Test, TestCompare, TestCompareList, TestConnector, TestConnectorContext, TestConnectorCreator, TestResult, TestStat, TestSuite, TestThresholds, TestThresholdsKey, TestWorkerResult, TestingBox, TestingBoxResult, TestingOptions, ThresholdLevel, Ticker, Tp, Trend, TrendLine, TrendLineMode, TrendLineOptions, UIFilters };