import { LogLevel, Logger } from '@voltagent/internal';
export { Logger } from '@voltagent/internal';
import { LoggerOptions as LoggerOptions$1 } from 'pino';
export { LoggerOptions as PinoLoggerOptions } from 'pino';
import * as _opentelemetry_api_logs from '@opentelemetry/api-logs';
import { LoggerProvider as LoggerProvider$1 } from '@opentelemetry/sdk-logs';

/**
 * Provider-agnostic logger options
 */
interface LoggerOptions {
    /**
     * Log level
     * @default "error" in production, "info" in development
     */
    level?: LogLevel;
    /**
     * Log format type
     * @default "json" in production, "pretty" in development
     */
    format?: "json" | "pretty";
    /**
     * Enable pretty printing in development
     * @default true if NODE_ENV !== "production"
     */
    pretty?: boolean;
    /**
     * Fields to redact from logs
     * @default ["password", "token", "apiKey", "secret"]
     */
    redact?: string[];
    /**
     * Maximum buffer size for in-memory log storage
     * @default 1000
     */
    bufferSize?: number;
    /**
     * Custom name for the logger instance
     */
    name?: string;
    /**
     * Pino-specific options to override defaults
     */
    pinoOptions?: LoggerOptions$1;
    /**
     * Additional provider-specific options
     */
    [key: string]: any;
}
interface LogEntry {
    timestamp: string;
    level: LogLevel;
    msg: string;
    component?: string;
    agentId?: string;
    conversationId?: string;
    workflowId?: string;
    executionId?: string;
    userId?: string;
    [key: string]: any;
}
interface LogFilter {
    level?: LogLevel;
    agentId?: string;
    conversationId?: string;
    workflowId?: string;
    executionId?: string;
    since?: Date;
    until?: Date;
    limit?: number;
}
interface LogBuffer {
    add(entry: LogEntry): void;
    query(filter?: LogFilter): LogEntry[];
    clear(): void;
    size(): number;
}

/**
 * Logger provider interface for implementing different logging backends
 */
interface LoggerProvider {
    /**
     * Provider name
     */
    name: string;
    /**
     * Create a new logger instance
     */
    createLogger(options?: LoggerOptions): LoggerWithProvider;
    /**
     * Create a child logger with additional context
     */
    createChildLogger(parent: Logger, bindings: Record<string, any>, options?: LoggerOptions): Logger;
    /**
     * Get the log buffer associated with this provider
     */
    getLogBuffer(): LogBuffer;
    /**
     * Flush any pending logs
     */
    flush?(): Promise<void>;
    /**
     * Close the logger provider
     */
    close?(): Promise<void>;
}
/**
 * Extended logger with provider access
 */
interface LoggerWithProvider extends Logger {
    /**
     * Get the underlying provider
     */
    getProvider(): LoggerProvider;
    /**
     * Get the log buffer
     */
    getBuffer(): LogBuffer;
}

/**
 * Pino-based logger provider
 */
declare class PinoLoggerProvider implements LoggerProvider {
    name: string;
    private customPinoOptions?;
    constructor(_bufferSize?: number, // Kept for backward compatibility but not used anymore
    _externalLogBuffer?: LogBuffer, // Kept for backward compatibility but not used anymore
    pinoOptions?: LoggerOptions$1);
    createLogger(options?: LoggerOptions): LoggerWithProvider;
    private wrapPinoInstance;
    createChildLogger(parent: Logger & {
        _pinoInstance?: any;
    }, bindings: Record<string, any>, _options?: LoggerOptions): Logger;
    getLogBuffer(): LogBuffer;
    flush(): Promise<void>;
    close(): Promise<void>;
    /**
     * Create Pino-specific options from generic logger options
     */
    private createPinoOptions;
}

/**
 * Get (or auto-create if not exists) the global logger provider
 */
declare function getGlobalLoggerProvider(): LoggerProvider;
/**
 * Set the global logger provider
 */
declare function setGlobalLoggerProvider(provider: LoggerProvider): void;
/**
 * Get the global log buffer
 */
declare function getGlobalLogBuffer(): LogBuffer;
/**
 * Extended logger with buffer access (for backward compatibility)
 */
type LoggerWithBuffer = LoggerWithProvider;
/**
 * Create a new Pino logger instance
 * @param options Logger options including pinoOptions
 * @param externalLogBuffer Optional external log buffer to sync logs to (deprecated)
 */
declare function createPinoLogger(options?: LoggerOptions, _externalLogBuffer?: any): LoggerWithBuffer;
/**
 * Connect an external log buffer to the existing logger
 * @deprecated Buffer management is now handled by @voltagent/core. This function does nothing.
 */
declare function connectExternalLogBuffer(_logger: LoggerWithProvider, _externalBuffer: LogBuffer): void;

/**
 * In-memory circular buffer for storing recent log entries
 */
declare class InMemoryLogBuffer implements LogBuffer {
    private buffer;
    private maxSize;
    constructor(maxSize?: number);
    add(entry: LogEntry): void;
    query(filter?: LogFilter): LogEntry[];
    clear(): void;
    size(): number;
    private getLevelPriority;
}

/**
 * Get the default log level based on environment
 */
declare function getDefaultLogLevel(): string;
/**
 * Get the default log format based on environment
 */
declare function getDefaultLogFormat(): "json" | "pretty";
/**
 * Get default redaction paths
 */
declare function getDefaultRedactionPaths(): string[];

declare class PinoOpenTelemetryBridge {
    private instrumentation?;
    private initialized;
    /**
     * Initialize the bridge with OpenTelemetry LoggerProvider
     */
    initialize(loggerProvider: LoggerProvider$1): void;
    /**
     * Check if the bridge is initialized
     */
    isInitialized(): boolean;
    /**
     * Get the OpenTelemetry logger for direct usage
     */
    getOtelLogger(name: string, version?: string): _opentelemetry_api_logs.Logger;
    /**
     * Clean shutdown
     */
    shutdown(): Promise<void>;
}
/**
 * Get or create the global Pino OpenTelemetry bridge
 */
declare function getPinoOpenTelemetryBridge(): PinoOpenTelemetryBridge;
/**
 * Initialize the global bridge with a LoggerProvider
 */
declare function initializePinoOpenTelemetry(loggerProvider: LoggerProvider$1): void;
/**
 * Check if OpenTelemetry bridge is active
 */
declare function isOpenTelemetryEnabled(): boolean;

export { InMemoryLogBuffer, type LogBuffer, type LogEntry, type LogFilter, type LoggerOptions, type LoggerProvider, type LoggerWithBuffer, type LoggerWithProvider, PinoLoggerProvider, PinoOpenTelemetryBridge, connectExternalLogBuffer, createPinoLogger, getDefaultLogFormat, getDefaultLogLevel, getDefaultRedactionPaths, getGlobalLogBuffer, getGlobalLoggerProvider, getPinoOpenTelemetryBridge, initializePinoOpenTelemetry, isOpenTelemetryEnabled, setGlobalLoggerProvider };