import { DyNTS_SingletonServiceBase } from '../base/singleton.service-base';
/**
 * FR-193 (2026-06-15) — bedrock OOM korai-figyelmeztető heap-watchdog.
 *
 * MIÉRT: a Node heap-OOM (`--max-old-space-size` túllépés, pl. egy óriási JSON.parse)
 * a process-t AZONNAL megöli — `process.on('uncaughtException')` NEM kapja el, így a
 * crash pillanatában már nincs mód a hibát rögzíteni. Az EGYETLEN megbízható idő a
 * rögzítésre a crash ELŐTT van. E watchdog periodikusan figyeli a heap-kihasználtságot,
 * és amikor egy konfigurálható küszöböt átlép, TARTÓS rekordot hagy (DyFM_Log +
 * `DyNTS_GlobalService.globalErrorHandler` → az Errors-sink, amit minden szerver megkap)
 * — így egy OOM-hajlamos szerver NYOMOT hagy mielőtt elszáll, és a kuszob-atlepés
 * lathato a dashboard-on / Discord-on.
 *
 * MIT NEM csinál: NEM állítja le/újraindítja a process-t (az a konténer-szintű
 * `restart:` policy dolga), és NEM próbálja elkapni a fatal OOM-ot (nem lehet). Tisztán
 * MEGFIGYELÉS + RÖGZÍTÉS + opcionális `onCritical` hook (amivel a fogyasztó terhet dobhat).
 *
 * Hiszterézis: a küszöböket CSAK állapot-VÁLTÁSkor jelzi (normal→warning→critical), és
 * a `recoveryMargin`-nyit a warning ALÁ esve jelez 'recovered'-et — így nem spamel a
 * küszöb körül oszcilláló heap.
 *
 * Használat (opt-in, mint a `DyNTS_Logs_Service`):
 *   DyNTS_MemoryGuard.getInstance().install();              // default settings
 *   DyNTS_MemoryGuard.getInstance().install({ onCritical }); // custom hook
 * VAGY automatikusan: a base `App` startup feltelepíti, ha
 *   `DyNTS_global_settings.memoryGuard.enabled === true` (alapértelmezés szerint igen).
 */
