homebridge-pentair-intellicenter-ai/dist/errorHandling.d.ts

Homebridge plugin for the Pentair IntelliCenter pool control system (maintained with AI assistance)

/**
 * Error handling and resilience utilities for Pentair Platform
 */
import { IntelliCenterRequest } from './types';
export interface RetryOptions {
    maxAttempts: number;
    baseDelay: number;
    maxDelay: number;
    backoffFactor: number;
    retryableErrors?: string[];
}
export interface CircuitBreakerOptions {
    failureThreshold: number;
    resetTimeout: number;
    monitoringPeriod: number;
}
export declare enum CircuitBreakerState {
    CLOSED = "closed",// Normal operation
    OPEN = "open",// Circuit breaker is open, rejecting calls
    HALF_OPEN = "half-open"
}
export declare class CircuitBreaker {
    private options;
    private state;
    private failureCount;
    private lastFailureTime;
    private successCount;
    constructor(options: CircuitBreakerOptions);
    execute<T>(operation: () => Promise<T>): Promise<T>;
    private onSuccess;
    private onFailure;
    getState(): CircuitBreakerState;
    getStats(): {
        state: CircuitBreakerState;
        failureCount: number;
        lastFailureTime: number;
        successCount: number;
    };
    reset(): void;
}
export declare class RetryManager {
    static withRetry<T>(operation: () => Promise<T>, options: RetryOptions, logger?: (message: string) => void): Promise<T>;
}
export interface ConnectionHealth {
    isHealthy: boolean;
    lastSuccessfulOperation: number;
    consecutiveFailures: number;
    lastError?: string;
    responseTime?: number;
}
export declare class HealthMonitor {
    private consecutiveFailures;
    private lastSuccessfulOperation;
    private lastError?;
    private responseTimeHistory;
    private readonly maxHistorySize;
    recordSuccess(responseTime?: number): void;
    recordFailure(error: string): void;
    getHealth(): ConnectionHealth;
    reset(): void;
}
export interface DeadLetterQueueItem {
    command: IntelliCenterRequest;
    timestamp: number;
    attempts: number;
    lastError: string;
    originalMessageId: string;
}
export declare class DeadLetterQueue {
    private queue;
    private maxSize;
    private maxRetentionMs;
    constructor(maxSize?: number, maxRetentionMs?: number);
    add(command: IntelliCenterRequest, attempts: number, error: string, originalMessageId: string): void;
    getFailedCommands(): ReadonlyArray<DeadLetterQueueItem>;
    getStats(): {
        queueSize: number;
        maxSize: number;
        oldestTimestamp: number | null;
        newestTimestamp: number | null;
    };
    clear(): void;
    private cleanup;
}
export declare class RateLimiter {
    private maxRequests;
    private windowMs;
    private requests;
    constructor(maxRequests: number, windowMs: number);
    private getNow;
    canMakeRequest(): boolean;
    recordRequest(): boolean;
    getStats(): {
        currentRequests: number;
        maxRequests: number;
        windowMs: number;
        canMakeRequest: boolean;
    };
}
//# sourceMappingURL=errorHandling.d.ts.map