/**
 * RedlockToolkit Error Classes
 * Comprehensive error handling with detailed context
 */
import { LockStats } from "./types";
/**
 * Base class for all RedlockToolkit errors
 */
export declare abstract class RedlockToolkitError extends Error {
    readonly timestamp: number;
    readonly context?: Record<string, unknown>;
    constructor(message: string, context?: Record<string, unknown>);
    /**
     * Get error details as JSON
     */
    toJSON(): Record<string, unknown>;
}
/**
 * Thrown when a resource is already locked
 */
export declare class ResourceLockedError extends RedlockToolkitError {
    readonly resources: string[];
    readonly currentHolder?: string;
    constructor(resources: string[], currentHolder?: string, context?: Record<string, unknown>);
}
/**
 * Thrown when unable to acquire lock due to consensus failure
 */
export declare class ConsensusError extends RedlockToolkitError {
    readonly attempts: Promise<LockStats>[];
    readonly requiredQuorum: number;
    readonly achievedVotes: number;
    constructor(message: string, attempts: Promise<LockStats>[], requiredQuorum: number, achievedVotes: number, context?: Record<string, unknown>);
}
/**
 * Thrown when lock acquisition times out
 */
export declare class LockTimeoutError extends RedlockToolkitError {
    readonly timeoutMs: number;
    readonly attemptsCount: number;
    constructor(timeoutMs: number, attemptsCount: number, context?: Record<string, unknown>);
}
/**
 * Thrown when trying to operate on an expired lock
 */
export declare class LockExpiredError extends RedlockToolkitError {
    readonly expiration: number;
    readonly currentTime: number;
    constructor(expiration: number, context?: Record<string, unknown>);
}
/**
 * Thrown when lock release fails
 */
export declare class LockReleaseError extends RedlockToolkitError {
    readonly resources: string[];
    readonly identifier: string;
    readonly releasedCount: number;
    readonly totalClients: number;
    constructor(resources: string[], identifier: string, releasedCount: number, totalClients: number, context?: Record<string, unknown>);
}
/**
 * Thrown when lock extension fails
 */
export declare class LockExtensionError extends RedlockToolkitError {
    readonly resources: string[];
    readonly identifier: string;
    readonly currentExpiration: number;
    constructor(resources: string[], identifier: string, currentExpiration: number, context?: Record<string, unknown>);
}
/**
 * Thrown when circuit breaker is open
 */
export declare class CircuitBreakerOpenError extends RedlockToolkitError {
    readonly lastFailureTime: number;
    readonly failureCount: number;
    constructor(lastFailureTime: number, failureCount: number, context?: Record<string, unknown>);
}
/**
 * Thrown when Redis operation fails
 */
export declare class RedisOperationError extends RedlockToolkitError {
    readonly operation: string;
    readonly client: string;
    readonly originalError: Error;
    constructor(operation: string, client: string, originalError: Error, context?: Record<string, unknown>);
}
/**
 * Thrown when configuration is invalid
 */
export declare class ConfigurationError extends RedlockToolkitError {
    readonly parameter: string;
    readonly value: unknown;
    constructor(parameter: string, value: unknown, reason: string, context?: Record<string, unknown>);
}
/**
 * Thrown when lock validation fails
 */
export declare class LockValidationError extends RedlockToolkitError {
    readonly validationType: string;
    readonly expected: unknown;
    readonly actual: unknown;
    constructor(validationType: string, expected: unknown, actual: unknown, context?: Record<string, unknown>);
}
/**
 * Thrown when optimistic locking detects a conflict
 */
export declare class OptimisticLockConflictError extends RedlockToolkitError {
    readonly resources: string[];
    readonly expectedVersion: number;
    readonly currentVersion: number;
    readonly conflictType: "version" | "value" | "locked";
    constructor(resources: string[], expectedVersion: number, currentVersion: number, conflictType: "version" | "value" | "locked", context?: Record<string, unknown>);
}
/**
 * Thrown when hybrid locking strategy fails
 */
export declare class HybridLockError extends RedlockToolkitError {
    readonly primaryStrategy: string;
    readonly fallbackStrategy: string;
    readonly primaryError: Error;
    readonly fallbackError?: Error;
    constructor(primaryStrategy: string, fallbackStrategy: string, primaryError: Error, fallbackError?: Error, context?: Record<string, unknown>);
}
/**
 * Thrown when semaphore is at capacity
 */
export declare class SemaphoreFullError extends RedlockToolkitError {
    readonly resource: string;
    readonly activePermits: number;
    readonly maxPermits: number;
    constructor(resource: string, activePermits: number, maxPermits: number, context?: Record<string, unknown>);
}
/**
 * Thrown when permit extension fails
 */
export declare class PermitExtensionError extends RedlockToolkitError {
    readonly resource: string;
    readonly identifier: string;
    constructor(resource: string, identifier: string, context?: Record<string, unknown>);
}
/**
 * Thrown when CountDownLatch doesn't exist or has expired
 */
export declare class LatchNotFoundError extends RedlockToolkitError {
    readonly latchName: string;
    constructor(name: string, context?: Record<string, unknown>);
}
/**
 * Thrown when CountDownLatch already exists
 */
export declare class LatchExistsError extends RedlockToolkitError {
    readonly latchName: string;
    constructor(name: string, context?: Record<string, unknown>);
}
/**
 * Thrown when awaiting CountDownLatch times out
 */
export declare class LatchTimeoutError extends RedlockToolkitError {
    readonly latchName: string;
    readonly remainingCount: number;
    readonly timeoutMs: number;
    constructor(name: string, remainingCount: number, timeoutMs: number, context?: Record<string, unknown>);
}
/**
 * Utility function to determine if an error is retryable
 */
export declare function isRetryableError(error: Error): boolean;
/**
 * Utility function to get retry delay based on error type
 */
export declare function getRetryDelay(error: Error, baseDelay: number, jitter: number): number;
//# sourceMappingURL=errors.d.ts.map