/** Egy MemoryGuard esemény — küszöb-átlépés vagy helyreállás. */
export interface DyNTS_MemoryGuard_Event {
    /** `warning` / `critical` küszöb-átlépés, vagy `recovered` (vissza normal-ba). */
    level: 'warning' | 'critical' | 'recovered';
    /** Heap használat MB-ban (`process.memoryUsage().heapUsed`). */
    heapUsedMb: number;
    /** Heap plafon MB-ban (`v8.getHeapStatistics().heap_size_limit` — a `--max-old-space-size`). */
    heapLimitMb: number;
    /** heapUsed / heapLimit * 100 (egész %-ra kerekítve). */
    heapPct: number;
    /** Resident Set Size MB-ban (teljes process-memória, heap + non-heap). */
    rssMb: number;
    /** External (C++ / Buffer) memória MB-ban. */
    externalMb: number;
    /** A közelmúlt GC-hányada (GC-ben töltött idő / poll-ablak; 0..1) — a mark-compact-thrash / OOM-precursor jelzője. */
    gcFraction: number;
    /** Mi váltotta ki az esemény-szintet: a heap-% küszöb, a GC-thrash, vagy mindkettő. */
    trigger: 'heap' | 'gc' | 'heap+gc' | 'recovery';
    /** Esemény időbélyege (ISO). */
    at: string;
}
/** `install()` opcionális override-jai (a `DyNTS_global_settings.memoryGuard` FÖLÉ). */
export interface DyNTS_MemoryGuard_Config {
    /** Poll-intervallum ms-ben. Default: 10000. */
    pollIntervalMs?: number;
    /** Warning küszöb a heap-plafon %-ában. Default: 85. */
    heapWarningThreshold?: number;
    /** Critical küszöb a heap-plafon %-ában. Default: 95. */
    heapCriticalThreshold?: number;
    /** A warning küszöb ALATTI margó %-ban a 'recovered'-hez (hiszterézis). Default: 10. */
    recoveryMargin?: number;
    /** Megőrzött események max száma (ring-buffer). Default: 100. */
    maxHistoryCount?: number;
    /** GC-hányad-küszöb a `warning`-hoz (0..1). Default: 0.40. */
    gcWarningFraction?: number;
    /** GC-hányad-küszöb a `critical`-hoz (0..1). Default: 0.60. */
    gcCriticalFraction?: number;
    /** `uncaughtException` crash-handler telepítése (teljes-részletű error-entry + tiszta exit). Default: true. */
    installCrashHandlers?: boolean;
    /** Tartós critical → tiszta exit (a wrapper újraindít). Default: false. */
    exitOnSustainedCritical?: boolean;
    /** Hány egymást követő critical poll után lép ki. Default: 3. */
    sustainedCriticalPolls?: number;
    /** A graceful-exit kódja. Default: 137. */
    exitCode?: number;
    /** Boot-grace ms az `exitOnSustainedCritical`-hez (a guard-install utáni ennyi ms-ben NEM lép ki). Default: 60000. */
    bootGraceMs?: number;
    /** Hook, amit a `critical` küszöb átlépésekor hívunk (pl. terhelés-dobás). */
    onCritical?: (event: DyNTS_MemoryGuard_Event) => void;
}
type DyNTS_MemoryGuard_State = 'normal' | 'warning' | 'critical';
export declare class DyNTS_MemoryGuard extends DyNTS_SingletonServiceBase {
    static getInstance(): DyNTS_MemoryGuard;
    private timer;
    private installed;
    private state;
    private pollIntervalMs;
    private warnPct;
    private critPct;
    private recoveryMargin;
    private maxHistoryCount;
    private gcWarnFraction;
    private gcCritFraction;
    private exitOnSustainedCritical;
    private sustainedCriticalPolls;
    private exitCode;
    private bootGraceMs;
    /** A guard-install időbélyege (a boot-grace számításához; 0 = még nem telepített). */
    private installedAt;
    private onCritical?;
    private readonly history;
    private peakHeapPct;
    private peakRssMb;
    private gcObserver;
    private gcEvents;
    private criticalStreak;
    private crashHandler;
    protected constructor();
    /**
     * Elindítja a heap-watchdogot. Idempotens (többszöri hívás no-op). A `config`
     * felülírja a `DyNTS_global_settings.memoryGuard` értékeit, ami a beépített
     * defaultokat írja felül. SOHA nem dob — egy figyelő-réteg nem dönthet be egy
     * szervert (minden hiba try/catch-elt + descriptive-en logolt).
     */
    install(config?: DyNTS_MemoryGuard_Config): void;
    /** A heap-plafon byte-ban (`--max-old-space-size`). Külön metódus a spec-mockoláshoz. */
    private getHeapLimitBytes;
    /**
     * Egy poll-ciklus: kiolvassa a heap-kihasználtságot, frissíti a csúcsokat, és a
     * hiszterézis-állapotgép szerint esemény-átlépéskor rögzít + logol. SOHA nem dob.
     */
    private poll;
    /** Esemény ring-bufferbe + log + (warning/critical esetén) tartós error-sink. */
    private recordEvent;
    /**
     * A pillanatnyi heap-nyomás (heap-% + GC-hányad → szint) — a FOGYASZTÓK (pl. egy API-controller) ezzel
     * gate-elhetik a nehéz műveleteket (load-shed). Olvasás-only, mellékhatás nélkül; nem igényli az install-t.
     */
    pressure(): {
        level: 'ok' | 'warning' | 'critical';
        heapUsedMb: number;
        heapLimitMb: number;
        heapPct: number;
        rssMb: number;
        gcFraction: number;
    };
    /** `true`, ha a NEHÉZ műveleteket le kell shed-elni (critical nyomás) — a fogyasztó load-shed gate-jének. */
    shouldShedLoad(): boolean;
    /** A GC-hányad az utolsó `pollIntervalMs` ablakban (GC-ms / ablak-ms; clamp [0..1]). Nincs GC-observer → 0. */
    private recentGcFraction;
    /** A 'gc' perf-entry-k figyelője — a GC-ben töltött időt gyűjti a gördülő ablakhoz. Best-effort (nem kritikus). */
    private installGcObserver;
    /**
     * Process-szintű `uncaughtException` crash-handler: a (különben néma) crash ELŐTT TELJES-RÉSZLETŰ error-entry
     * (message + stack + memória-snapshot) az error-sinkbe, majd tiszta exit (a wrapper/restart-policy újraindít).
     * Az `unhandledRejection`-t a base App már rögzíti; ez az eddig-fedetlen `uncaughtException`-t fedi le.
     */
    private installCrashHandlers;
    /** Tartós-critical graceful-exit: végső error-entry + tiszta exit (a wrapper újraindít a kriptikus 134 helyett). */
    private gracefulExit;
    /** A megőrzött események (legrégebbi → legújabb). Csak olvasásra. */
    getHistory(): DyNTS_MemoryGuard_Event[];
    /** Pillanatnyi állapot + csúcsok diagnosztikához (pl. egy status-endpoint). */
    getStatus(): {
        installed: boolean;
        state: DyNTS_MemoryGuard_State;
        peakHeapPct: number;
        peakRssMb: number;
        eventCount: number;
    };
    /** Telepítve van-e a watchdog. */
    isInstalled(): boolean;
    /**
     * Leállítja a watchdogot + visszaállítja az állapotot. Graceful shutdown-hoz ÉS a
     * spec-ek `afterEach`-éhez (a singleton-state ne szivárogjon a tesztek közt).
     */
    _teardownForTesting(): void;
}
export {};
//# sourceMappingURL=memory-guard.service.d.ts.map