/** Default interval for periodic memory snapshots (30 seconds) */
export declare const DEFAULT_MEMORY_MONITORING_INTERVAL_MS = 30000;
export interface CacheStats {
    name: string;
    entries: number;
    maxEntries?: number;
    estimatedSizeBytes?: number;
    /** Cache backend type (memory, redis, api) */
    backend?: string;
}
export interface HeapStats {
    usedHeapSizeMB: number;
    totalHeapSizeMB: number;
    heapSizeLimitMB: number;
    externalMemoryMB: number;
    heapUsedPercent: number;
    rss?: number;
}
export interface MemorySnapshot {
    timestamp: string;
    heap: HeapStats;
    caches: CacheStats[];
    totalCacheEntries: number;
    gcStats?: GCStats;
}
export interface MonitoringCacheStats {
    name: string;
    entries: number;
    maxEntries?: number;
    estimatedSizeBytes?: number;
    backend?: string;
}
export interface MemoryMonitoringLogContext {
    heapUsedMB: number;
    heapTotalMB: number;
    heapLimitMB: number;
    heapUsedPercent: number;
    rssMB?: number;
    totalCacheEntries: number;
    topCaches: MonitoringCacheStats[];
}
export interface MemoryMonitoringEnv {
    get(key: string): string | null | undefined;
}
export interface MemoryMonitoringConfig {
    enabled: boolean;
    intervalMs: number;
}
export interface MemoryMonitoringState {
    active: boolean;
    intervalMs: number | undefined;
}
export interface GCStats {
    majorGCs: number;
    minorGCs: number;
    lastGCDurationMs?: number;
}
export interface PendingRapidHeapGrowth {
    baselineHeapUsedMB: number;
    observedGrowthMB: number;
}
export interface RapidHeapGrowthEvaluationInput {
    previousHeapUsedMB: number;
    currentHeapUsedMB: number;
    currentHeapUsedPercent?: number;
    pending: PendingRapidHeapGrowth | undefined;
    thresholdMB: number;
    memoryPressureWarningThresholdPercent?: number;
}
export interface RapidHeapGrowthEvaluation {
    shouldWarn: boolean;
    growthMB?: number;
    observedGrowthMB?: number;
    pending?: PendingRapidHeapGrowth;
}
export interface RapidHeapGrowthState {
    lastHeapUsedMB: number;
    pending: PendingRapidHeapGrowth | undefined;
}
export declare function registerCache(name: string, getStats: () => CacheStats): void;
export declare function unregisterCache(name: string): void;
export declare function getHeapStats(): HeapStats;
export interface EffectiveHeapLimitInput {
    /** Real V8 `heap_size_limit` (MB) read from runtime heap statistics, when available. */
    runtimeHeapLimitMB: number | undefined;
    /** Limit (MB) parsed from CLI args / `DENO_V8_FLAGS` env strings — unverified. */
    configuredHeapLimitMB: number | undefined;
}
/**
 * Resolve the heap limit used for `heapUsedPercent` and memory-pressure
 * thresholds.
 *
 * The runtime-reported limit always wins. Env/CLI strings like
 * `DENO_V8_FLAGS` only describe a limit the runtime may silently ignore:
 * `deno compile` binaries have shipped without applying `DENO_V8_FLAGS`,
 * aborting at V8's ~2048MB default while the env string claimed 4096MB —
 * which made pressure eviction mathematically unreachable
 * (veryfront-issue-inbox#269). When the runtime limit cannot be read, an
 * env-derived limit is therefore clamped to the V8 default so eviction
 * still fires before the real ceiling.
 */
export declare function resolveEffectiveHeapLimitMB(input: EffectiveHeapLimitInput): number;
export declare function getCacheStats(): CacheStats[];
export declare function getMemorySnapshot(): MemorySnapshot;
export declare function getTopCacheStats(caches: CacheStats[], limit?: number): MonitoringCacheStats[];
export declare function getMemoryMonitoringLogContext(snapshot: MemorySnapshot, topCacheLimit?: number): MemoryMonitoringLogContext;
export declare function getMemoryMonitoringConfig(env: MemoryMonitoringEnv): MemoryMonitoringConfig;
export declare function getInitialRapidHeapGrowthState(initialHeapUsedMB: number): RapidHeapGrowthState;
export declare function getRapidHeapGrowthEvaluation(input: RapidHeapGrowthEvaluationInput): RapidHeapGrowthEvaluation;
export declare function getMemoryMonitoringState(): MemoryMonitoringState;
export declare function forceGC(): Promise<boolean>;
export declare function startMemoryMonitoring(intervalMs?: number): void;
export declare function startConfiguredMemoryMonitoring(env: MemoryMonitoringEnv): MemoryMonitoringConfig;
export declare function stopMemoryMonitoring(): void;
export declare function setHeapWarningThreshold(threshold: number): void;
export declare const DEFAULT_PROFILER_WARNING_THRESHOLD = 65;
export declare const DEFAULT_PROFILER_CRITICAL_THRESHOLD = 80;
export interface MemoryPressureThresholds {
    warning: number;
    critical: number;
}
/** Pure threshold evaluation. Runtime env overrides are passed by `checkMemoryPressure`. */
export declare function evaluateMemoryPressure(heapUsedPercent: number, thresholds?: MemoryPressureThresholds): {
    critical: boolean;
    warning: boolean;
};
export declare function checkMemoryPressure(): {
    critical: boolean;
    warning: boolean;
    heapUsedPercent: number;
};
export type { MemorySnapshot as MemorySnapshotType };
//# sourceMappingURL=profiler.d.ts.map