import { OnModuleInit } from '@nestjs/common';
import { Observable } from 'rxjs';
import { TelescopeEntry } from '../interfaces/telescope-entry.interface';
import { TelescopeConfig } from '../interfaces/telescope-config.interface';
export interface ScalingNode {
    id: string;
    hostname: string;
    port: number;
    status: 'active' | 'inactive' | 'unhealthy';
    load: number;
    memoryUsage: number;
    cpuUsage: number;
    lastHeartbeat: Date;
    capabilities: string[];
    version: string;
}
export interface ScalingConfig {
    enabled: boolean;
    clusterMode: boolean;
    nodeId: string;
    discovery: {
        method: 'redis' | 'consul' | 'kubernetes' | 'manual';
        interval: number;
        timeout: number;
    };
    loadBalancing: {
        strategy: 'round-robin' | 'least-loaded' | 'consistent-hash' | 'random';
        healthCheckInterval: number;
        failoverEnabled: boolean;
    };
    dataDistribution: {
        sharding: boolean;
        shardKey: string;
        replicationFactor: number;
        consistencyLevel: 'eventual' | 'strong' | 'quorum';
    };
    communication: {
        protocol: 'http' | 'grpc' | 'redis-pubsub';
        timeout: number;
        retries: number;
        compression: boolean;
    };
}
export interface LoadBalancingResult {
    targetNode: ScalingNode;
    strategy: string;
    loadFactor: number;
    latency: number;
}
export interface ClusterHealth {
    totalNodes: number;
    activeNodes: number;
    unhealthyNodes: number;
    averageLoad: number;
    dataDistribution: {
        balanced: boolean;
        variance: number;
        recommendations: string[];
    };
    performance: {
        averageResponseTime: number;
        throughput: number;
        errorRate: number;
    };
}
export declare class HorizontalScalingService implements OnModuleInit {
    private readonly telescopeConfig;
    private readonly logger;
    private readonly nodes;
    private readonly nodeSubject;
    private readonly healthSubject;
    private readonly loadBalancer;
    private readonly loadBalancerCounters;
    private readonly nodeLoadHistory;
    private readonly config;
    private readonly localNode;
    private heartbeatInterval;
    private discoveryInterval;
    constructor(telescopeConfig: TelescopeConfig);
    onModuleInit(): Promise<void>;
    private getDefaultScalingConfig;
    private createLocalNode;
    private initializeScaling;
    private initializeLoadBalancer;
    private startHeartbeat;
    private startDiscovery;
    private sendHeartbeat;
    private updateLocalNodeMetrics;
    private getCpuUsage;
    private calculateLoad;
    private broadcastHeartbeat;
    private broadcastViaRedis;
    private broadcastViaHttp;
    private broadcastViaGrpc;
    private discoverNodes;
    private discoverNodesViaRedis;
    private discoverNodesViaConsul;
    private discoverNodesViaKubernetes;
    private updateNodeHealth;
    private markNodeUnhealthy;
    private cleanupInactiveNodes;
    private startHealthMonitoring;
    routeEntry(entry: TelescopeEntry): Promise<LoadBalancingResult>;
    private selectTargetNode;
    private roundRobinSelection;
    private getRoundRobinIndex;
    private leastLoadedSelection;
    private consistentHashSelection;
    private hashString;
    private randomSelection;
    private measureLatency;
    getClusterHealth(): Promise<ClusterHealth>;
    private analyzeDataDistribution;
    private measureClusterPerformance;
    private calculateThroughput;
    private calculateErrorRate;
    getNodeUpdates(): Observable<ScalingNode>;
    getClusterHealthUpdates(): Observable<ClusterHealth>;
    getNodes(): ScalingNode[];
    getActiveNodes(): ScalingNode[];
    getNodeById(nodeId: string): ScalingNode | undefined;
    isLocalNode(nodeId: string): boolean;
    getLocalNode(): ScalingNode;
    shutdown(): Promise<void>;
    private notifyShutdown;
}