import { IContextProvider } from '../../domain/interfaces/IContextProvider';
import { ILogBuffer } from '../../domain/interfaces/ILogBuffer';
import { ILogFilter } from '../../domain/interfaces/ILogFilter';
import { HealthStatus, ILogger, LoggerMetrics } from '../../domain/interfaces/ILogger';
import { ILogTransport } from '../../domain/interfaces/ILogTransport';
import type { LogLevel } from '../../domain/value-objects/LogLevel';
export declare class LogService implements ILogger {
    private readonly filter;
    private readonly buffer;
    private readonly transport;
    private readonly contextProvider;
    private readonly config;
    private metrics;
    private startTime;
    private metricsCollector;
    private readonly hostname;
    private readonly pid;
    private readonly maxConcurrentFlushes;
    private readonly maxPendingBatches;
    private destroyed;
    private destroyPromise?;
    private logSequence;
    private lastResourceSampleAt;
    private readonly resourceSampleIntervalMs;
    private readonly flushQueue;
    private inFlightFlushes;
    private idleResolvers;
    private queueDroppedEntries;
    private lastFlushWarningAt;
    constructor(filter: ILogFilter, buffer: ILogBuffer, transport: ILogTransport, contextProvider: IContextProvider, config: {
        appName: string;
        version: string;
        environment: string;
        labels: Record<string, string>;
        dynamicLabels: Record<string, () => string | number>;
        enableMetrics: boolean;
        maxConcurrentFlushes: number;
        maxPendingBatches: number;
        shutdownTimeoutMillis?: number;
    });
    private initializeMetrics;
    debug(message: string, context?: Record<string, unknown>): void;
    info(message: string, context?: Record<string, unknown>): void;
    warn(message: string, context?: Record<string, unknown>): void;
    error(message: string, context?: Record<string, unknown>): void;
    fatal(message: string, context?: Record<string, unknown>): void;
    withContext<T>(context: Record<string, unknown>, fn: () => T): T;
    withContextAsync<T>(context: Record<string, unknown>, fn: () => Promise<T>): Promise<T>;
    log(level: LogLevel, message: string, context?: Record<string, unknown>): void;
    trackEvent(eventName: string, properties?: Record<string, unknown>): void;
    private createLogEntry;
    flush(): Promise<void>;
    private enqueueFlush;
    private processFlushQueue;
    private sendFlushBatch;
    private notifyIfQueueIdle;
    private waitForQueueIdle;
    getMetrics(): LoggerMetrics;
    getHealth(): HealthStatus;
    destroy(): Promise<void>;
    private destroyInternal;
    private updateMetrics;
}
//# sourceMappingURL=LogService.d.ts.map