/**
 * Observability Service
 *
 * Injectable service for observability (metrics, tracing, logging).
 * Works like CacheManager, DatabaseService, and ApiClient - can be injected into domain services.
 *
 * Adapters are initialized separately with their own configs.
 * This service only orchestrates - it doesn't know about adapter-specific configs.
 *
 * @module base/observability
 */
import type { ObservabilityAdapter, ObservabilityAdapterConfig, Metric, SpanOptions, Span, LogEntry, ObservabilityEvent, OperationContext, MonitoringOperationResult, ObservabilityServiceConfig, ObservabilityServiceInterface } from '@plyaz/types/observability';
/**
 * ObservabilityService - Main observability service that implements ObservabilityAdapter.
 *
 * This service orchestrates multiple adapters and can be injected into domain services.
 * Logger adapter is always included by default for console output.
 *
 * ```typescript
 * // 1. Initialize adapters separately
 * const datadogAdapter = new DatadogAdapter();
 * await datadogAdapter.initialize({ apiKey: '...', serviceName: 'my-service' });
 *
 * // 2. Create service - logger is auto-added by default
 * const observability = new ObservabilityService();
 * await observability.initialize({
 *   mode: 'parallel',
 *   adapters: [datadogAdapter], // Logger added automatically
 *   serviceName: 'my-service',
 * });
 *
 * // 3. Use in domain services (implements ObservabilityAdapter)
 * await observability.incrementCounter('api.requests', 1);
 * ```
 */
export declare class ObservabilityService implements ObservabilityAdapter, ObservabilityServiceInterface {
    readonly provider: "custom";
    readonly name = "ObservabilityService";
    private _isInitialized;
    private _config;
    private readonly logger;
    private readonly adapterEntries;
    private mode;
    private readonly noopAdapter;
    private loggerAdapter;
    constructor();
    get isInitialized(): boolean;
    /**
     * Check if service has at least one working adapter
     */
    get isReady(): boolean;
    /**
     * Get all adapters (for compatibility)
     */
    private get adapters();
    /**
     * Get initialized adapter entries
     */
    private get initializedEntries();
    /**
     * Get primary (non-failover) initialized adapters
     */
    private get primaryEntries();
    /**
     * Get failover initialized adapters
     */
    private get failoverEntries();
    /**
     * Check if input is an adapter with priority config
     */
    private isAdapterWithPriority;
    /**
     * Normalize adapter input to adapter with priority and failover config
     */
    private normalizeAdapter;
    /**
     * Initialize the observability service.
     * Logger adapter is always added by default unless explicitly disabled.
     * Adapters are sorted by priority (higher = first), with failover adapters after primary.
     */
    initialize(config: ObservabilityAdapterConfig & ObservabilityServiceConfig): Promise<void>;
    shutdown(): Promise<void>;
    isHealthy(): Promise<boolean>;
    flush(): Promise<void>;
    private get config();
    private executeOnAdapters;
    private executeSingle;
    /**
     * Execute on primary adapters in parallel.
     * If all primary adapters fail, execute on failover adapters.
     */
    private executeParallelWithFailover;
    private executeParallel;
    /**
     * Execute on primary adapters in priority order.
     * If all primary adapters fail, try failover adapters.
     */
    private executePriorityWithFailover;
    private withTimeout;
    recordMetric(metric: Metric): Promise<void>;
    incrementCounter(name: string, value?: number, tags?: Record<string, string>): Promise<void>;
    setGauge(name: string, value: number, tags?: Record<string, string>): Promise<void>;
    recordHistogram(name: string, value: number, tags?: Record<string, string>): Promise<void>;
    startSpan(options: SpanOptions): Span;
    withSpan<T>(options: SpanOptions, fn: (span: Span) => Promise<T>): Promise<T>;
    getActiveSpan(): Span | null;
    log(entry: LogEntry): Promise<void>;
    sendEvent(event: ObservabilityEvent): Promise<void>;
    /**
     * Track a service operation with automatic metrics and tracing.
     *
     * @example
     * ```typescript
     * const { result, metrics } = await observability.trackOperation(
     *   {
     *     serviceName: 'UserService',
     *     operation: 'create',
     *     entityType: 'user',
     *     startTime: Date.now(),
     *   },
     *   async () => {
     *     return await this.repository.create(userData);
     *   }
     * );
     * ```
     */
    trackOperation<T>(context: OperationContext, operation: () => Promise<T>): Promise<{
        result: T;
        metrics: MonitoringOperationResult;
    }>;
}
/**
 * Create an ObservabilityService with pre-initialized adapters.
 *
 * @example
 * ```typescript
 * // Initialize adapters first
 * const datadogAdapter = new DatadogAdapter();
 * await datadogAdapter.initialize({ apiKey: '...', serviceName: 'my-service' });
 *
 * // Create and initialize service (logger auto-added)
 * const observability = await createObservabilityService({
 *   mode: 'parallel',
 *   adapters: [datadogAdapter],
 *   serviceName: 'my-service',
 * });
 *
 * // Priority mode (fallback chain)
 * const observability = await createObservabilityService({
 *   mode: 'priority',
 *   adapters: [datadogAdapter, grafanaAdapter],
 *   serviceName: 'my-service',
 * });
 * ```
 */
export declare function createObservabilityService(config?: ObservabilityServiceConfig & {
    serviceName?: string;
    environment?: string;
}): Promise<ObservabilityService>;
//# sourceMappingURL=ObservabilityService.d.ts.map