import type { BtcCacheArtifact, MarketRegimeArtifact, OiHistoryArtifact, PrescreenedArtifact, SharedArtifactContract, SharedArtifactValue } from "../artifacts.js";
import type { ScannerDependencyPolicyMode } from "../scanner-definition.js";
import type { ScannerDefinition } from "../scanner-definition.js";
import type { ScannerRuntimeState } from "../store/runtime-store.js";
import type { CandleResult, Instrument, OiSnapshot, ScannerId, SharedArtifactKey, SmMarket } from "../types.js";
import type { ClearingHouseState } from "../implementations/liquidation-watchdog.js";
import type { DslState } from "../../types/dsl/index.js";
type ReadonlyPrimitive = bigint | boolean | null | number | string | symbol | undefined;
type ReadonlyDeepArray<Item> = ReadonlyArray<ReadonlyDeep<Item>>;
type ReadonlyDeepObject<T extends object> = {
    readonly [Key in keyof T]: ReadonlyDeep<T[Key]>;
};
/**
 * Recursively marks nested scan-input payloads as readonly.
 * This is used for artifact-backed inputs so scanners cannot mutate shared
 * market intelligence snapshots in place.
 */
type ReadonlyDeep<T> = T extends ReadonlyPrimitive ? T : T extends (...args: never[]) => unknown ? T : T extends readonly (infer Item)[] ? ReadonlyDeepArray<Item> : T extends object ? ReadonlyDeepObject<T> : T;
/** Candle data indexed first by asset, then by timeframe within each candle result. */
export type CandlesByAsset = Readonly<Record<string, Readonly<CandleResult>>>;
/** Open-interest history indexed by asset name. */
export type OiHistoryByAsset = Readonly<Record<string, readonly Readonly<OiSnapshot>[]>>;
/**
 * Known built-in retained-context hints kept for built-in scanner ergonomics.
 * Runtime wiring remains open-keyed beyond these built-ins.
 */
interface BuiltInArtifactInputHints {
    readonly prescreened?: ReadonlyDeep<PrescreenedArtifact>;
    readonly "oi-history"?: ReadonlyDeep<OiHistoryArtifact>;
    readonly "btc-cache"?: ReadonlyDeep<BtcCacheArtifact>;
    readonly "market-regime"?: ReadonlyDeep<MarketRegimeArtifact>;
}
/**
 * Shared market intelligence resolved for one scan run.
 * These values come from shared artifact bindings rather than direct provider needs.
 */
export type ScanArtifactInputs = Readonly<Record<string, ReadonlyDeep<unknown> | undefined>> & BuiltInArtifactInputHints;
/**
 * Data payload assembled by engine for one scan run.
 * Top-level fields are provider-backed inputs; `artifacts` contains shared
 * market intelligence. Scanners should treat this snapshot as read-only input.
 */
export interface ScanInputs {
    readonly instruments?: readonly Readonly<Instrument>[];
    readonly candles?: CandlesByAsset;
    readonly smData?: readonly Readonly<SmMarket>[];
    readonly activePositions?: readonly Readonly<Record<string, unknown>>[];
    readonly clearingHouseState?: Readonly<ClearingHouseState>;
    readonly dslStates?: readonly Readonly<DslState>[];
    readonly artifacts: ScanArtifactInputs;
}
export interface ResolvedScannerDependency {
    readonly scanner: ScannerId;
    readonly contextKey: string;
    readonly updatedAt: number;
    readonly maxAgeMs?: number;
    readonly stale: boolean;
    readonly onMissing?: ScannerDependencyPolicyMode;
    readonly onStale?: ScannerDependencyPolicyMode;
    readonly value: ReadonlyDeep<unknown>;
}
/** Optional logger surface exposed to scanners and hooks. */
export interface ScannerLogger {
    debug?: (message: string, meta?: Record<string, unknown>) => void;
    info?: (message: string, meta?: Record<string, unknown>) => void;
    warn?: (message: string, meta?: Record<string, unknown>) => void;
    error?: (message: string, meta?: Record<string, unknown>) => void;
}
/** Shared-artifact accessors available to scanners for reading and writing shared market intelligence. */
export interface SharedArtifactAccessor {
    loadSharedArtifact: <Key extends SharedArtifactKey>(artifact: Key | SharedArtifactContract<Key>, opts?: {
        maxAgeMs?: number;
    }) => Promise<SharedArtifactValue<Key> | null>;
    saveSharedArtifact: <Key extends SharedArtifactKey>(artifact: Key | SharedArtifactContract<Key>, value: SharedArtifactValue<Key>) => Promise<void>;
}
/** Context passed once during scanner bootstrap. */
export interface ScannerInitContext<Cfg = unknown, St = unknown> extends SharedArtifactAccessor {
    address: string;
    scannerId: ScannerId;
    definition: ScannerDefinition<Cfg, St>;
    runtime: ScannerRuntimeState<Cfg, St>;
    config: Cfg;
    state: St;
    now: () => number;
    logger?: ScannerLogger;
    setState: (nextState: St) => Promise<void>;
}
/** Context passed on each scan run after runtime and inputs are loaded. */
export interface ScanContext<Cfg = unknown, St = unknown> extends ScannerInitContext<Cfg, St> {
    runStartedAt: number;
    inputs: ScanInputs;
    dependencies: readonly ResolvedScannerDependency[];
}
export {};
//# sourceMappingURL=context.d.ts.map