import { API, Characteristic, DynamicPlatformPlugin, Logger, PlatformAccessory, PlatformConfig, Service } from 'homebridge';
import { BaseCircuit, Body, Circuit, Heater, IntelliCenterParams, IntelliCenterRequest, IntelliCenterResponse, Module, Panel, Pump, PumpCircuit, Sensor } from './types';
import { HeaterAccessory } from './heaterAccessory';
import { CircuitBreakerState } from './errorHandling';
import { PentairConfig } from './configValidation';
/**
 * HomebridgePlatform
 * This class is the main constructor for your plugin, this is where you should
 * parse the user config and discover/register accessories with Homebridge.
 */
export declare class PentairPlatform implements DynamicPlatformPlugin {
    readonly log: Logger;
    readonly config: PlatformConfig;
    readonly api: API;
    readonly Service: typeof Service;
    readonly Characteristic: typeof Characteristic;
    readonly accessoryMap: Map<string, PlatformAccessory>;
    readonly heaters: Map<string, PlatformAccessory>;
    readonly heaterInstances: Map<string, HeaterAccessory>;
    private connection;
    private maxBufferSize;
    private discoverCommandsSent;
    private discoverCommandsFailed;
    private discoveryBuffer;
    private discoveryTimeout;
    private buffer;
    private pumpIdToCircuitMap;
    private pumpToCircuitsMap;
    private circuitToPumpMap;
    private pumpCircuitToPumpMap;
    private activePumpCircuits;
    private static shutdownHandlersSetup;
    private temperatureReadings;
    private temperatureUnitValidated;
    private temperatureValidationInterval;
    private lastMessageReceived;
    private isSocketAlive;
    private reconnecting;
    private lastReconnectTime;
    private parseErrorCount;
    private parseErrorResetTime;
    private commandQueue;
    private processingQueue;
    private heartbeatInterval;
    private circuitBreaker;
    private healthMonitor;
    private rateLimiter;
    private deadLetterQueue;
    private validatedConfig;
    constructor(log: Logger, config: PlatformConfig, api: API);
    private validateConfiguration;
    private initializeComponents;
    private initializeDataStructures;
    private setupApiEventHandlers;
    private setupHeartbeatMonitoring;
    /**
     * Validate network connectivity to IntelliCenter before attempting Telnet connection
     */
    private validateNetworkConnectivity;
    private createNetworkCheckContext;
    private setupNetworkCheckHandlers;
    private initiateNetworkConnection;
    connectToIntellicenter(): Promise<void>;
    private buildTelnetParams;
    private validateNetworkConnectivityIfNeeded;
    private attemptConnection;
    private handleConnectionError;
    setupSocketEventHandlers(): void;
    private handleDataReceived;
    private isCompleteMessage;
    private processCompleteMessage;
    private processMessageLine;
    private isValidJsonStructure;
    private bufferIncompleteData;
    private handleConnectionEstablished;
    private resetDiscoveryState;
    private startDeviceDiscovery;
    private handleConnectionReady;
    private handleLoginFailed;
    private handleConnectionClosed;
    private handleSocketError;
    private handleConnectionEnded;
    private handleResponseReady;
    /**
     * This function is invoked when homebridge restores cached accessories from disk at startup.
     * It should be used to setup event handlers for characteristics and update respective values.
     */
    configureAccessory(accessory: PlatformAccessory): void;
    private logPumpCircuitUpdate;
    private logStandalonePumpUpdate;
    private handlePumpCircuitUpdate;
    private handleExistingAccessoryUpdate;
    private handleStandalonePumpUpdate;
    private handleUnregisteredDevice;
    private processChange;
    private handleParseError;
    private handleErrorResponse;
    private handleNotifyListResponse;
    handleUpdate(response: IntelliCenterResponse): Promise<void>;
    private logPumpUpdateStart;
    private updatePumpCircuitProperties;
    private logPumpUpdateComplete;
    updatePump(accessory: PlatformAccessory, params: IntelliCenterParams): void;
    updateCircuit(accessory: PlatformAccessory, params: IntelliCenterParams): void;
    private logCircuitUpdate;
    private performCircuitUpdate;
    private updateBodyCircuit;
    private updateAccessoryAndCreateCircuit;
    private handlePumpSensorUpdates;
    private handlePumpControlledCircuitUpdate;
    private handleNonPumpControlledCircuitUpdate;
    private handleBodyCircuitHeaterUpdate;
    updateSensor(accessory: PlatformAccessory, params: IntelliCenterParams): void;
    updateFeatureRpmSensorForPumpCircuit(pumpCircuit: PumpCircuit): void;
    private findFeatureRpmAccessory;
    private searchForMatchingRpmSensor;
    private isMatchingRpmSensor;
    private updateFeatureRpmAccessory;
    private logRpmSensorNotFound;
    updateFeatureRpmSensorForCircuit(circuit: Circuit): void;
    updateHeaterStatuses(body: Body): void;
    updateHeaterRpmSensor(heater: Heater, body: Body): void;
    updateHeaterRpmSensorsForPumpCircuit(pumpCircuit: PumpCircuit): void;
    /**
     * Validate speed value for standalone pump
     */
    private validateStandalonePumpSpeed;
    /**
     * Check if accessory is a heater RPM sensor
     */
    private isHeaterRpmSensor;
    /**
     * Check if speed is in heater range
     */
    private isSpeedInHeaterRange;
    /**
     * Update a single heater RPM sensor
     */
    private updateSingleHeaterRpmSensor;
    updateHeaterRpmSensorsForStandalonePump(pumpId: string, speed: string, speedType: string): void;
    /**
     * This is an example method showing how to register discovered accessories.
     * Accessories must only be registered once, previously created accessories
     * must not be registered again to prevent "duplicate UUID" errors.
     */
    discoverDevices(): void;
    discoverDeviceType(deviceType: string): void;
    /**
     * Handle discovery command timeout
     */
    private handleDiscoveryTimeout;
    /**
     * Complete discovery even with partial data from failed commands
     */
    private completeDiscoveryWithPartialData;
    handleDiscoveryResponse(response: IntelliCenterResponse): void;
    private clearDiscoveryTimeout;
    private mergeDiscoveryResponse;
    private getDiscoveryCommandCounts;
    private shouldContinueDiscovery;
    private sendNextDiscoveryCommand;
    private shouldRetryFailedCommands;
    private shouldRetryCommand;
    private retryFailedCommand;
    private completeDiscovery;
    private initializeDiscoveryState;
    private processPanelSensors;
    private processPumpCircuits;
    private createPumpSensors;
    private processPanelPumps;
    /**
     * Register discovered accessories with HomeKit
     */
    private registerDiscoveredAccessories;
    private createDiscoveryContext;
    private processAllPanels;
    private processSinglePanel;
    private finalizeDiscovery;
    private processModuleBodies;
    private associateBodyWithPump;
    private processModuleFeatures;
    private processPanelFeatures;
    private collectModuleHeaters;
    private processHeaters;
    private calculateHeaterPumpPriority;
    private isValidHeaterPumpCircuit;
    private findHeaterPumpCircuit;
    private getExpectedAccessoryId;
    private handlePumpAccessoryId;
    private handlePumpGpmSensor;
    private removeOrphanedAccessory;
    cleanupOrphanedAccessories(discoveredAccessoryIds: Set<string>): void;
    discoverHeater(heater: Heater, bodyMap: ReadonlyMap<string, Body>): void;
    discoverCircuit(panel: Panel, module: Module | null, circuit: Circuit, pumpCircuit: PumpCircuit | undefined): void;
    discoverTemperatureSensor(panel: Panel, module: Module | null, sensor: Sensor): void;
    discoverFeatureRpmSensor(panel: Panel, feature: Circuit, pumpCircuit: PumpCircuit): void;
    discoverBodyRpmSensor(panel: Panel, body: Body, pumpCircuit: PumpCircuit): void;
    discoverHeaterRpmSensor(panel: Panel, heater: Heater, body: Body, pumpCircuit: PumpCircuit): void;
    discoverPumpGpmSensor(panel: Panel, pump: Pump): void;
    discoverPumpRpmSensor(panel: Panel, pump: Pump): void;
    discoverPumpWattsSensor(panel: Panel, pump: Pump): void;
    updatePumpSensors(pumpCircuit: PumpCircuit): void;
    /**
     * Update all pump sensors when any circuit changes for that pump
     */
    updateAllPumpSensorsForChangedCircuit(pumpCircuit: PumpCircuit): Promise<void>;
    /**
     * Find pump object by ID in discovered accessories
     */
    private findPumpObjectById;
    /**
     * Process a single pump circuit for RPM calculation
     */
    private processPumpCircuitForRpm;
    /**
     * Get the highest RPM among all enabled circuits for a given pump
     */
    getHighestRpmForPump(pumpId: string): number | null;
    /**
     * Check circuit context for activity status
     */
    private checkCircuitContext;
    /**
     * Check feature context for activity status
     */
    private checkFeatureContext;
    /**
     * Check body context for activity status
     */
    private checkBodyContext;
    /**
     * Check if a pump circuit is currently active by looking for corresponding feature/circuit status
     * (Same logic as WATTS sensor)
     */
    private isPumpCircuitActive;
    /**
     * Update all pump sensors (RPM, GPM, WATTS) with the specified RPM value
     */
    updatePumpSensorsWithRpm(pumpId: string, rpm: number): void;
    updatePumpSensorsForStandalonePump(pumpId: string, speed: string, speedType: string): void;
    subscribeForUpdates(circuit: BaseCircuit, keys: ReadonlyArray<string>): void;
    getConfig(): PentairConfig;
    json(data: unknown): string;
    private jsonSeenObjects?;
    /**
     * Get system health and status information
     */
    getSystemHealth(): {
        isHealthy: boolean;
        lastSuccessfulOperation: Date;
        consecutiveFailures: number;
        lastError: string | undefined;
        averageResponseTime: number | undefined;
        circuitBreaker: {
            state: CircuitBreakerState;
            failureCount: number;
            lastFailureTime: Date | null;
        };
        rateLimiter: {
            currentRequests: number;
            maxRequests: number;
            windowMs: number;
            canMakeRequest: boolean;
        };
        connection: {
            isSocketAlive: boolean;
            lastMessageReceived: Date;
            reconnecting: boolean;
            commandQueueLength: number;
        };
    };
    /**
     * Reset error handling components (useful for testing or manual recovery)
     */
    resetErrorHandling(): void;
    sendCommandNoWait(command: IntelliCenterRequest): void;
    private sanitizeCommand;
    private processCommandQueue;
    delay(ms: number): Promise<unknown>;
    private maybeReconnect;
    /**
     * Build pump-circuit associations for proper device management
     * Maps pumps to their controlled circuits and vice versa
     */
    private buildPumpCircuitAssociations;
    /**
     * Get the pump ID that controls a specific circuit
     */
    getPumpForCircuit(circuitId: string): string | undefined;
    /**
     * Get all circuit IDs controlled by a specific pump
     */
    getCircuitsForPump(pumpId: string): Set<string> | undefined;
    /**
     * Get the pump ID for a specific pump circuit
     */
    getPumpForPumpCircuit(pumpCircuitId: string): string | undefined;
    /**
     * Find the pump circuit ID that controls a specific circuit
     */
    findPumpCircuitForCircuit(circuitId: string): string | undefined;
    /**
     * Log detailed pump discovery mapping in requested format
     */
    logPumpDiscoveryMapping(pump: Pump, panel: Panel): void;
    /**
     * Log current pump-circuit associations for debugging
     */
    logPumpCircuitAssociations(): void;
    /**
     * Update all pump sensors when heater status changes
     */
    private updateAllPumpSensorsForHeaterChange;
    /**
     * Directly update pump sensors by pump ID (used for heater changes)
     */
    private updatePumpSensorsDirectly;
    /**
     * Update pump object circuits array when standalone pump circuit changes
     */
    private updatePumpObjectCircuits;
    /**
     * Start temperature unit validation monitoring
     */
    private startTemperatureUnitValidation;
    /**
     * Collect temperature reading for validation
     */
    private collectTemperatureReading;
    /**
     * Validate temperature unit consistency with IntelliCenter readings
     */
    private validateTemperatureUnits;
    /**
     * Setup graceful shutdown handlers for SIGTERM and SIGINT signals
     */
    private setupGracefulShutdown;
    private clearTimersAndIntervals;
    private cleanupConnection;
    private clearDataStructures;
    private resetState;
    /**
     * Cleanup method for tests and graceful shutdown
     * Clears intervals, closes connections, and removes event listeners
     */
    cleanup(): Promise<void>;
}
//# sourceMappingURL=platform.d.ts.map