import { HttpClientConfig } from './http';
import { ServiceConfig } from './service-circuit-breaker';
import { OfflineQueueOptions } from './persistent-offline-queue';
import { CircuitBreakerConfig, TimingConfig, TraceSpan } from './enhanced-interceptors';
import { createVersionedApi, ApiVersion, VersioningStrategy } from './api-versioning';
/**
 * Telemetry configuration
 */
export interface TelemetryConfig {
    /** Callback for trace spans */
    onSpan?: (span: TraceSpan) => void;
    /** Callback for metrics */
    onMetric?: (metric: ServiceMetric) => void;
    /** Callback for errors */
    onError?: (error: ServiceError) => void;
    /** Service name for tracing */
    serviceName?: string;
    /** Sampling rate (0-1) */
    samplingRate?: number;
}
/**
 * Service metric data
 */
export interface ServiceMetric {
    name: string;
    value: number;
    unit: string;
    tags: Record<string, string>;
    timestamp: number;
}
/**
 * Service error data
 */
export interface ServiceError {
    message: string;
    code: string;
    stack?: string;
    context: Record<string, unknown>;
    timestamp: number;
}
/**
 * Service layer configuration
 */
export interface ServiceLayerConfig {
    /** Base URL for API requests */
    apiBaseUrl: string;
    /** Auth service URL (if different from API) */
    authBaseUrl?: string;
    /** Current API version */
    apiVersion?: ApiVersion;
    /** Minimum supported API version */
    minApiVersion?: ApiVersion;
    /** API versioning strategy */
    versioningStrategy?: VersioningStrategy;
    /** Enable offline queue (default: true) */
    enableOfflineQueue?: boolean;
    /** Enable circuit breakers (default: true) */
    enableCircuitBreakers?: boolean;
    /** Enable request deduplication (default: true) */
    enableDeduplication?: boolean;
    /** Enable distributed tracing (default: true) */
    enableTracing?: boolean;
    /** Enable request timing (default: true) */
    enableTiming?: boolean;
    /** Enable correlation IDs (default: true) */
    enableCorrelation?: boolean;
    /** Telemetry configuration */
    telemetry?: TelemetryConfig;
    /** Circuit breaker configuration */
    circuitBreaker?: CircuitBreakerConfig;
    /** Offline queue configuration */
    offlineQueue?: OfflineQueueOptions;
    /** Timing configuration */
    timing?: TimingConfig;
    /** Additional services to register */
    services?: ServiceConfig[];
    /** HTTP client configuration */
    httpClient?: HttpClientConfig;
    /** Called when service layer is initialized */
    onInitialized?: () => void;
    /** Called when a service becomes unhealthy */
    onServiceUnhealthy?: (serviceName: string) => void;
    /** Called when a service recovers */
    onServiceRecovered?: (serviceName: string) => void;
    /** Called when offline mode is entered */
    onOfflineMode?: () => void;
    /** Called when online mode is restored */
    onOnlineMode?: () => void;
}
/**
 * Service layer status
 */
export interface ServiceLayerStatus {
    initialized: boolean;
    online: boolean;
    services: {
        name: string;
        health: 'healthy' | 'degraded' | 'unhealthy' | 'unknown';
        circuitState: 'closed' | 'open' | 'half-open';
    }[];
    offlineQueue: {
        enabled: boolean;
        pending: number;
        processing: boolean;
    };
    metrics: {
        totalRequests: number;
        successRate: number;
        avgResponseTime: number;
    };
}
/**
 * Service Layer Facade
 *
 * Provides unified initialization and access to all service layer components.
 */
declare class ServiceLayerFacade {
    private config;
    private metrics;
    private cleanupFunctions;
    private _initialized;
    /**
     * Check if service layer is initialized
     */
    get initialized(): boolean;
    /**
     * Get current configuration
     */
    getConfig(): ServiceLayerConfig | null;
    /**
     * Initialize the service layer
     */
    initialize(config: ServiceLayerConfig): Promise<void>;
    /**
     * Get current service layer status
     */
    getStatus(): Promise<ServiceLayerStatus>;
    /**
     * Get versioned API client
     */
    getVersionedApi(version?: ApiVersion): ReturnType<typeof createVersionedApi>;
    /**
     * Reset metrics
     */
    resetMetrics(): void;
    /**
     * Force process offline queue
     */
    processOfflineQueue(): Promise<void>;
    /**
     * Reset all circuit breakers
     */
    resetCircuitBreakers(): void;
    /**
     * Dispose and cleanup
     */
    dispose(): void;
    /**
     * Setup circuit breakers for services
     */
    private setupCircuitBreakers;
    /**
     * Setup enhanced interceptors
     */
    private setupInterceptors;
    /**
     * Setup offline queue
     */
    private setupOfflineQueue;
    /**
     * Setup event listeners
     */
    private setupEventListeners;
    /**
     * Setup telemetry integration
     */
    private setupTelemetry;
}
/**
 * Global service layer instance
 */
export declare const serviceLayer: ServiceLayerFacade;
/**
 * Initialize the service layer (convenience function)
 */
export declare function initializeServiceLayer(config: ServiceLayerConfig): Promise<void>;
/**
 * Get service layer status (convenience function)
 */
export declare function getServiceLayerStatus(): Promise<ServiceLayerStatus>;
/**
 * Dispose service layer (convenience function)
 */
export declare function disposeServiceLayer(): void;
export {};