@nestjs-redisx/core 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,4917 @@
+import { Provider, Type, ModuleMetadata, DynamicModule, OnModuleDestroy, Logger, OnModuleInit } from '@nestjs/common';
+import { ModuleRef } from '@nestjs/core';
+import EventEmitter from 'events';
+import Redis, { Cluster } from 'ioredis';
+import { RedisClientType, RedisClusterType, RedisSentinelType } from 'redis';
+
+/**
+ * Context provided to plugins during lifecycle methods.
+ * Gives access to core services and configuration.
+ */
+interface IPluginContext {
+    /**
+     * Client manager for accessing and querying Redis clients.
+     *
+     * @example
+     * ```typescript
+     * if (context.clientManager.hasClient('cache')) {
+     *   const client = await context.clientManager.getClient('cache');
+     * }
+     * ```
+     */
+    readonly clientManager: IClientManager$1;
+    /**
+     * Full module configuration.
+     * Includes global config and plugin-specific config.
+     *
+     * @example
+     * ```typescript
+     * const cacheConfig = context.config.cache;
+     * ```
+     */
+    readonly config: IRedisXConfig;
+    /**
+     * Logger instance scoped to the plugin.
+     * Automatically includes plugin name in logs.
+     *
+     * @example
+     * ```typescript
+     * context.logger.info('Cache initialized', { size: 1000 });
+     * ```
+     */
+    readonly logger: IRedisXLogger;
+    /**
+     * NestJS ModuleRef for advanced DI operations.
+     * Use sparingly, prefer explicit injection.
+     */
+    readonly moduleRef: ModuleRef;
+    /**
+     * Gets another plugin by name.
+     * Returns undefined if plugin not loaded.
+     *
+     * @example
+     * ```typescript
+     * const cachePlugin = context.getPlugin<CachePlugin>('cache');
+     * ```
+     */
+    getPlugin<T extends IRedisXPlugin>(name: string): T | undefined;
+    /**
+     * Checks if a plugin is loaded.
+     */
+    hasPlugin(name: string): boolean;
+}
+/**
+ * Client manager interface for plugin context.
+ * Delegates to the real RedisClientManager.
+ */
+interface IClientManager$1 {
+    /**
+     * Gets Redis client by name.
+     * @param name Client name (defaults to 'default')
+     */
+    getClient(name?: string): Promise<IRedisDriver$1>;
+    /**
+     * Checks if client exists.
+     */
+    hasClient(name: string): boolean;
+    /**
+     * Gets all registered client names.
+     */
+    getClientNames(): string[];
+}
+/**
+ * RedisX configuration interface.
+ */
+interface IRedisXConfig {
+    /**
+     * Redis client configurations.
+     */
+    clients: Record<string, IClientConfig>;
+    /**
+     * Registered plugins.
+     */
+    plugins?: IRedisXPlugin[];
+    /**
+     * Global configuration.
+     */
+    global?: {
+        /** Enable debug logging */
+        debug?: boolean;
+        /** Default TTL for operations */
+        defaultTtl?: number;
+        /** Key prefix for all keys */
+        keyPrefix?: string;
+    };
+}
+/**
+ * Client configuration.
+ */
+interface IClientConfig {
+    host?: string;
+    port?: number;
+    password?: string;
+    db?: number;
+    keyPrefix?: string;
+    connectTimeout?: number;
+    commandTimeout?: number;
+}
+/**
+ * Logger interface.
+ */
+interface IRedisXLogger {
+    debug(message: string, context?: Record<string, unknown>): void;
+    info(message: string, context?: Record<string, unknown>): void;
+    warn(message: string, context?: Record<string, unknown>): void;
+    error(message: string, error?: Error, context?: Record<string, unknown>): void;
+}
+/**
+ * Redis driver interface (re-export for context).
+ */
+interface IRedisDriver$1 {
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    get(key: string): Promise<string | null>;
+    set(key: string, value: string, options?: unknown): Promise<'OK' | null>;
+    del(keys: string | string[]): Promise<number>;
+    eval(script: string, keys: string[], args: (string | number)[]): Promise<unknown>;
+    evalsha(sha: string, keys: string[], args: (string | number)[]): Promise<unknown>;
+    pipeline(): unknown;
+}
+
+/**
+ * Base interface for all RedisX plugins.
+ *
+ * Plugins extend core functionality without modifying core code.
+ * They follow the Open/Closed Principle.
+ *
+ * ## Lifecycle hooks
+ *
+ * `onRegister()`, `onModuleInit()`, `onModuleDestroy()` and `dependencies`
+ * are managed by `PluginRegistryService`. Plugins are initialized in
+ * topological order based on `dependencies`. During shutdown, hooks are
+ * called in reverse dependency order.
+ *
+ * @example
+ * ```typescript
+ * export class CachePlugin implements IRedisXPlugin {
+ *   readonly name = 'cache';
+ *   readonly version = '1.0.0';
+ *
+ *   getProviders() {
+ *     return [CacheService, TagIndexService];
+ *   }
+ * }
+ * ```
+ */
+interface IRedisXPlugin {
+    /**
+     * Unique plugin identifier.
+     * Used for dependency resolution and configuration mapping.
+     * Must be lowercase, alphanumeric with hyphens.
+     *
+     * @example 'cache', 'locks', 'rate-limit'
+     */
+    readonly name: string;
+    /**
+     * Plugin version following semver.
+     * Used for compatibility checks.
+     *
+     * @example '1.0.0', '2.1.3'
+     */
+    readonly version: string;
+    /**
+     * Optional human-readable description.
+     */
+    readonly description?: string;
+    /**
+     * Names of plugins this plugin depends on.
+     * Core ensures dependencies are initialized first.
+     *
+     * @example ['cache'] - depends on cache plugin
+     */
+    readonly dependencies?: string[];
+    /**
+     * Called immediately when plugin is registered.
+     * Use for synchronous setup that doesn't require other plugins.
+     *
+     * @param context - Plugin context with core services
+     */
+    onRegister?(context: IPluginContext): void | Promise<void>;
+    /**
+     * Called after all plugins registered and Redis connected.
+     * Dependencies are guaranteed to be initialized.
+     * Use for async setup like loading Lua scripts.
+     *
+     * @param context - Plugin context with core services
+     */
+    onModuleInit?(context: IPluginContext): void | Promise<void>;
+    /**
+     * Called when application is shutting down.
+     * Use for cleanup (close connections, flush buffers).
+     * Called in reverse dependency order.
+     *
+     * @param context - Plugin context with core services
+     */
+    onModuleDestroy?(context: IPluginContext): void | Promise<void>;
+    /**
+     * Returns NestJS providers this plugin contributes.
+     * These are registered in the DI container.
+     */
+    getProviders?(): Provider[];
+    /**
+     * Returns exports that other modules can inject.
+     * Typically the main service of the plugin.
+     */
+    getExports?(): Array<Provider | string | symbol | Type>;
+    /**
+     * Returns NestJS controllers this plugin contributes.
+     * Controllers handle HTTP endpoints.
+     */
+    getControllers?(): Type[];
+}
+
+/**
+ * Configuration types for NestJS RedisX.
+ * Based on ARCHITECTURE.md - Configuration Schema.
+ */
+
+/**
+ * Base connection options common to all connection types.
+ */
+interface IBaseConnectionConfig {
+    /**
+     * Password for authentication.
+     */
+    password?: string;
+    /**
+     * Database number (0-15).
+     * @default 0
+     */
+    db?: number;
+    /**
+     * Key prefix for all operations.
+     * @example 'myapp:'
+     */
+    keyPrefix?: string;
+    /**
+     * Connection timeout in milliseconds.
+     * @default 10000
+     */
+    connectTimeout?: number;
+    /**
+     * Command timeout in milliseconds.
+     * @default 5000
+     */
+    commandTimeout?: number;
+    /**
+     * Keep-alive interval in milliseconds.
+     * @default 0 (disabled)
+     */
+    keepAlive?: number;
+    /**
+     * Enable offline queue.
+     * @default true
+     */
+    enableOfflineQueue?: boolean;
+    /**
+     * Enable auto-reconnect.
+     * @default true
+     */
+    enableAutoReconnect?: boolean;
+    /**
+     * Maximum retry attempts for commands.
+     * @default 3
+     */
+    maxRetriesPerRequest?: number;
+    /**
+     * Retry strategy function.
+     */
+    retryStrategy?: (times: number) => number | null;
+    /**
+     * Reconnect on error function.
+     */
+    reconnectOnError?: (error: Error) => boolean | 1 | 2;
+}
+/**
+ * Single instance Redis connection configuration.
+ */
+interface ISingleConnectionConfig extends IBaseConnectionConfig {
+    /**
+     * Connection type discriminator.
+     */
+    type?: 'single';
+    /**
+     * Redis host.
+     * @default 'localhost'
+     */
+    host?: string;
+    /**
+     * Redis port.
+     * @default 6379
+     */
+    port?: number;
+    /**
+     * Optional TLS configuration.
+     */
+    tls?: ITlsConfig;
+}
+/**
+ * Redis Cluster connection configuration.
+ */
+interface IClusterConnectionConfig extends IBaseConnectionConfig {
+    /**
+     * Connection type discriminator.
+     */
+    type: 'cluster';
+    /**
+     * Cluster nodes.
+     * @example [{ host: 'localhost', port: 6379 }, { host: 'localhost', port: 6380 }]
+     */
+    nodes: Array<{
+        host: string;
+        port: number;
+    }>;
+    /**
+     * Cluster-specific options.
+     */
+    clusterOptions?: {
+        /**
+         * Maximum number of redirections.
+         * @default 16
+         */
+        maxRedirections?: number;
+        /**
+         * Retry delay for cluster commands.
+         * @default 100
+         */
+        retryDelayOnClusterDown?: number;
+        /**
+         * Retry delay when all slots covered.
+         * @default 100
+         */
+        retryDelayOnFailover?: number;
+        /**
+         * Scale reads to slaves.
+         * @default 'master'
+         */
+        scaleReads?: 'master' | 'slave' | 'all';
+        /**
+         * Enable readonly mode for slave nodes.
+         * @default false
+         */
+        enableReadyCheck?: boolean;
+        /**
+         * NAT mapping for Docker/firewall scenarios.
+         * Maps internal IPs to external accessible addresses.
+         * @example { '172.17.0.2:6379': { host: 'localhost', port: 6379 } }
+         */
+        natMap?: Record<string, {
+            host: string;
+            port: number;
+        }>;
+        /**
+         * Additional ioredis cluster options.
+         * Allows passing any other ioredis ClusterOptions.
+         */
+        [key: string]: unknown;
+    };
+}
+/**
+ * Redis Sentinel connection configuration.
+ */
+interface ISentinelConnectionConfig extends IBaseConnectionConfig {
+    /**
+     * Connection type discriminator.
+     */
+    type: 'sentinel';
+    /**
+     * Sentinel nodes.
+     */
+    sentinels: Array<{
+        host: string;
+        port: number;
+    }>;
+    /**
+     * Master name.
+     */
+    name: string;
+    /**
+     * Optional TLS configuration.
+     */
+    tls?: ITlsConfig;
+    /**
+     * Sentinel-specific options.
+     */
+    sentinelOptions?: {
+        /**
+         * Enable TLS for sentinel connections.
+         */
+        enableTLSForSentinelMode?: boolean;
+        /**
+         * Sentinel password (if different from node password).
+         */
+        sentinelPassword?: string;
+        /**
+         * Retry strategy for sentinel.
+         */
+        sentinelRetryStrategy?: (times: number) => number | null;
+        /**
+         * Prefer slave nodes for reads.
+         * @default false
+         */
+        preferredSlaves?: boolean;
+        /**
+         * NAT mapping for sentinel-managed instances.
+         * Maps internal master/slave addresses to external accessible addresses.
+         * @example { 'redis-master:6379': { host: 'localhost', port: 6379 } }
+         */
+        natMap?: Record<string, {
+            host: string;
+            port: number;
+        }>;
+        /**
+         * Master connection pool size.
+         * Number of connections to maintain to the master node.
+         * @default 1
+         */
+        masterPoolSize?: number;
+        /**
+         * Replica connection pool size per node.
+         * Set to 0 to disable replica connections.
+         * @default 0
+         */
+        replicaPoolSize?: number;
+        /**
+         * Interval in milliseconds to scan for topology changes.
+         * @default 10000
+         */
+        scanInterval?: number;
+        /**
+         * Maximum number of command rediscovers on topology change.
+         * @default 16
+         */
+        maxCommandRediscovers?: number;
+        /**
+         * Additional ioredis/node-redis sentinel options.
+         */
+        [key: string]: unknown;
+    };
+}
+/**
+ * TLS configuration.
+ */
+interface ITlsConfig {
+    /**
+     * Enable TLS.
+     * @default false
+     */
+    enabled?: boolean;
+    /**
+     * CA certificate.
+     */
+    ca?: string | Buffer;
+    /**
+     * Client certificate.
+     */
+    cert?: string | Buffer;
+    /**
+     * Client key.
+     */
+    key?: string | Buffer;
+    /**
+     * Reject unauthorized certificates.
+     * @default true
+     */
+    rejectUnauthorized?: boolean;
+}
+/**
+ * Union type for all connection configurations.
+ */
+type ConnectionConfig = ISingleConnectionConfig | IClusterConnectionConfig | ISentinelConnectionConfig;
+/**
+ * Configuration for a single Redis client.
+ */
+interface IRedisClientOptions {
+    /**
+     * Client name (for named clients).
+     * @default 'default'
+     */
+    name?: string;
+    /**
+     * Connection configuration.
+     */
+    connection: ConnectionConfig;
+    /**
+     * Namespace/prefix for this client.
+     * Overrides connection.keyPrefix.
+     */
+    namespace?: string;
+}
+/**
+ * Driver type for Redis connections.
+ */
+type DriverType = 'ioredis' | 'node-redis';
+/**
+ * Global module configuration options.
+ */
+interface IGlobalConfig {
+    /**
+     * Redis driver to use.
+     * @default 'ioredis'
+     */
+    driver?: DriverType;
+    /**
+     * Enable debug logging.
+     * @default false
+     */
+    debug?: boolean;
+    /**
+     * Default TTL for cache operations (seconds).
+     * @default 3600
+     */
+    defaultTtl?: number;
+    /**
+     * Global key prefix for all clients.
+     */
+    keyPrefix?: string;
+    /**
+     * Enable graceful shutdown.
+     * @default true
+     */
+    gracefulShutdown?: boolean;
+    /**
+     * Graceful shutdown timeout (milliseconds).
+     * @default 5000
+     */
+    gracefulShutdownTimeout?: number;
+    /**
+     * Enable health checks.
+     * @default true
+     */
+    enableHealthChecks?: boolean;
+    /**
+     * Health check interval (milliseconds).
+     * @default 30000
+     */
+    healthCheckInterval?: number;
+}
+/**
+ * Synchronous module configuration.
+ */
+interface IRedisModuleOptions {
+    /**
+     * Redis client configurations.
+     * Can be a single config or a map of named clients.
+     */
+    clients: ConnectionConfig | Record<string, ConnectionConfig>;
+    /**
+     * Registered plugins.
+     */
+    plugins?: IRedisXPlugin[];
+    /**
+     * Global configuration.
+     */
+    global?: IGlobalConfig;
+}
+/**
+ * Factory function for async configuration.
+ */
+interface IRedisModuleOptionsFactory {
+    /**
+     * Creates module options asynchronously.
+     */
+    createRedisModuleOptions(): Promise<IRedisModuleOptions> | IRedisModuleOptions;
+}
+/**
+ * Asynchronous module configuration.
+ */
+interface IRedisModuleAsyncOptions extends Pick<ModuleMetadata, 'imports'> {
+    /**
+     * Registered plugins.
+     * Plugins must be provided outside useFactory to ensure providers are available at module construction time.
+     * This is a standard NestJS pattern (similar to @nestjs/typeorm entities, @nestjs/graphql resolvers).
+     */
+    plugins?: IRedisXPlugin[];
+    /**
+     * Factory function returning options.
+     */
+    useFactory?: (...args: unknown[]) => Promise<IRedisModuleOptions> | IRedisModuleOptions;
+    /**
+     * Dependencies to inject into factory.
+     */
+    inject?: unknown[];
+    /**
+     * Use existing provider.
+     */
+    useExisting?: Type<IRedisModuleOptionsFactory>;
+    /**
+     * Use class provider.
+     */
+    useClass?: Type<IRedisModuleOptionsFactory>;
+}
+/**
+ * Client metadata stored in the registry.
+ */
+interface IClientMetadata {
+    /**
+     * Client name.
+     */
+    name: string;
+    /**
+     * Connection configuration.
+     */
+    config: ConnectionConfig;
+    /**
+     * Connection status.
+     */
+    status: ConnectionStatus;
+    /**
+     * Last connection time.
+     */
+    connectedAt?: Date;
+    /**
+     * Last error.
+     */
+    lastError?: Error;
+    /**
+     * Number of reconnection attempts.
+     */
+    reconnectAttempts: number;
+}
+/**
+ * Connection status.
+ */
+declare enum ConnectionStatus {
+    DISCONNECTED = "disconnected",
+    CONNECTING = "connecting",
+    CONNECTED = "connected",
+    RECONNECTING = "reconnecting",
+    ERROR = "error"
+}
+/**
+ * Health check result.
+ */
+interface IHealthCheckResult {
+    /**
+     * Overall health status.
+     */
+    status: 'healthy' | 'unhealthy' | 'degraded';
+    /**
+     * Individual client statuses.
+     */
+    clients: Record<string, IClientHealthStatus>;
+    /**
+     * Timestamp of check.
+     */
+    timestamp: Date;
+}
+/**
+ * Client health status.
+ */
+interface IClientHealthStatus {
+    /**
+     * Client name.
+     */
+    name: string;
+    /**
+     * Connection status.
+     */
+    status: ConnectionStatus;
+    /**
+     * Latency in milliseconds (ping).
+     */
+    latency?: number;
+    /**
+     * Last error message.
+     */
+    error?: string;
+    /**
+     * Uptime in milliseconds.
+     */
+    uptime?: number;
+}
+/**
+ * Type guard for single connection config.
+ */
+declare function isSingleConnection(config: ConnectionConfig): config is ISingleConnectionConfig;
+/**
+ * Type guard for cluster connection config.
+ */
+declare function isClusterConnection(config: ConnectionConfig): config is IClusterConnectionConfig;
+/**
+ * Type guard for sentinel connection config.
+ */
+declare function isSentinelConnection(config: ConnectionConfig): config is ISentinelConnectionConfig;
+/**
+ * Type guard for async options with factory.
+ */
+declare function hasFactory(options: IRedisModuleAsyncOptions): options is Required<Pick<IRedisModuleAsyncOptions, 'useFactory'>> & IRedisModuleAsyncOptions;
+/**
+ * Type guard for async options with existing provider.
+ */
+declare function hasExisting(options: IRedisModuleAsyncOptions): options is Required<Pick<IRedisModuleAsyncOptions, 'useExisting'>> & IRedisModuleAsyncOptions;
+/**
+ * Type guard for async options with class provider.
+ */
+declare function hasClass(options: IRedisModuleAsyncOptions): options is Required<Pick<IRedisModuleAsyncOptions, 'useClass'>> & IRedisModuleAsyncOptions;
+
+/**
+ * Redis module for NestJS.
+ *
+ * Global module that provides Redis client(s) with driver abstraction,
+ * health monitoring, automatic reconnection, and plugin system.
+ *
+ * Module is always global - no need to import in feature modules.
+ *
+ * @example
+ * **Synchronous configuration:**
+ * ```typescript
+ * @Module({
+ *   imports: [
+ *     RedisModule.forRoot({
+ *       clients: {
+ *         type: 'single',
+ *         host: 'localhost',
+ *         port: 6379,
+ *       },
+ *     }),
+ *   ],
+ * })
+ * export class AppModule {}
+ * ```
+ *
+ * @example
+ * **Asynchronous configuration with factory:**
+ * ```typescript
+ * @Module({
+ *   imports: [
+ *     RedisModule.forRootAsync({
+ *       useFactory: (config: ConfigService) => ({
+ *         clients: {
+ *           type: 'single',
+ *           host: config.get('REDIS_HOST'),
+ *           port: config.get('REDIS_PORT'),
+ *         },
+ *       }),
+ *       inject: [ConfigService],
+ *     }),
+ *   ],
+ * })
+ * export class AppModule {}
+ * ```
+ *
+ * @example
+ * **With plugins:**
+ * ```typescript
+ * @Module({
+ *   imports: [
+ *     RedisModule.forRoot({
+ *       clients: { type: 'single', host: 'localhost', port: 6379 },
+ *       plugins: [new CachePlugin(), new LocksPlugin()],
+ *     }),
+ *   ],
+ * })
+ * export class AppModule {}
+ * ```
+ */
+declare class RedisModule {
+    /**
+     * Configures Redis module synchronously.
+     *
+     * Creates a global module with Redis clients and plugins.
+     * All providers are available for injection everywhere.
+     *
+     * @param options - Redis module options
+     * @returns Dynamic module
+     *
+     * @example
+     * ```typescript
+     * RedisModule.forRoot({
+     *   clients: {
+     *     type: 'single',
+     *     host: 'localhost',
+     *     port: 6379,
+     *   },
+     *   plugins: [new CachePlugin(), new LocksPlugin()],
+     * })
+     * ```
+     */
+    static forRoot(options: IRedisModuleOptions): DynamicModule;
+    /**
+     * Configures Redis module asynchronously.
+     *
+     * Allows configuration to be loaded asynchronously using factory function,
+     * existing provider, or class-based factory. Supports plugins.
+     *
+     * Note: Plugins must be provided in the async options (outside useFactory),
+     * not in the factory result. This is a standard NestJS pattern — plugins
+     * must be available at module construction time for NestJS DI.
+     *
+     * @param options - Async Redis module options
+     * @returns Dynamic module
+     *
+     * @example
+     * **Using factory with plugins:**
+     * ```typescript
+     * RedisModule.forRootAsync({
+     *   plugins: [new CachePlugin(), new LocksPlugin()],
+     *   useFactory: (config: ConfigService) => ({
+     *     clients: {
+     *       type: 'single',
+     *       host: config.get('REDIS_HOST'),
+     *       port: config.get('REDIS_PORT'),
+     *     },
+     *   }),
+     *   inject: [ConfigService],
+     * })
+     * ```
+     *
+     * @example
+     * **Using class:**
+     * ```typescript
+     * @Injectable()
+     * class RedisConfigService implements IRedisModuleOptionsFactory {
+     *   createRedisModuleOptions(): IRedisModuleOptions {
+     *     return {
+     *       clients: { type: 'single', host: 'localhost', port: 6379 },
+     *     };
+     *   }
+     * }
+     *
+     * RedisModule.forRootAsync({
+     *   plugins: [new CachePlugin()],
+     *   useClass: RedisConfigService,
+     * })
+     * ```
+     */
+    static forRootAsync(options: IRedisModuleAsyncOptions): DynamicModule;
+}
+
+/**
+ * Redis driver abstraction interface.
+ *
+ * Complete interface for all Redis operations.
+ * All Redis operations MUST go through this interface.
+ * NEVER import ioredis or redis directly.
+ *
+ * @example
+ * ```typescript
+ * @Injectable()
+ * export class CacheService {
+ *   constructor(
+ *     @Inject(REDIS_DRIVER) private readonly driver: IRedisDriver
+ *   ) {}
+ * }
+ * ```
+ */
+interface IRedisDriver {
+    /**
+     * Connects to Redis.
+     * Called automatically by ClientManager.
+     */
+    connect(): Promise<void>;
+    /**
+     * Disconnects from Redis gracefully.
+     * Called automatically on module destroy.
+     */
+    disconnect(): Promise<void>;
+    /**
+     * Checks if connected to Redis.
+     */
+    isConnected(): boolean;
+    /**
+     * Pings Redis server.
+     * @returns 'PONG' or custom message
+     */
+    ping(message?: string): Promise<string>;
+    /**
+     * Selects database.
+     * @param db - Database number (0-15)
+     */
+    select(db: number): Promise<void>;
+    /**
+     * Gets value of a key.
+     * @returns Value or null if key doesn't exist
+     */
+    get(key: string): Promise<string | null>;
+    /**
+     * Sets value of a key with optional TTL.
+     * @returns 'OK' if successful, null otherwise
+     */
+    set(key: string, value: string, options?: ISetOptions): Promise<'OK' | null>;
+    /**
+     * Gets multiple values.
+     * @returns Array of values (null for non-existent keys)
+     */
+    mget(...keys: string[]): Promise<Array<string | null>>;
+    /**
+     * Sets multiple key-value pairs.
+     * @returns 'OK' if successful
+     */
+    mset(data: Record<string, string>): Promise<'OK'>;
+    /**
+     * Sets value only if key doesn't exist.
+     * @returns 1 if set, 0 if not set
+     */
+    setnx(key: string, value: string): Promise<number>;
+    /**
+     * Sets value with expiration in seconds.
+     * @returns 'OK' if successful
+     */
+    setex(key: string, seconds: number, value: string): Promise<'OK'>;
+    /**
+     * Gets value and deletes key atomically.
+     * @returns Value or null if key doesn't exist
+     */
+    getdel(key: string): Promise<string | null>;
+    /**
+     * Gets value and sets expiration atomically.
+     * @returns Value or null if key doesn't exist
+     */
+    getex(key: string, options: {
+        ex?: number;
+        px?: number;
+    }): Promise<string | null>;
+    /**
+     * Increments integer value by 1.
+     * @returns New value after increment
+     */
+    incr(key: string): Promise<number>;
+    /**
+     * Increments integer value by amount.
+     * @returns New value after increment
+     */
+    incrby(key: string, increment: number): Promise<number>;
+    /**
+     * Decrements integer value by 1.
+     * @returns New value after decrement
+     */
+    decr(key: string): Promise<number>;
+    /**
+     * Decrements integer value by amount.
+     * @returns New value after decrement
+     */
+    decrby(key: string, decrement: number): Promise<number>;
+    /**
+     * Appends value to key.
+     * @returns Length of string after append
+     */
+    append(key: string, value: string): Promise<number>;
+    /**
+     * Gets length of string value.
+     * @returns Length of string, 0 if key doesn't exist
+     */
+    strlen(key: string): Promise<number>;
+    /**
+     * Increments value by float amount.
+     * @returns New value after increment
+     */
+    incrbyfloat(key: string, increment: number): Promise<string>;
+    /**
+     * Gets substring of string value.
+     * @param start - Start offset (can be negative)
+     * @param end - End offset (can be negative)
+     * @returns Substring
+     */
+    getrange(key: string, start: number, end: number): Promise<string>;
+    /**
+     * Overwrites part of string at offset.
+     * @returns Length of string after modification
+     */
+    setrange(key: string, offset: number, value: string): Promise<number>;
+    /**
+     * Sets multiple keys only if none exist.
+     * @returns 1 if all keys set, 0 if no keys set
+     */
+    msetnx(data: Record<string, string>): Promise<number>;
+    /**
+     * Deletes one or more keys.
+     * @returns Number of keys deleted
+     */
+    del(...keys: string[]): Promise<number>;
+    /**
+     * Checks if key exists.
+     * @returns Number of existing keys
+     */
+    exists(...keys: string[]): Promise<number>;
+    /**
+     * Sets TTL on a key (seconds).
+     * @returns 1 if timeout was set, 0 if key doesn't exist
+     */
+    expire(key: string, seconds: number): Promise<number>;
+    /**
+     * Sets TTL on a key (milliseconds).
+     * @returns 1 if timeout was set, 0 if key doesn't exist
+     */
+    pexpire(key: string, milliseconds: number): Promise<number>;
+    /**
+     * Sets absolute expiration time (Unix timestamp in seconds).
+     * @returns 1 if timeout was set, 0 if key doesn't exist
+     */
+    expireat(key: string, timestamp: number): Promise<number>;
+    /**
+     * Gets TTL of a key (seconds).
+     * @returns TTL in seconds, -1 if no TTL, -2 if key doesn't exist
+     */
+    ttl(key: string): Promise<number>;
+    /**
+     * Gets TTL of a key (milliseconds).
+     * @returns TTL in milliseconds, -1 if no TTL, -2 if key doesn't exist
+     */
+    pttl(key: string): Promise<number>;
+    /**
+     * Removes expiration from key.
+     * @returns 1 if expiration removed, 0 if key has no expiration
+     */
+    persist(key: string): Promise<number>;
+    /**
+     * Renames key.
+     * @returns 'OK' if successful
+     * @throws Error if source key doesn't exist
+     */
+    rename(key: string, newKey: string): Promise<'OK'>;
+    /**
+     * Renames key only if new key doesn't exist.
+     * @returns 1 if renamed, 0 if new key exists
+     */
+    renamenx(key: string, newKey: string): Promise<number>;
+    /**
+     * Gets type of value stored at key.
+     * @returns Type name: 'string', 'list', 'set', 'zset', 'hash', 'stream', 'none'
+     */
+    type(key: string): Promise<string>;
+    /**
+     * Scans keys matching pattern.
+     * @returns Cursor and array of keys
+     */
+    scan(cursor: number, options?: IScanOptions): Promise<[string, string[]]>;
+    /**
+     * Deletes keys asynchronously (non-blocking).
+     * Better for large keys than del.
+     * @returns Number of keys unlinked
+     */
+    unlink(...keys: string[]): Promise<number>;
+    /**
+     * Copies key to another key.
+     * @param destination - Destination key
+     * @param options - Copy options (replace, db)
+     * @returns 1 if copied, 0 if not
+     */
+    copy(source: string, destination: string, options?: ICopyOptions): Promise<number>;
+    /**
+     * Finds all keys matching pattern.
+     * WARNING: Use SCAN in production for large keyspaces.
+     * @returns Array of matching keys
+     */
+    keys(pattern: string): Promise<string[]>;
+    /**
+     * Alters the last access time of keys.
+     * @returns Number of keys touched
+     */
+    touch(...keys: string[]): Promise<number>;
+    /**
+     * Returns the internal encoding of a Redis object.
+     * @param subcommand - ENCODING, FREQ, IDLETIME, REFCOUNT
+     * @returns Object info
+     */
+    object(subcommand: 'ENCODING' | 'FREQ' | 'IDLETIME' | 'REFCOUNT', key: string): Promise<string | number | null>;
+    /**
+     * Serializes the value at key.
+     * @returns Serialized value or null
+     */
+    dump(key: string): Promise<string | null>;
+    /**
+     * Deserializes and stores value at key.
+     * @param ttl - TTL in milliseconds (0 = no expiry)
+     * @param serializedValue - Serialized value from dump
+     * @param options - Restore options
+     * @returns 'OK' if successful
+     */
+    restore(key: string, ttl: number, serializedValue: string, options?: IRestoreOptions): Promise<'OK'>;
+    /**
+     * Returns server time.
+     * @returns [unix timestamp in seconds, microseconds]
+     */
+    time(): Promise<[string, string]>;
+    /**
+     * Gets value of hash field.
+     * @returns Value or null if field doesn't exist
+     */
+    hget(key: string, field: string): Promise<string | null>;
+    /**
+     * Sets value of hash field.
+     * @returns 1 if new field, 0 if field updated
+     */
+    hset(key: string, field: string, value: string): Promise<number>;
+    /**
+     * Sets multiple hash fields.
+     * @returns 'OK' if successful
+     */
+    hmset(key: string, data: Record<string, string>): Promise<'OK'>;
+    /**
+     * Gets multiple hash field values.
+     * @returns Array of values (null for non-existent fields)
+     */
+    hmget(key: string, ...fields: string[]): Promise<Array<string | null>>;
+    /**
+     * Gets all fields and values of hash.
+     * @returns Object with field-value pairs
+     */
+    hgetall(key: string): Promise<Record<string, string>>;
+    /**
+     * Deletes hash fields.
+     * @returns Number of fields deleted
+     */
+    hdel(key: string, ...fields: string[]): Promise<number>;
+    /**
+     * Checks if hash field exists.
+     * @returns 1 if field exists, 0 otherwise
+     */
+    hexists(key: string, field: string): Promise<number>;
+    /**
+     * Gets all field names in hash.
+     */
+    hkeys(key: string): Promise<string[]>;
+    /**
+     * Gets all values in hash.
+     */
+    hvals(key: string): Promise<string[]>;
+    /**
+     * Gets number of fields in hash.
+     */
+    hlen(key: string): Promise<number>;
+    /**
+     * Increments hash field by integer.
+     * @returns New value after increment
+     */
+    hincrby(key: string, field: string, increment: number): Promise<number>;
+    /**
+     * Scans hash fields.
+     * @returns Cursor and array of field-value pairs
+     */
+    hscan(key: string, cursor: number, options?: IScanOptions): Promise<[string, string[]]>;
+    /**
+     * Sets hash field only if it doesn't exist.
+     * @returns 1 if field set, 0 if field exists
+     */
+    hsetnx(key: string, field: string, value: string): Promise<number>;
+    /**
+     * Increments hash field by float.
+     * @returns New value as string
+     */
+    hincrbyfloat(key: string, field: string, increment: number): Promise<string>;
+    /**
+     * Gets string length of hash field value.
+     * @returns Length of field value, 0 if field/key doesn't exist
+     */
+    hstrlen(key: string, field: string): Promise<number>;
+    /**
+     * Gets random fields from hash.
+     * @param count - Number of fields (negative for duplicates allowed)
+     * @param withValues - Include values
+     * @returns Random field(s) or field-value pairs
+     */
+    hrandfield(key: string, count?: number, withValues?: boolean): Promise<string | string[] | null>;
+    /**
+     * Pushes values to left of list.
+     * @returns Length of list after push
+     */
+    lpush(key: string, ...values: string[]): Promise<number>;
+    /**
+     * Pushes values to right of list.
+     * @returns Length of list after push
+     */
+    rpush(key: string, ...values: string[]): Promise<number>;
+    /**
+     * Pops value from left of list.
+     * @returns Value or null if list is empty
+     */
+    lpop(key: string): Promise<string | null>;
+    /**
+     * Pops value from right of list.
+     * @returns Value or null if list is empty
+     */
+    rpop(key: string): Promise<string | null>;
+    /**
+     * Gets list length.
+     * @returns Number of elements
+     */
+    llen(key: string): Promise<number>;
+    /**
+     * Gets list range.
+     * @returns Array of values
+     */
+    lrange(key: string, start: number, stop: number): Promise<string[]>;
+    /**
+     * Trims list to specified range.
+     * @returns 'OK' if successful
+     */
+    ltrim(key: string, start: number, stop: number): Promise<'OK'>;
+    /**
+     * Gets element at index.
+     * @returns Value or null if index out of range
+     */
+    lindex(key: string, index: number): Promise<string | null>;
+    /**
+     * Sets element at index.
+     * @returns 'OK' if successful
+     */
+    lset(key: string, index: number, value: string): Promise<'OK'>;
+    /**
+     * Inserts element before or after pivot.
+     * @param position - BEFORE or AFTER
+     * @param pivot - Reference element
+     * @param element - Element to insert
+     * @returns List length, -1 if pivot not found
+     */
+    linsert(key: string, position: 'BEFORE' | 'AFTER', pivot: string, element: string): Promise<number>;
+    /**
+     * Removes elements from list.
+     * @param count - Number to remove (0=all, positive=head, negative=tail)
+     * @param element - Element to remove
+     * @returns Number of removed elements
+     */
+    lrem(key: string, count: number, element: string): Promise<number>;
+    /**
+     * Gets index of element in list.
+     * @param options - RANK, COUNT, MAXLEN options
+     * @returns Index or null if not found
+     */
+    lpos(key: string, element: string, options?: ILposOptions): Promise<number | number[] | null>;
+    /**
+     * Blocking left pop from list.
+     * @param timeout - Timeout in seconds (0 = block forever)
+     * @returns [key, element] or null on timeout
+     */
+    blpop(keys: string[], timeout: number): Promise<[string, string] | null>;
+    /**
+     * Blocking right pop from list.
+     * @param timeout - Timeout in seconds (0 = block forever)
+     * @returns [key, element] or null on timeout
+     */
+    brpop(keys: string[], timeout: number): Promise<[string, string] | null>;
+    /**
+     * Atomically moves element between lists.
+     * @param source - Source list key
+     * @param destination - Destination list key
+     * @param from - LEFT or RIGHT
+     * @param to - LEFT or RIGHT
+     * @returns Moved element or null
+     */
+    lmove(source: string, destination: string, from: 'LEFT' | 'RIGHT', to: 'LEFT' | 'RIGHT'): Promise<string | null>;
+    /**
+     * Blocking version of lmove.
+     * @param timeout - Timeout in seconds
+     * @returns Moved element or null on timeout
+     */
+    blmove(source: string, destination: string, from: 'LEFT' | 'RIGHT', to: 'LEFT' | 'RIGHT', timeout: number): Promise<string | null>;
+    /**
+     * Adds members to set.
+     * @returns Number of members added
+     */
+    sadd(key: string, ...members: string[]): Promise<number>;
+    /**
+     * Removes members from set.
+     * @returns Number of members removed
+     */
+    srem(key: string, ...members: string[]): Promise<number>;
+    /**
+     * Gets all members of set.
+     */
+    smembers(key: string): Promise<string[]>;
+    /**
+     * Checks if member is in set.
+     * @returns 1 if member exists, 0 otherwise
+     */
+    sismember(key: string, member: string): Promise<number>;
+    /**
+     * Gets number of members in set.
+     */
+    scard(key: string): Promise<number>;
+    /**
+     * Gets random member from set.
+     * @returns Random member or null if set is empty
+     */
+    srandmember(key: string, count?: number): Promise<string | string[] | null>;
+    /**
+     * Pops random member from set.
+     * @returns Random member or null if set is empty
+     */
+    spop(key: string, count?: number): Promise<string | string[] | null>;
+    /**
+     * Scans set members.
+     * @returns Cursor and array of members
+     */
+    sscan(key: string, cursor: number, options?: IScanOptions): Promise<[string, string[]]>;
+    /**
+     * Moves member from one set to another.
+     * @returns 1 if moved, 0 if member not in source
+     */
+    smove(source: string, destination: string, member: string): Promise<number>;
+    /**
+     * Returns intersection of sets.
+     * @returns Array of common members
+     */
+    sinter(...keys: string[]): Promise<string[]>;
+    /**
+     * Stores intersection of sets.
+     * @returns Number of members in result
+     */
+    sinterstore(destination: string, ...keys: string[]): Promise<number>;
+    /**
+     * Returns union of sets.
+     * @returns Array of all unique members
+     */
+    sunion(...keys: string[]): Promise<string[]>;
+    /**
+     * Stores union of sets.
+     * @returns Number of members in result
+     */
+    sunionstore(destination: string, ...keys: string[]): Promise<number>;
+    /**
+     * Returns difference of sets (first - others).
+     * @returns Array of members in first set but not in others
+     */
+    sdiff(...keys: string[]): Promise<string[]>;
+    /**
+     * Stores difference of sets.
+     * @returns Number of members in result
+     */
+    sdiffstore(destination: string, ...keys: string[]): Promise<number>;
+    /**
+     * Checks if multiple members are in set.
+     * @returns Array of 1/0 for each member
+     */
+    smismember(key: string, ...members: string[]): Promise<number[]>;
+    /**
+     * Adds members to sorted set with scores.
+     * @returns Number of members added
+     */
+    zadd(key: string, ...args: Array<number | string>): Promise<number>;
+    /**
+     * Removes members from sorted set.
+     * @returns Number of members removed
+     */
+    zrem(key: string, ...members: string[]): Promise<number>;
+    /**
+     * Gets members in range by index.
+     */
+    zrange(key: string, start: number, stop: number, withScores?: boolean): Promise<string[]>;
+    /**
+     * Gets members in range by score.
+     */
+    zrangebyscore(key: string, min: number | string, max: number | string, withScores?: boolean): Promise<string[]>;
+    /**
+     * Gets score of member.
+     * @returns Score or null if member doesn't exist
+     */
+    zscore(key: string, member: string): Promise<string | null>;
+    /**
+     * Gets number of members in sorted set.
+     */
+    zcard(key: string): Promise<number>;
+    /**
+     * Gets rank of member (0-based, lowest score first).
+     * @returns Rank or null if member doesn't exist
+     */
+    zrank(key: string, member: string): Promise<number | null>;
+    /**
+     * Increments score of member.
+     * @returns New score
+     */
+    zincrby(key: string, increment: number, member: string): Promise<string>;
+    /**
+     * Scans sorted set members.
+     * @returns Cursor and array of member-score pairs
+     */
+    zscan(key: string, cursor: number, options?: IScanOptions): Promise<[string, string[]]>;
+    /**
+     * Gets reverse rank of member (highest score first).
+     * @returns Rank or null if member doesn't exist
+     */
+    zrevrank(key: string, member: string): Promise<number | null>;
+    /**
+     * Counts members with scores in range.
+     * @returns Number of members
+     */
+    zcount(key: string, min: number | string, max: number | string): Promise<number>;
+    /**
+     * Counts members in lexicographical range.
+     * @returns Number of members
+     */
+    zlexcount(key: string, min: string, max: string): Promise<number>;
+    /**
+     * Removes and returns members with lowest scores.
+     * @returns Array of [member, score] pairs
+     */
+    zpopmin(key: string, count?: number): Promise<string[]>;
+    /**
+     * Removes and returns members with highest scores.
+     * @returns Array of [member, score] pairs
+     */
+    zpopmax(key: string, count?: number): Promise<string[]>;
+    /**
+     * Blocking pop from sorted set (lowest score).
+     * @param timeout - Timeout in seconds
+     * @returns [key, member, score] or null on timeout
+     */
+    bzpopmin(keys: string[], timeout: number): Promise<[string, string, string] | null>;
+    /**
+     * Blocking pop from sorted set (highest score).
+     * @param timeout - Timeout in seconds
+     * @returns [key, member, score] or null on timeout
+     */
+    bzpopmax(keys: string[], timeout: number): Promise<[string, string, string] | null>;
+    /**
+     * Computes union of sorted sets and stores result.
+     * @param destination - Destination key
+     * @param keys - Source keys
+     * @param options - WEIGHTS and AGGREGATE options
+     * @returns Number of elements in result
+     */
+    zunionstore(destination: string, keys: string[], options?: IZStoreOptions): Promise<number>;
+    /**
+     * Computes intersection of sorted sets and stores result.
+     * @param destination - Destination key
+     * @param keys - Source keys
+     * @param options - WEIGHTS and AGGREGATE options
+     * @returns Number of elements in result
+     */
+    zinterstore(destination: string, keys: string[], options?: IZStoreOptions): Promise<number>;
+    /**
+     * Gets scores of multiple members.
+     * @returns Array of scores (null for non-existent members)
+     */
+    zmscore(key: string, ...members: string[]): Promise<Array<string | null>>;
+    /**
+     * Gets random members from sorted set.
+     * @param count - Number of members (negative for duplicates allowed)
+     * @param withScores - Include scores
+     * @returns Random member(s) or member-score pairs
+     */
+    zrandmember(key: string, count?: number, withScores?: boolean): Promise<string | string[] | null>;
+    /**
+     * Gets members in score range in reverse order.
+     * @returns Array of members (with scores if withScores)
+     */
+    zrevrangebyscore(key: string, max: number | string, min: number | string, options?: IZRangeByScoreOptions): Promise<string[]>;
+    /**
+     * Publishes message to channel.
+     * @returns Number of subscribers that received the message
+     */
+    publish(channel: string, message: string): Promise<number>;
+    /**
+     * Subscribes to channels.
+     */
+    subscribe(...channels: string[]): Promise<void>;
+    /**
+     * Unsubscribes from channels.
+     */
+    unsubscribe(...channels: string[]): Promise<void>;
+    /**
+     * Subscribes to channels by pattern.
+     */
+    psubscribe(...patterns: string[]): Promise<void>;
+    /**
+     * Unsubscribes from channel patterns.
+     */
+    punsubscribe(...patterns: string[]): Promise<void>;
+    /**
+     * Adds entry to stream.
+     * @param key - Stream key
+     * @param id - Entry ID ('*' for auto-generated)
+     * @param fields - Field-value pairs
+     * @param options - Optional MAXLEN/MINID trimming
+     * @returns Entry ID
+     */
+    xadd(key: string, id: string, fields: Record<string, string>, options?: IStreamAddOptions): Promise<string>;
+    /**
+     * Reads entries from streams.
+     * @param streams - Stream keys and IDs to read from
+     * @param options - Read options (COUNT, BLOCK)
+     * @returns Array of stream entries or null
+     */
+    xread(streams: Array<{
+        key: string;
+        id: string;
+    }>, options?: IStreamReadOptions): Promise<StreamReadResult | null>;
+    /**
+     * Reads entries from streams using consumer group.
+     * @param group - Consumer group name
+     * @param consumer - Consumer name
+     * @param streams - Stream keys and IDs to read from
+     * @param options - Read options (COUNT, BLOCK, NOACK)
+     * @returns Array of stream entries or null
+     */
+    xreadgroup(group: string, consumer: string, streams: Array<{
+        key: string;
+        id: string;
+    }>, options?: IStreamReadGroupOptions): Promise<StreamReadResult | null>;
+    /**
+     * Gets range of entries from stream.
+     * @param key - Stream key
+     * @param start - Start ID ('-' for oldest)
+     * @param end - End ID ('+' for newest)
+     * @param options - Optional COUNT
+     * @returns Array of entries
+     */
+    xrange(key: string, start: string, end: string, options?: {
+        count?: number;
+    }): Promise<IStreamEntry[]>;
+    /**
+     * Gets range of entries in reverse order.
+     * @param key - Stream key
+     * @param end - End ID ('+' for newest)
+     * @param start - Start ID ('-' for oldest)
+     * @param options - Optional COUNT
+     * @returns Array of entries
+     */
+    xrevrange(key: string, end: string, start: string, options?: {
+        count?: number;
+    }): Promise<IStreamEntry[]>;
+    /**
+     * Gets stream length.
+     * @param key - Stream key
+     * @returns Number of entries
+     */
+    xlen(key: string): Promise<number>;
+    /**
+     * Gets stream information.
+     * @param key - Stream key
+     * @returns Stream info object
+     */
+    xinfo(key: string): Promise<IStreamInfo>;
+    /**
+     * Trims stream to specified length.
+     * @param key - Stream key
+     * @param maxLen - Maximum length
+     * @param approximate - Use '~' for approximate trimming (better performance)
+     * @returns Number of entries removed
+     */
+    xtrim(key: string, maxLen: number, approximate?: boolean): Promise<number>;
+    /**
+     * Creates consumer group.
+     * @param key - Stream key
+     * @param group - Group name
+     * @param id - Start ID ('$' for new entries only, '0' for all)
+     * @param mkstream - Create stream if doesn't exist
+     * @returns 'OK' if successful
+     */
+    xgroupCreate(key: string, group: string, id: string, mkstream?: boolean): Promise<'OK'>;
+    /**
+     * Destroys consumer group.
+     * @param key - Stream key
+     * @param group - Group name
+     * @returns 1 if destroyed, 0 if didn't exist
+     */
+    xgroupDestroy(key: string, group: string): Promise<number>;
+    /**
+     * Deletes consumer from group.
+     * @param key - Stream key
+     * @param group - Group name
+     * @param consumer - Consumer name
+     * @returns Number of pending messages removed
+     */
+    xgroupDelConsumer(key: string, group: string, consumer: string): Promise<number>;
+    /**
+     * Sets consumer group last delivered ID.
+     * @param key - Stream key
+     * @param group - Group name
+     * @param id - New last ID
+     * @returns 'OK' if successful
+     */
+    xgroupSetId(key: string, group: string, id: string): Promise<'OK'>;
+    /**
+     * Acknowledges message processing.
+     * @param key - Stream key
+     * @param group - Group name
+     * @param ids - Message IDs to acknowledge
+     * @returns Number of messages acknowledged
+     */
+    xack(key: string, group: string, ...ids: string[]): Promise<number>;
+    /**
+     * Gets pending messages info.
+     * @param key - Stream key
+     * @param group - Group name
+     * @returns Pending info summary
+     */
+    xpending(key: string, group: string): Promise<IStreamPendingInfo>;
+    /**
+     * Gets detailed pending messages.
+     * @param key - Stream key
+     * @param group - Group name
+     * @param start - Start ID
+     * @param end - End ID
+     * @param count - Max entries to return
+     * @param consumer - Optional consumer filter
+     * @returns Array of pending entries
+     */
+    xpendingRange(key: string, group: string, start: string, end: string, count: number, consumer?: string): Promise<IStreamPendingEntry[]>;
+    /**
+     * Claims messages from another consumer.
+     * @param key - Stream key
+     * @param group - Group name
+     * @param consumer - New consumer
+     * @param minIdleTime - Minimum idle time in ms
+     * @param ids - Message IDs to claim
+     * @returns Claimed entries
+     */
+    xclaim(key: string, group: string, consumer: string, minIdleTime: number, ...ids: string[]): Promise<IStreamEntry[]>;
+    /**
+     * Deletes entries from stream.
+     * @param key - Stream key
+     * @param ids - Entry IDs to delete
+     * @returns Number of entries deleted
+     */
+    xdel(key: string, ...ids: string[]): Promise<number>;
+    /**
+     * Creates a pipeline for batching commands.
+     * Commands are executed atomically but not transactionally.
+     */
+    pipeline(): IPipeline;
+    /**
+     * Creates a multi/exec transaction.
+     * Commands are executed atomically and transactionally.
+     */
+    multi(): IMulti;
+    /**
+     * Evaluates Lua script.
+     * @param script - Lua script source
+     * @param keys - KEYS array
+     * @param args - ARGV array
+     * @returns Script result
+     */
+    eval(script: string, keys: string[], args: Array<string | number>): Promise<unknown>;
+    /**
+     * Evaluates Lua script by SHA.
+     * @param sha - Script SHA hash
+     * @param keys - KEYS array
+     * @param args - ARGV array
+     * @returns Script result
+     */
+    evalsha(sha: string, keys: string[], args: Array<string | number>): Promise<unknown>;
+    /**
+     * Loads Lua script and returns SHA.
+     * @param script - Lua script source
+     * @returns SHA hash
+     */
+    scriptLoad(script: string): Promise<string>;
+    /**
+     * Checks if scripts exist.
+     * @param shas - Script SHA hashes
+     * @returns Array of 1/0 for each script
+     */
+    scriptExists(...shas: string[]): Promise<number[]>;
+    /**
+     * Flushes all scripts from cache.
+     * @returns 'OK' if successful
+     */
+    scriptFlush(): Promise<'OK'>;
+    /**
+     * Flushes all keys from current database.
+     * @returns 'OK' if successful
+     */
+    flushdb(): Promise<'OK'>;
+    /**
+     * Flushes all keys from all databases.
+     * @returns 'OK' if successful
+     */
+    flushall(): Promise<'OK'>;
+    /**
+     * Gets server info.
+     * @param section - Optional info section
+     * @returns Info string
+     */
+    info(section?: string): Promise<string>;
+    /**
+     * Gets database size (number of keys).
+     * @returns Number of keys
+     */
+    dbsize(): Promise<number>;
+    /**
+     * Adds elements to HyperLogLog.
+     * @returns 1 if cardinality changed, 0 otherwise
+     */
+    pfadd(key: string, ...elements: string[]): Promise<number>;
+    /**
+     * Returns estimated cardinality.
+     * @returns Estimated number of unique elements
+     */
+    pfcount(...keys: string[]): Promise<number>;
+    /**
+     * Merges HyperLogLogs into destination.
+     * @returns 'OK' if successful
+     */
+    pfmerge(destination: string, ...sources: string[]): Promise<'OK'>;
+    /**
+     * Adds geospatial members.
+     * @param members - Array of [longitude, latitude, member]
+     * @returns Number of members added
+     */
+    geoadd(key: string, ...members: Array<number | string>): Promise<number>;
+    /**
+     * Returns distance between two members.
+     * @param unit - m, km, mi, ft
+     * @returns Distance or null if member doesn't exist
+     */
+    geodist(key: string, member1: string, member2: string, unit?: GeoUnit): Promise<string | null>;
+    /**
+     * Returns geohash strings for members.
+     * @returns Array of geohash strings (null for non-existent)
+     */
+    geohash(key: string, ...members: string[]): Promise<Array<string | null>>;
+    /**
+     * Returns positions of members.
+     * @returns Array of [longitude, latitude] or null
+     */
+    geopos(key: string, ...members: string[]): Promise<Array<[string, string] | null>>;
+    /**
+     * Searches for members in radius.
+     * @returns Array of members with optional distance/coordinates
+     */
+    geosearch(key: string, options: IGeoSearchOptions): Promise<Array<string | IGeoSearchResult>>;
+    /**
+     * Searches and stores result.
+     * @returns Number of members in result
+     */
+    geosearchstore(destination: string, source: string, options: IGeoSearchOptions & {
+        storedist?: boolean;
+    }): Promise<number>;
+    /**
+     * Sets bit at offset.
+     * @returns Previous bit value
+     */
+    setbit(key: string, offset: number, value: 0 | 1): Promise<number>;
+    /**
+     * Gets bit at offset.
+     * @returns Bit value (0 or 1)
+     */
+    getbit(key: string, offset: number): Promise<number>;
+    /**
+     * Counts set bits in range.
+     * @param start - Start byte offset
+     * @param end - End byte offset
+     * @param mode - BYTE or BIT
+     * @returns Number of set bits
+     */
+    bitcount(key: string, start?: number, end?: number, mode?: 'BYTE' | 'BIT'): Promise<number>;
+    /**
+     * Performs bitwise operations.
+     * @param operation - AND, OR, XOR, NOT
+     * @param destKey - Destination key
+     * @param keys - Source keys (one for NOT)
+     * @returns Size of result in bytes
+     */
+    bitop(operation: 'AND' | 'OR' | 'XOR' | 'NOT', destKey: string, ...keys: string[]): Promise<number>;
+    /**
+     * Finds first bit set to value.
+     * @param bit - 0 or 1
+     * @param start - Start byte offset
+     * @param end - End byte offset
+     * @param mode - BYTE or BIT
+     * @returns Position of first bit, -1 if not found
+     */
+    bitpos(key: string, bit: 0 | 1, start?: number, end?: number, mode?: 'BYTE' | 'BIT'): Promise<number>;
+    /**
+     * Executes Redis Cluster commands.
+     * @param subcommand - Cluster subcommand (INFO, NODES, etc.)
+     * @param args - Additional arguments
+     * @returns Command result
+     */
+    cluster(subcommand: string, ...args: Array<string | number>): Promise<unknown>;
+    /**
+     * Executes Redis Sentinel commands.
+     * @param subcommand - Sentinel subcommand (masters, master, replicas, etc.)
+     * @param args - Additional arguments
+     * @returns Command result
+     */
+    sentinel(subcommand: string, ...args: Array<string | number>): Promise<unknown>;
+    /**
+     * Registers event handler.
+     */
+    on(event: DriverEvent, handler: DriverEventHandler): void;
+    /**
+     * Registers one-time event handler.
+     */
+    once(event: DriverEvent, handler: DriverEventHandler): void;
+    /**
+     * Unregisters event handler.
+     */
+    off(event: DriverEvent, handler: DriverEventHandler): void;
+    /**
+     * Removes all listeners for event.
+     */
+    removeAllListeners(event?: DriverEvent): void;
+}
+/**
+ * Options for SET command.
+ */
+interface ISetOptions {
+    /**
+     * Expiration in seconds (EX).
+     */
+    ex?: number;
+    /**
+     * Expiration in milliseconds (PX).
+     */
+    px?: number;
+    /**
+     * Expiration Unix timestamp in seconds (EXAT).
+     */
+    exat?: number;
+    /**
+     * Expiration Unix timestamp in milliseconds (PXAT).
+     */
+    pxat?: number;
+    /**
+     * Only set if key exists (XX).
+     */
+    xx?: boolean;
+    /**
+     * Only set if key doesn't exist (NX).
+     */
+    nx?: boolean;
+    /**
+     * Return previous value (GET).
+     */
+    get?: boolean;
+    /**
+     * Keep existing TTL (KEEPTTL).
+     */
+    keepttl?: boolean;
+}
+/**
+ * Options for SCAN family commands.
+ */
+interface IScanOptions {
+    /**
+     * Match pattern.
+     */
+    match?: string;
+    /**
+     * Count hint (not exact).
+     */
+    count?: number;
+    /**
+     * Type filter (for SCAN only).
+     */
+    type?: string;
+}
+/**
+ * Pipeline for batching Redis commands.
+ * Commands are buffered and sent to server in a single round-trip.
+ */
+interface IPipeline {
+    /**
+     * Executes all queued commands.
+     * @returns Array of [error, result] tuples for each command
+     */
+    exec(): Promise<Array<[Error | null, unknown]>>;
+    get(key: string): this;
+    set(key: string, value: string, options?: ISetOptions): this;
+    del(...keys: string[]): this;
+    mget(...keys: string[]): this;
+    mset(data: Record<string, string>): this;
+    expire(key: string, seconds: number): this;
+    ttl(key: string): this;
+    incr(key: string): this;
+    incrby(key: string, increment: number): this;
+    hget(key: string, field: string): this;
+    hset(key: string, field: string, value: string): this;
+    hmset(key: string, data: Record<string, string>): this;
+    hgetall(key: string): this;
+    lpush(key: string, ...values: string[]): this;
+    rpush(key: string, ...values: string[]): this;
+    sadd(key: string, ...members: string[]): this;
+    srem(key: string, ...members: string[]): this;
+    zadd(key: string, ...args: Array<number | string>): this;
+    zrem(key: string, ...members: string[]): this;
+}
+/**
+ * Multi/Exec transaction.
+ * Commands are executed atomically and transactionally.
+ */
+interface IMulti extends IPipeline {
+    /**
+     * Discards transaction.
+     */
+    discard(): void;
+}
+/**
+ * Options for XADD command.
+ */
+interface IStreamAddOptions {
+    /**
+     * Maximum stream length (MAXLEN).
+     */
+    maxLen?: number;
+    /**
+     * Use approximate trimming (~) for better performance.
+     */
+    approximate?: boolean;
+    /**
+     * Only add if stream exists (NOMKSTREAM).
+     */
+    noMkStream?: boolean;
+    /**
+     * Minimum ID for trimming (MINID).
+     */
+    minId?: string;
+}
+/**
+ * Options for XREAD command.
+ */
+interface IStreamReadOptions {
+    /**
+     * Maximum entries per stream.
+     */
+    count?: number;
+    /**
+     * Block timeout in milliseconds (0 = forever).
+     */
+    block?: number;
+}
+/**
+ * Options for XREADGROUP command.
+ */
+interface IStreamReadGroupOptions extends IStreamReadOptions {
+    /**
+     * Don't add to pending list.
+     */
+    noAck?: boolean;
+}
+/**
+ * Single stream entry.
+ */
+interface IStreamEntry {
+    /**
+     * Entry ID (timestamp-sequence).
+     */
+    id: string;
+    /**
+     * Entry fields.
+     */
+    fields: Record<string, string>;
+}
+/**
+ * Result from XREAD/XREADGROUP.
+ */
+type StreamReadResult = Array<{
+    /**
+     * Stream key.
+     */
+    key: string;
+    /**
+     * Entries read from stream.
+     */
+    entries: IStreamEntry[];
+}>;
+/**
+ * Stream information from XINFO.
+ */
+interface IStreamInfo {
+    /**
+     * Number of entries.
+     */
+    length: number;
+    /**
+     * Number of consumer groups.
+     */
+    groups: number;
+    /**
+     * First entry ID.
+     */
+    firstEntry: IStreamEntry | null;
+    /**
+     * Last entry ID.
+     */
+    lastEntry: IStreamEntry | null;
+    /**
+     * Last generated ID.
+     */
+    lastGeneratedId: string;
+    /**
+     * Radix tree keys.
+     */
+    radixTreeKeys: number;
+    /**
+     * Radix tree nodes.
+     */
+    radixTreeNodes: number;
+}
+/**
+ * Pending messages summary from XPENDING.
+ */
+interface IStreamPendingInfo {
+    /**
+     * Total pending count.
+     */
+    count: number;
+    /**
+     * Smallest pending ID.
+     */
+    minId: string | null;
+    /**
+     * Largest pending ID.
+     */
+    maxId: string | null;
+    /**
+     * Pending count per consumer.
+     */
+    consumers: Array<{
+        name: string;
+        count: number;
+    }>;
+}
+/**
+ * Single pending entry from XPENDING with range.
+ */
+interface IStreamPendingEntry {
+    /**
+     * Entry ID.
+     */
+    id: string;
+    /**
+     * Consumer name.
+     */
+    consumer: string;
+    /**
+     * Idle time in milliseconds.
+     */
+    idleTime: number;
+    /**
+     * Delivery count.
+     */
+    deliveryCount: number;
+}
+/**
+ * Driver events.
+ */
+declare enum DriverEvent {
+    CONNECT = "connect",
+    READY = "ready",
+    DISCONNECT = "disconnect",
+    CLOSE = "close",
+    ERROR = "error",
+    RECONNECTING = "reconnecting",
+    END = "end"
+}
+/**
+ * Driver event handler.
+ */
+type DriverEventHandler = (data?: unknown) => void;
+/**
+ * Options for COPY command.
+ */
+interface ICopyOptions {
+    /**
+     * Target database number.
+     */
+    db?: number;
+    /**
+     * Replace existing key.
+     */
+    replace?: boolean;
+}
+/**
+ * Options for RESTORE command.
+ */
+interface IRestoreOptions {
+    /**
+     * Replace existing key.
+     */
+    replace?: boolean;
+    /**
+     * Absolute Unix timestamp (milliseconds) for expiration.
+     */
+    absttl?: boolean;
+    /**
+     * Eviction time in seconds.
+     */
+    idletime?: number;
+    /**
+     * Eviction frequency.
+     */
+    freq?: number;
+}
+/**
+ * Options for LPOS command.
+ */
+interface ILposOptions {
+    /**
+     * Search from Nth match.
+     */
+    rank?: number;
+    /**
+     * Return count matches.
+     */
+    count?: number;
+    /**
+     * Limit comparisons.
+     */
+    maxlen?: number;
+}
+/**
+ * Options for ZRANGEBYSCORE command.
+ */
+interface IZRangeByScoreOptions {
+    /**
+     * Include scores in result.
+     */
+    withScores?: boolean;
+    /**
+     * Limit results.
+     */
+    limit?: {
+        offset: number;
+        count: number;
+    };
+}
+/**
+ * Options for ZUNIONSTORE/ZINTERSTORE commands.
+ */
+interface IZStoreOptions {
+    /**
+     * Weight for each input key.
+     */
+    weights?: number[];
+    /**
+     * How to aggregate scores.
+     */
+    aggregate?: 'SUM' | 'MIN' | 'MAX';
+}
+/**
+ * Geo distance unit.
+ */
+type GeoUnit = 'm' | 'km' | 'mi' | 'ft';
+/**
+ * Options for GEOSEARCH command.
+ */
+interface IGeoSearchOptions {
+    /**
+     * Search from member.
+     */
+    member?: string;
+    /**
+     * Search from coordinates.
+     */
+    coord?: {
+        longitude: number;
+        latitude: number;
+    };
+    /**
+     * Search by radius.
+     */
+    radius?: {
+        value: number;
+        unit: GeoUnit;
+    };
+    /**
+     * Search by box.
+     */
+    box?: {
+        width: number;
+        height: number;
+        unit: GeoUnit;
+    };
+    /**
+     * Sort order.
+     */
+    sort?: 'ASC' | 'DESC';
+    /**
+     * Limit results.
+     */
+    count?: number;
+    /**
+     * Use ANY with count.
+     */
+    any?: boolean;
+    /**
+     * Include coordinates.
+     */
+    withCoord?: boolean;
+    /**
+     * Include distance.
+     */
+    withDist?: boolean;
+    /**
+     * Include hash.
+     */
+    withHash?: boolean;
+}
+/**
+ * Geo search result with optional data.
+ */
+interface IGeoSearchResult {
+    member: string;
+    distance?: string;
+    hash?: number;
+    coordinates?: [string, string];
+}
+
+/**
+ * Redis client interface.
+ *
+ * Wraps IRedisDriver with additional client-level functionality.
+ * Manages connection lifecycle, health checks, and metadata.
+ *
+ * @example
+ * ```typescript
+ * @Injectable()
+ * export class MyService {
+ *   constructor(
+ *     @Inject(REDIS_CLIENT) private readonly client: IRedisClient
+ *   ) {}
+ *
+ *   async getData() {
+ *     if (this.client.isHealthy()) {
+ *       return await this.client.get('key');
+ *     }
+ *   }
+ * }
+ * ```
+ */
+interface IRedisClient extends IRedisDriver {
+    /**
+     * Gets client name.
+     */
+    readonly name: string;
+    /**
+     * Gets connection configuration.
+     */
+    readonly config: ConnectionConfig;
+    /**
+     * Gets client metadata.
+     */
+    getMetadata(): IClientMetadata;
+    /**
+     * Checks if client is healthy (connected and responsive).
+     */
+    isHealthy(): boolean;
+    /**
+     * Gets connection uptime in milliseconds.
+     * @returns Uptime or null if not connected
+     */
+    getUptime(): number | null;
+    /**
+     * Measures latency by pinging server.
+     * @returns Latency in milliseconds or null if disconnected
+     */
+    getLatency(): Promise<number | null>;
+    /**
+     * Gets last error if any.
+     */
+    getLastError(): Error | null;
+    /**
+     * Clears last error.
+     */
+    clearLastError(): void;
+    /**
+     * Reconnects to Redis.
+     * Disconnects if connected, then connects again.
+     */
+    reconnect(): Promise<void>;
+    /**
+     * Quits gracefully.
+     * Waits for pending commands to complete before disconnecting.
+     */
+    quit(): Promise<void>;
+    /**
+     * Creates a namespaced client.
+     * All keys will be prefixed with namespace.
+     *
+     * @example
+     * ```typescript
+     * const userClient = client.namespace('user');
+     * await userClient.set('123', data); // Actually sets 'user:123'
+     * ```
+     */
+    namespace(prefix: string): IRedisClient;
+    /**
+     * Gets current namespace prefix.
+     */
+    getNamespace(): string | null;
+}
+/**
+ * Client manager interface.
+ * Manages multiple named Redis clients.
+ */
+interface IClientManager {
+    /**
+     * Gets client by name.
+     * @throws Error if client not found
+     */
+    getClient(name?: string): IRedisClient;
+    /**
+     * Checks if client exists.
+     */
+    hasClient(name: string): boolean;
+    /**
+     * Gets all client names.
+     */
+    getClientNames(): string[];
+    /**
+     * Registers a new client.
+     * @throws Error if client with same name already exists
+     */
+    registerClient(name: string, client: IRedisClient): Promise<void>;
+    /**
+     * Removes and disconnects client.
+     */
+    removeClient(name: string): Promise<void>;
+    /**
+     * Gets all clients.
+     */
+    getAllClients(): Map<string, IRedisClient>;
+    /**
+     * Checks health of all clients.
+     */
+    checkHealth(): Promise<Map<string, boolean>>;
+    /**
+     * Disconnects all clients.
+     */
+    disconnectAll(): Promise<void>;
+}
+
+/**
+ * Health check status for Redis client.
+ */
+interface IHealthStatus {
+    /**
+     * Client name.
+     */
+    name: string;
+    /**
+     * Whether client is healthy (connected and responsive).
+     */
+    healthy: boolean;
+    /**
+     * Current connection status.
+     */
+    status: ConnectionStatus;
+    /**
+     * Latency in milliseconds (from PING command).
+     * null if not connected or ping failed.
+     */
+    latency: number | null;
+    /**
+     * Last error if any.
+     */
+    lastError: string | null;
+    /**
+     * Timestamp of last successful check.
+     */
+    lastCheckAt: Date;
+    /**
+     * Additional metadata.
+     */
+    metadata: {
+        /**
+         * Driver type (ioredis or node-redis).
+         */
+        driverType: string;
+        /**
+         * Connection type (single, cluster, sentinel).
+         */
+        connectionType: string;
+        /**
+         * Number of reconnection attempts.
+         */
+        reconnectAttempts: number;
+        /**
+         * Uptime in milliseconds.
+         */
+        uptime: number;
+    };
+}
+/**
+ * Connection statistics for all clients.
+ */
+interface IConnectionStats {
+    /**
+     * Total number of registered clients.
+     */
+    totalClients: number;
+    /**
+     * Number of connected clients.
+     */
+    connectedClients: number;
+    /**
+     * Number of disconnected clients.
+     */
+    disconnectedClients: number;
+    /**
+     * Number of clients with errors.
+     */
+    errorClients: number;
+    /**
+     * Per-client statistics.
+     */
+    clients: Record<string, IClientStats>;
+    /**
+     * Timestamp when stats were collected.
+     */
+    collectedAt: Date;
+}
+/**
+ * Statistics for individual client.
+ */
+interface IClientStats {
+    /**
+     * Client name.
+     */
+    name: string;
+    /**
+     * Current status.
+     */
+    status: ConnectionStatus;
+    /**
+     * Total commands executed.
+     */
+    commandsExecuted: number;
+    /**
+     * Total errors.
+     */
+    errors: number;
+    /**
+     * Total reconnections.
+     */
+    reconnections: number;
+    /**
+     * Average latency in milliseconds.
+     */
+    averageLatency: number;
+    /**
+     * Peak latency in milliseconds.
+     */
+    peakLatency: number;
+    /**
+     * Last activity timestamp.
+     */
+    lastActivityAt: Date | null;
+    /**
+     * Connected since timestamp.
+     */
+    connectedAt: Date | null;
+    /**
+     * Total uptime in milliseconds.
+     */
+    uptime: number;
+}
+/**
+ * Reconnection options.
+ */
+interface IReconnectionOptions {
+    /**
+     * Maximum number of reconnection attempts.
+     * @default Infinity
+     */
+    maxAttempts?: number;
+    /**
+     * Initial delay in milliseconds.
+     * @default 1000
+     */
+    initialDelay?: number;
+    /**
+     * Maximum delay in milliseconds.
+     * @default 30000
+     */
+    maxDelay?: number;
+    /**
+     * Exponential backoff multiplier.
+     * @default 2
+     */
+    backoffMultiplier?: number;
+    /**
+     * Enable jitter to prevent thundering herd.
+     * @default true
+     */
+    enableJitter?: boolean;
+}
+
+/**
+ * Redis driver manager interface.
+ *
+ * Manages multiple Redis driver connections with:
+ * - Lazy connection (connect on first use)
+ * - Automatic reconnection with exponential backoff
+ * - Health monitoring
+ * - Graceful shutdown
+ * - Connection pooling
+ *
+ * @example
+ * ```typescript
+ * @Injectable()
+ * export class CacheService {
+ *   constructor(
+ *     @Inject(CLIENT_MANAGER) private readonly clientManager: IRedisDriverManager
+ *   ) {}
+ *
+ *   async get(key: string): Promise<string | null> {
+ *     const driver = await this.clientManager.getClient('cache');
+ *     return driver.get(key);
+ *   }
+ * }
+ * ```
+ */
+interface IRedisDriverManager {
+    /**
+     * Gets Redis driver by name.
+     *
+     * Performs lazy connection on first access.
+     * Subsequent calls return the same connected driver.
+     *
+     * @param name - Client name (default: 'default')
+     * @returns Redis driver instance
+     * @throws Error if client not found or connection fails
+     *
+     * @example
+     * ```typescript
+     * const driver = await manager.getClient('cache');
+     * await driver.set('key', 'value');
+     * ```
+     */
+    getClient(name?: string): Promise<IRedisDriver>;
+    /**
+     * Creates and registers a new Redis driver.
+     *
+     * @param name - Unique client name
+     * @param config - Redis connection configuration
+     * @param options - Optional client options
+     * @returns Created driver instance
+     * @throws Error if client with this name already exists
+     *
+     * @example
+     * ```typescript
+     * const driver = await manager.createClient('sessions', {
+     *   type: 'single',
+     *   host: 'localhost',
+     *   port: 6379,
+     *   db: 1,
+     * });
+     * ```
+     */
+    createClient(name: string, config: ConnectionConfig, options?: {
+        reconnection?: IReconnectionOptions;
+        metadata?: Partial<IClientMetadata>;
+    }): Promise<IRedisDriver>;
+    /**
+     * Checks if client exists.
+     *
+     * @param name - Client name
+     * @returns true if client is registered
+     */
+    hasClient(name: string): boolean;
+    /**
+     * Gets all registered client names.
+     *
+     * @returns Array of client names
+     */
+    getClientNames(): string[];
+    /**
+     * Closes specific client connection.
+     *
+     * Gracefully disconnects and removes client from registry.
+     *
+     * @param name - Client name
+     * @throws Error if client not found
+     *
+     * @example
+     * ```typescript
+     * await manager.closeClient('cache');
+     * ```
+     */
+    closeClient(name: string): Promise<void>;
+    /**
+     * Closes all client connections.
+     *
+     * Performs graceful shutdown of all clients in parallel.
+     * Safe to call multiple times.
+     *
+     * @example
+     * ```typescript
+     * await manager.closeAll();
+     * ```
+     */
+    closeAll(): Promise<void>;
+    /**
+     * Performs health check on client(s).
+     *
+     * Executes PING command and measures latency.
+     *
+     * @param name - Client name (if omitted, checks all clients)
+     * @returns Health status for specified client(s)
+     *
+     * @example
+     * ```typescript
+     * // Check single client
+     * const health = await manager.healthCheck('cache');
+     * if (!health.healthy) {
+     *   logger.error('Cache unhealthy', health);
+     * }
+     *
+     * // Check all clients
+     * const allHealth = await manager.healthCheck();
+     * ```
+     */
+    healthCheck(name?: string): Promise<IHealthStatus | IHealthStatus[]>;
+    /**
+     * Gets connection statistics.
+     *
+     * Returns aggregate stats for all clients.
+     *
+     * @returns Connection statistics
+     *
+     * @example
+     * ```typescript
+     * const stats = manager.getStats();
+     * console.log(`Connected: ${stats.connectedClients}/${stats.totalClients}`);
+     * ```
+     */
+    getStats(): IConnectionStats;
+    /**
+     * Gets client metadata.
+     *
+     * @param name - Client name
+     * @returns Client metadata
+     * @throws Error if client not found
+     */
+    getMetadata(name: string): IClientMetadata;
+    /**
+     * Updates client metadata.
+     *
+     * @param name - Client name
+     * @param metadata - Partial metadata to merge
+     */
+    updateMetadata(name: string, metadata: Partial<IClientMetadata>): void;
+    /**
+     * Registers event listener for all clients.
+     *
+     * @param event - Event name
+     * @param handler - Event handler
+     *
+     * @example
+     * ```typescript
+     * manager.on('manager:reconnecting', (data) => {
+     *   logger.warn(`Client ${data.name} reconnecting...`);
+     * });
+     * ```
+     */
+    on(event: ManagerEvent, handler: ManagerEventHandler): void;
+    /**
+     * Unregisters event listener.
+     *
+     * @param event - Event name
+     * @param handler - Event handler
+     */
+    off(event: ManagerEvent, handler: ManagerEventHandler): void;
+}
+/**
+ * Manager-specific events.
+ */
+declare enum ManagerEvent {
+    /**
+     * Client connected.
+     */
+    CONNECTED = "manager:connected",
+    /**
+     * Client disconnected.
+     */
+    DISCONNECTED = "manager:disconnected",
+    /**
+     * Client reconnecting.
+     */
+    RECONNECTING = "manager:reconnecting",
+    /**
+     * Client error.
+     */
+    ERROR = "manager:error",
+    /**
+     * Client created.
+     */
+    CREATED = "manager:created",
+    /**
+     * Client removed.
+     */
+    REMOVED = "manager:removed"
+}
+/**
+ * Manager event data.
+ */
+interface IManagerEventData {
+    /**
+     * Client name.
+     */
+    name: string;
+    /**
+     * Event timestamp.
+     */
+    timestamp: Date;
+    /**
+     * Error if any.
+     */
+    error?: Error;
+    /**
+     * Additional context.
+     */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Manager event handler.
+ */
+type ManagerEventHandler = (data: IManagerEventData) => void;
+
+/**
+ * Redis Client Manager.
+ *
+ * Manages multiple Redis client connections with:
+ * - Lazy connection (connect on first use)
+ * - Automatic reconnection with exponential backoff
+ * - Health monitoring and statistics
+ * - Graceful shutdown
+ * - Event notifications
+ *
+ * @example
+ * ```typescript
+ * @Injectable()
+ * export class AppService {
+ *   constructor(
+ *     @Inject(CLIENT_MANAGER) private readonly clientManager: RedisClientManager
+ *   ) {}
+ *
+ *   async cacheValue(key: string, value: string): Promise<void> {
+ *     const client = await this.clientManager.getClient('cache');
+ *     await client.set(key, value, { ex: 3600 });
+ *   }
+ * }
+ * ```
+ */
+declare class RedisClientManager implements IRedisDriverManager, OnModuleDestroy {
+    private readonly logger;
+    /**
+     * Registered clients.
+     */
+    private readonly clients;
+    /**
+     * Event emitter for client events.
+     */
+    private readonly eventEmitter;
+    /**
+     * Whether manager is shutting down.
+     */
+    private isShuttingDown;
+    /**
+     * Default reconnection options.
+     */
+    private readonly defaultIReconnectionOptions;
+    /**
+     * Default driver type.
+     */
+    private readonly defaultDriverType;
+    /**
+     * Gets Redis client by name with lazy connection.
+     */
+    getClient(name?: string): Promise<IRedisDriver>;
+    /**
+     * Creates and registers a new Redis client.
+     */
+    createClient(name: string, config: ConnectionConfig, options?: {
+        reconnection?: IReconnectionOptions;
+        metadata?: Partial<IClientMetadata>;
+        driverType?: DriverType;
+    }): Promise<IRedisDriver>;
+    /**
+     * Checks if client exists.
+     */
+    hasClient(name: string): boolean;
+    /**
+     * Gets all registered client names.
+     */
+    getClientNames(): string[];
+    /**
+     * Closes specific client connection.
+     */
+    closeClient(name: string): Promise<void>;
+    /**
+     * Closes all client connections.
+     */
+    closeAll(): Promise<void>;
+    /**
+     * Performs health check on client(s).
+     */
+    healthCheck(name?: string): Promise<IHealthStatus | IHealthStatus[]>;
+    /**
+     * Gets connection statistics.
+     */
+    getStats(): IConnectionStats;
+    /**
+     * Gets client metadata.
+     */
+    getMetadata(name: string): IClientMetadata;
+    /**
+     * Updates client metadata.
+     */
+    updateMetadata(name: string, metadata: Partial<IClientMetadata>): void;
+    /**
+     * Registers event listener.
+     */
+    on(event: ManagerEvent, handler: ManagerEventHandler): void;
+    /**
+     * Unregisters event listener.
+     */
+    off(event: ManagerEvent, handler: ManagerEventHandler): void;
+    /**
+     * NestJS lifecycle hook - cleanup on module destroy.
+     */
+    onModuleDestroy(): Promise<void>;
+    /**
+     * Connects client with error handling.
+     */
+    private connectClient;
+    /**
+     * Disconnects client gracefully.
+     */
+    private disconnectClient;
+    /**
+     * Sets up driver event handlers for reconnection.
+     */
+    private setupDriverEventHandlers;
+    /**
+     * Schedules reconnection with exponential backoff.
+     */
+    private scheduleReconnection;
+    /**
+     * Performs health check on single client.
+     */
+    private checkClientHealth;
+    /**
+     * Creates initial statistics for new client.
+     */
+    private createInitialStats;
+    /**
+     * Updates latency statistics.
+     */
+    private updateLatencyStats;
+    /**
+     * Calculates client uptime in milliseconds.
+     */
+    private calculateUptime;
+    /**
+     * Emits manager event.
+     */
+    private emitEvent;
+}
+
+/**
+ * Redis service - convenient wrapper over RedisClientManager.
+ *
+ * Provides direct access to Redis operations without manual client management.
+ * All methods are proxied to the default Redis driver.
+ *
+ * @example
+ * ```typescript
+ * @Injectable()
+ * export class UserService {
+ *   constructor(private readonly redis: RedisService) {}
+ *
+ *   async cacheUser(id: string, user: User): Promise<void> {
+ *     await this.redis.set(`user:${id}`, JSON.stringify(user), { ex: 3600 });
+ *   }
+ *
+ *   async getUser(id: string): Promise<User | null> {
+ *     const data = await this.redis.get(`user:${id}`);
+ *     return data ? JSON.parse(data) : null;
+ *   }
+ *
+ *   async deleteUser(id: string): Promise<void> {
+ *     await this.redis.del(`user:${id}`);
+ *   }
+ * }
+ * ```
+ */
+declare class RedisService implements OnModuleDestroy {
+    private readonly clientManager;
+    /**
+     * Default Redis driver instance.
+     */
+    private driver;
+    constructor(clientManager: RedisClientManager);
+    /**
+     * Gets default Redis driver.
+     * Lazy loads on first access.
+     */
+    private getDriver;
+    /**
+     * Gets a named Redis client.
+     *
+     * @param name - Client name
+     * @returns Redis driver instance
+     *
+     * @example
+     * ```typescript
+     * const sessions = await this.redis.getClient('sessions');
+     * await sessions.set('session:123', data);
+     * ```
+     */
+    getClient(name?: string): Promise<IRedisDriver>;
+    /**
+     * Checks if default client is connected.
+     */
+    isConnected(): Promise<boolean>;
+    /**
+     * Pings Redis server.
+     */
+    ping(message?: string): Promise<string>;
+    /**
+     * Selects database.
+     */
+    select(db: number): Promise<void>;
+    /**
+     * Gets value by key.
+     */
+    get(key: string): Promise<string | null>;
+    /**
+     * Sets key-value pair with optional TTL.
+     */
+    set(key: string, value: string, options?: ISetOptions): Promise<'OK' | null>;
+    /**
+     * Gets multiple values.
+     */
+    mget(...keys: string[]): Promise<Array<string | null>>;
+    /**
+     * Sets multiple key-value pairs.
+     */
+    mset(data: Record<string, string>): Promise<'OK'>;
+    /**
+     * Sets value only if key doesn't exist.
+     */
+    setnx(key: string, value: string): Promise<number>;
+    /**
+     * Sets value with expiration in seconds.
+     */
+    setex(key: string, seconds: number, value: string): Promise<'OK'>;
+    /**
+     * Gets value and deletes key.
+     */
+    getdel(key: string): Promise<string | null>;
+    /**
+     * Gets value and sets expiration.
+     */
+    getex(key: string, options: {
+        ex?: number;
+        px?: number;
+    }): Promise<string | null>;
+    /**
+     * Increments integer value by 1.
+     */
+    incr(key: string): Promise<number>;
+    /**
+     * Increments integer value by amount.
+     */
+    incrby(key: string, increment: number): Promise<number>;
+    /**
+     * Decrements integer value by 1.
+     */
+    decr(key: string): Promise<number>;
+    /**
+     * Decrements integer value by amount.
+     */
+    decrby(key: string, decrement: number): Promise<number>;
+    /**
+     * Appends value to key.
+     */
+    append(key: string, value: string): Promise<number>;
+    /**
+     * Deletes one or more keys.
+     */
+    del(...keys: string[]): Promise<number>;
+    /**
+     * Checks if keys exist.
+     */
+    exists(...keys: string[]): Promise<number>;
+    /**
+     * Sets TTL on key (seconds).
+     */
+    expire(key: string, seconds: number): Promise<number>;
+    /**
+     * Sets TTL on key (milliseconds).
+     */
+    pexpire(key: string, milliseconds: number): Promise<number>;
+    /**
+     * Sets absolute expiration time.
+     */
+    expireat(key: string, timestamp: number): Promise<number>;
+    /**
+     * Gets TTL of key (seconds).
+     */
+    ttl(key: string): Promise<number>;
+    /**
+     * Gets TTL of key (milliseconds).
+     */
+    pttl(key: string): Promise<number>;
+    /**
+     * Removes expiration from key.
+     */
+    persist(key: string): Promise<number>;
+    /**
+     * Renames key.
+     */
+    rename(key: string, newKey: string): Promise<'OK'>;
+    /**
+     * Renames key only if new key doesn't exist.
+     */
+    renamenx(key: string, newKey: string): Promise<number>;
+    /**
+     * Gets type of value stored at key.
+     */
+    type(key: string): Promise<string>;
+    /**
+     * Scans keys matching pattern.
+     */
+    scan(cursor: number, options?: IScanOptions): Promise<[string, string[]]>;
+    /**
+     * Gets hash field value.
+     */
+    hget(key: string, field: string): Promise<string | null>;
+    /**
+     * Sets hash field value.
+     */
+    hset(key: string, field: string, value: string): Promise<number>;
+    /**
+     * Sets multiple hash fields.
+     */
+    hmset(key: string, data: Record<string, string>): Promise<'OK'>;
+    /**
+     * Gets multiple hash field values.
+     */
+    hmget(key: string, ...fields: string[]): Promise<Array<string | null>>;
+    /**
+     * Gets all fields and values of hash.
+     */
+    hgetall(key: string): Promise<Record<string, string>>;
+    /**
+     * Deletes hash fields.
+     */
+    hdel(key: string, ...fields: string[]): Promise<number>;
+    /**
+     * Checks if hash field exists.
+     */
+    hexists(key: string, field: string): Promise<number>;
+    /**
+     * Gets all field names in hash.
+     */
+    hkeys(key: string): Promise<string[]>;
+    /**
+     * Gets all values in hash.
+     */
+    hvals(key: string): Promise<string[]>;
+    /**
+     * Gets number of fields in hash.
+     */
+    hlen(key: string): Promise<number>;
+    /**
+     * Increments hash field by integer.
+     */
+    hincrby(key: string, field: string, increment: number): Promise<number>;
+    /**
+     * Scans hash fields.
+     */
+    hscan(key: string, cursor: number, options?: IScanOptions): Promise<[string, string[]]>;
+    /**
+     * Pushes values to left of list.
+     */
+    lpush(key: string, ...values: string[]): Promise<number>;
+    /**
+     * Pushes values to right of list.
+     */
+    rpush(key: string, ...values: string[]): Promise<number>;
+    /**
+     * Pops value from left of list.
+     */
+    lpop(key: string): Promise<string | null>;
+    /**
+     * Pops value from right of list.
+     */
+    rpop(key: string): Promise<string | null>;
+    /**
+     * Gets list length.
+     */
+    llen(key: string): Promise<number>;
+    /**
+     * Gets list range.
+     */
+    lrange(key: string, start: number, stop: number): Promise<string[]>;
+    /**
+     * Trims list to specified range.
+     */
+    ltrim(key: string, start: number, stop: number): Promise<'OK'>;
+    /**
+     * Gets element at index.
+     */
+    lindex(key: string, index: number): Promise<string | null>;
+    /**
+     * Sets element at index.
+     */
+    lset(key: string, index: number, value: string): Promise<'OK'>;
+    /**
+     * Adds members to set.
+     */
+    sadd(key: string, ...members: string[]): Promise<number>;
+    /**
+     * Removes members from set.
+     */
+    srem(key: string, ...members: string[]): Promise<number>;
+    /**
+     * Gets all members of set.
+     */
+    smembers(key: string): Promise<string[]>;
+    /**
+     * Checks if member is in set.
+     */
+    sismember(key: string, member: string): Promise<number>;
+    /**
+     * Gets number of members in set.
+     */
+    scard(key: string): Promise<number>;
+    /**
+     * Gets random member from set.
+     */
+    srandmember(key: string, count?: number): Promise<string | string[] | null>;
+    /**
+     * Pops random member from set.
+     */
+    spop(key: string, count?: number): Promise<string | string[] | null>;
+    /**
+     * Scans set members.
+     */
+    sscan(key: string, cursor: number, options?: IScanOptions): Promise<[string, string[]]>;
+    /**
+     * Adds members to sorted set with scores.
+     */
+    zadd(key: string, ...args: Array<number | string>): Promise<number>;
+    /**
+     * Removes members from sorted set.
+     */
+    zrem(key: string, ...members: string[]): Promise<number>;
+    /**
+     * Gets members in range by index.
+     */
+    zrange(key: string, start: number, stop: number, withScores?: boolean): Promise<string[]>;
+    /**
+     * Gets members in range by score.
+     */
+    zrangebyscore(key: string, min: number | string, max: number | string, withScores?: boolean): Promise<string[]>;
+    /**
+     * Gets score of member.
+     */
+    zscore(key: string, member: string): Promise<string | null>;
+    /**
+     * Gets number of members in sorted set.
+     */
+    zcard(key: string): Promise<number>;
+    /**
+     * Gets rank of member.
+     */
+    zrank(key: string, member: string): Promise<number | null>;
+    /**
+     * Increments score of member.
+     */
+    zincrby(key: string, increment: number, member: string): Promise<string>;
+    /**
+     * Scans sorted set members.
+     */
+    zscan(key: string, cursor: number, options?: IScanOptions): Promise<[string, string[]]>;
+    /**
+     * Publishes message to channel.
+     */
+    publish(channel: string, message: string): Promise<number>;
+    /**
+     * Subscribes to channels.
+     */
+    subscribe(...channels: string[]): Promise<void>;
+    /**
+     * Unsubscribes from channels.
+     */
+    unsubscribe(...channels: string[]): Promise<void>;
+    /**
+     * Subscribes to channels by pattern.
+     */
+    psubscribe(...patterns: string[]): Promise<void>;
+    /**
+     * Unsubscribes from channel patterns.
+     */
+    punsubscribe(...patterns: string[]): Promise<void>;
+    /**
+     * Creates a pipeline for batching commands.
+     */
+    pipeline(): Promise<IPipeline>;
+    /**
+     * Creates a multi/exec transaction.
+     */
+    multi(): Promise<IMulti>;
+    /**
+     * Evaluates Lua script.
+     */
+    eval(script: string, keys: string[], args: Array<string | number>): Promise<unknown>;
+    /**
+     * Evaluates Lua script by SHA.
+     */
+    evalsha(sha: string, keys: string[], args: Array<string | number>): Promise<unknown>;
+    /**
+     * Loads Lua script and returns SHA.
+     */
+    scriptLoad(script: string): Promise<string>;
+    /**
+     * Checks if scripts exist.
+     */
+    scriptExists(...shas: string[]): Promise<number[]>;
+    /**
+     * Flushes all scripts from cache.
+     */
+    scriptFlush(): Promise<'OK'>;
+    /**
+     * Flushes all keys from current database.
+     */
+    flushdb(): Promise<'OK'>;
+    /**
+     * Flushes all keys from all databases.
+     */
+    flushall(): Promise<'OK'>;
+    /**
+     * Gets server info.
+     */
+    info(section?: string): Promise<string>;
+    /**
+     * Gets database size (number of keys).
+     */
+    dbsize(): Promise<number>;
+    /**
+     * NestJS lifecycle hook - cleanup on module destroy.
+     */
+    onModuleDestroy(): Promise<void>;
+}
+
+/**
+ * Injects Redis driver by name.
+ *
+ * Use this decorator to inject a specific Redis client into your service.
+ * If no name is provided, the default client is injected.
+ *
+ * @param name - Client name (default: 'default')
+ * @returns Property decorator
+ *
+ * @example
+ * ```typescript
+ * @Injectable()
+ * export class CacheService {
+ *   constructor(
+ *     @InjectRedis() private readonly redis: IRedisDriver,
+ *     @InjectRedis('sessions') private readonly sessions: IRedisDriver,
+ *   ) {}
+ *
+ *   async cacheUser(id: string, data: User): Promise<void> {
+ *     await this.redis.set(`user:${id}`, JSON.stringify(data), { ex: 3600 });
+ *   }
+ *
+ *   async getSession(id: string): Promise<string | null> {
+ *     return this.sessions.get(`session:${id}`);
+ *   }
+ * }
+ * ```
+ */
+declare function InjectRedis(name?: string): ParameterDecorator;
+
+/**
+ * Base Redis driver implementation.
+ *
+ * Provides common functionality for all driver implementations.
+ * Subclasses must implement abstract methods for specific Redis clients.
+ *
+ * Features:
+ * - Event handling
+ * - Connection state management
+ * - Error wrapping
+ * - Optional operation logging
+ *
+ * @abstract
+ */
+declare abstract class BaseRedisDriver implements IRedisDriver {
+    protected readonly config: ConnectionConfig;
+    protected readonly eventEmitter: EventEmitter;
+    protected readonly logger: Logger;
+    protected connected: boolean;
+    protected connecting: boolean;
+    protected readonly enableLogging: boolean;
+    constructor(config: ConnectionConfig, options?: {
+        enableLogging?: boolean;
+    });
+    /**
+     * Establishes connection to Redis.
+     * Must set `this.connected = true` on success.
+     */
+    protected abstract doConnect(): Promise<void>;
+    /**
+     * Closes connection to Redis.
+     * Must set `this.connected = false` on completion.
+     */
+    protected abstract doDisconnect(): Promise<void>;
+    /**
+     * Executes raw Redis command.
+     * @param command - Command name
+     * @param args - Command arguments
+     */
+    protected abstract executeCommand(command: string, ...args: unknown[]): Promise<unknown>;
+    /**
+     * Creates pipeline instance.
+     */
+    protected abstract createPipeline(): IPipeline;
+    /**
+     * Creates multi/exec transaction instance.
+     */
+    protected abstract createMulti(): IMulti;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    ping(message?: string): Promise<string>;
+    select(db: number): Promise<void>;
+    get(key: string): Promise<string | null>;
+    set(key: string, value: string, options?: ISetOptions): Promise<'OK' | null>;
+    mget(...keys: string[]): Promise<Array<string | null>>;
+    mset(data: Record<string, string>): Promise<'OK'>;
+    setnx(key: string, value: string): Promise<number>;
+    setex(key: string, seconds: number, value: string): Promise<'OK'>;
+    getdel(key: string): Promise<string | null>;
+    getex(key: string, options: {
+        ex?: number;
+        px?: number;
+    }): Promise<string | null>;
+    incr(key: string): Promise<number>;
+    incrby(key: string, increment: number): Promise<number>;
+    decr(key: string): Promise<number>;
+    decrby(key: string, decrement: number): Promise<number>;
+    append(key: string, value: string): Promise<number>;
+    strlen(key: string): Promise<number>;
+    incrbyfloat(key: string, increment: number): Promise<string>;
+    getrange(key: string, start: number, end: number): Promise<string>;
+    setrange(key: string, offset: number, value: string): Promise<number>;
+    msetnx(data: Record<string, string>): Promise<number>;
+    del(...keys: string[]): Promise<number>;
+    exists(...keys: string[]): Promise<number>;
+    expire(key: string, seconds: number): Promise<number>;
+    pexpire(key: string, milliseconds: number): Promise<number>;
+    expireat(key: string, timestamp: number): Promise<number>;
+    ttl(key: string): Promise<number>;
+    pttl(key: string): Promise<number>;
+    persist(key: string): Promise<number>;
+    rename(key: string, newKey: string): Promise<'OK'>;
+    renamenx(key: string, newKey: string): Promise<number>;
+    type(key: string): Promise<string>;
+    scan(cursor: number, options?: IScanOptions): Promise<[string, string[]]>;
+    unlink(...keys: string[]): Promise<number>;
+    copy(source: string, destination: string, options?: ICopyOptions): Promise<number>;
+    keys(pattern: string): Promise<string[]>;
+    touch(...keys: string[]): Promise<number>;
+    object(subcommand: 'ENCODING' | 'FREQ' | 'IDLETIME' | 'REFCOUNT', key: string): Promise<string | number | null>;
+    dump(key: string): Promise<string | null>;
+    restore(key: string, ttl: number, serializedValue: string, options?: IRestoreOptions): Promise<'OK'>;
+    time(): Promise<[string, string]>;
+    hget(key: string, field: string): Promise<string | null>;
+    hset(key: string, field: string, value: string): Promise<number>;
+    hmset(key: string, data: Record<string, string>): Promise<'OK'>;
+    hmget(key: string, ...fields: string[]): Promise<Array<string | null>>;
+    hgetall(key: string): Promise<Record<string, string>>;
+    hdel(key: string, ...fields: string[]): Promise<number>;
+    hexists(key: string, field: string): Promise<number>;
+    hkeys(key: string): Promise<string[]>;
+    hvals(key: string): Promise<string[]>;
+    hlen(key: string): Promise<number>;
+    hincrby(key: string, field: string, increment: number): Promise<number>;
+    hscan(key: string, cursor: number, options?: IScanOptions): Promise<[string, string[]]>;
+    hsetnx(key: string, field: string, value: string): Promise<number>;
+    hincrbyfloat(key: string, field: string, increment: number): Promise<string>;
+    hstrlen(key: string, field: string): Promise<number>;
+    hrandfield(key: string, count?: number, withValues?: boolean): Promise<string | string[] | null>;
+    lpush(key: string, ...values: string[]): Promise<number>;
+    rpush(key: string, ...values: string[]): Promise<number>;
+    lpop(key: string): Promise<string | null>;
+    rpop(key: string): Promise<string | null>;
+    llen(key: string): Promise<number>;
+    lrange(key: string, start: number, stop: number): Promise<string[]>;
+    ltrim(key: string, start: number, stop: number): Promise<'OK'>;
+    lindex(key: string, index: number): Promise<string | null>;
+    lset(key: string, index: number, value: string): Promise<'OK'>;
+    linsert(key: string, position: 'BEFORE' | 'AFTER', pivot: string, element: string): Promise<number>;
+    lrem(key: string, count: number, element: string): Promise<number>;
+    lpos(key: string, element: string, options?: ILposOptions): Promise<number | number[] | null>;
+    blpop(keys: string[], timeout: number): Promise<[string, string] | null>;
+    brpop(keys: string[], timeout: number): Promise<[string, string] | null>;
+    lmove(source: string, destination: string, from: 'LEFT' | 'RIGHT', to: 'LEFT' | 'RIGHT'): Promise<string | null>;
+    blmove(source: string, destination: string, from: 'LEFT' | 'RIGHT', to: 'LEFT' | 'RIGHT', timeout: number): Promise<string | null>;
+    sadd(key: string, ...members: string[]): Promise<number>;
+    srem(key: string, ...members: string[]): Promise<number>;
+    smembers(key: string): Promise<string[]>;
+    sismember(key: string, member: string): Promise<number>;
+    scard(key: string): Promise<number>;
+    srandmember(key: string, count?: number): Promise<string | string[] | null>;
+    spop(key: string, count?: number): Promise<string | string[] | null>;
+    sscan(key: string, cursor: number, options?: IScanOptions): Promise<[string, string[]]>;
+    smove(source: string, destination: string, member: string): Promise<number>;
+    sinter(...keys: string[]): Promise<string[]>;
+    sinterstore(destination: string, ...keys: string[]): Promise<number>;
+    sunion(...keys: string[]): Promise<string[]>;
+    sunionstore(destination: string, ...keys: string[]): Promise<number>;
+    sdiff(...keys: string[]): Promise<string[]>;
+    sdiffstore(destination: string, ...keys: string[]): Promise<number>;
+    smismember(key: string, ...members: string[]): Promise<number[]>;
+    zadd(key: string, ...args: Array<number | string>): Promise<number>;
+    zrem(key: string, ...members: string[]): Promise<number>;
+    zrange(key: string, start: number, stop: number, withScores?: boolean): Promise<string[]>;
+    zrangebyscore(key: string, min: number | string, max: number | string, withScores?: boolean): Promise<string[]>;
+    zscore(key: string, member: string): Promise<string | null>;
+    zcard(key: string): Promise<number>;
+    zrank(key: string, member: string): Promise<number | null>;
+    zincrby(key: string, increment: number, member: string): Promise<string>;
+    zscan(key: string, cursor: number, options?: IScanOptions): Promise<[string, string[]]>;
+    zrevrank(key: string, member: string): Promise<number | null>;
+    zcount(key: string, min: number | string, max: number | string): Promise<number>;
+    zlexcount(key: string, min: string, max: string): Promise<number>;
+    zpopmin(key: string, count?: number): Promise<string[]>;
+    zpopmax(key: string, count?: number): Promise<string[]>;
+    bzpopmin(keys: string[], timeout: number): Promise<[string, string, string] | null>;
+    bzpopmax(keys: string[], timeout: number): Promise<[string, string, string] | null>;
+    zunionstore(destination: string, keys: string[], options?: IZStoreOptions): Promise<number>;
+    zinterstore(destination: string, keys: string[], options?: IZStoreOptions): Promise<number>;
+    zmscore(key: string, ...members: string[]): Promise<Array<string | null>>;
+    zrandmember(key: string, count?: number, withScores?: boolean): Promise<string | string[] | null>;
+    zrevrangebyscore(key: string, max: number | string, min: number | string, options?: IZRangeByScoreOptions): Promise<string[]>;
+    publish(channel: string, message: string): Promise<number>;
+    subscribe(...channels: string[]): Promise<void>;
+    unsubscribe(...channels: string[]): Promise<void>;
+    psubscribe(...patterns: string[]): Promise<void>;
+    punsubscribe(...patterns: string[]): Promise<void>;
+    xadd(key: string, id: string, fields: Record<string, string>, options?: IStreamAddOptions): Promise<string>;
+    xread(streams: Array<{
+        key: string;
+        id: string;
+    }>, options?: IStreamReadOptions): Promise<StreamReadResult | null>;
+    xreadgroup(group: string, consumer: string, streams: Array<{
+        key: string;
+        id: string;
+    }>, options?: IStreamReadGroupOptions): Promise<StreamReadResult | null>;
+    xrange(key: string, start: string, end: string, options?: {
+        count?: number;
+    }): Promise<IStreamEntry[]>;
+    xrevrange(key: string, end: string, start: string, options?: {
+        count?: number;
+    }): Promise<IStreamEntry[]>;
+    xlen(key: string): Promise<number>;
+    xinfo(key: string): Promise<IStreamInfo>;
+    xtrim(key: string, maxLen: number, approximate?: boolean): Promise<number>;
+    xgroupCreate(key: string, group: string, id: string, mkstream?: boolean): Promise<'OK'>;
+    xgroupDestroy(key: string, group: string): Promise<number>;
+    xgroupDelConsumer(key: string, group: string, consumer: string): Promise<number>;
+    xgroupSetId(key: string, group: string, id: string): Promise<'OK'>;
+    xack(key: string, group: string, ...ids: string[]): Promise<number>;
+    xpending(key: string, group: string): Promise<IStreamPendingInfo>;
+    xpendingRange(key: string, group: string, start: string, end: string, count: number, consumer?: string): Promise<IStreamPendingEntry[]>;
+    xclaim(key: string, group: string, consumer: string, minIdleTime: number, ...ids: string[]): Promise<IStreamEntry[]>;
+    xdel(key: string, ...ids: string[]): Promise<number>;
+    private parseStreamReadResult;
+    private parseStreamEntries;
+    private parseFieldArray;
+    private parseIStreamInfo;
+    private parseIStreamPendingInfo;
+    private parseStreamPendingEntries;
+    pipeline(): IPipeline;
+    multi(): IMulti;
+    /** Registry mapping SHA → script source for NOSCRIPT fallback */
+    private readonly scriptRegistry;
+    eval(script: string, keys: string[], args: Array<string | number>): Promise<unknown>;
+    evalsha(sha: string, keys: string[], args: Array<string | number>): Promise<unknown>;
+    scriptLoad(script: string): Promise<string>;
+    private isNoscriptError;
+    scriptExists(...shas: string[]): Promise<number[]>;
+    scriptFlush(): Promise<'OK'>;
+    pfadd(key: string, ...elements: string[]): Promise<number>;
+    pfcount(...keys: string[]): Promise<number>;
+    pfmerge(destination: string, ...sources: string[]): Promise<'OK'>;
+    geoadd(key: string, ...members: Array<number | string>): Promise<number>;
+    geodist(key: string, member1: string, member2: string, unit?: GeoUnit): Promise<string | null>;
+    geohash(key: string, ...members: string[]): Promise<Array<string | null>>;
+    geopos(key: string, ...members: string[]): Promise<Array<[string, string] | null>>;
+    geosearch(key: string, options: IGeoSearchOptions): Promise<Array<string | IGeoSearchResult>>;
+    geosearchstore(destination: string, source: string, options: IGeoSearchOptions & {
+        storedist?: boolean;
+    }): Promise<number>;
+    private parseIGeoSearchResult;
+    setbit(key: string, offset: number, value: 0 | 1): Promise<number>;
+    getbit(key: string, offset: number): Promise<number>;
+    bitcount(key: string, start?: number, end?: number, mode?: 'BYTE' | 'BIT'): Promise<number>;
+    bitop(operation: 'AND' | 'OR' | 'XOR' | 'NOT', destKey: string, ...keys: string[]): Promise<number>;
+    bitpos(key: string, bit: 0 | 1, start?: number, end?: number, mode?: 'BYTE' | 'BIT'): Promise<number>;
+    flushdb(): Promise<'OK'>;
+    flushall(): Promise<'OK'>;
+    info(section?: string): Promise<string>;
+    dbsize(): Promise<number>;
+    cluster(subcommand: string, ...args: Array<string | number>): Promise<unknown>;
+    sentinel(subcommand: string, ...args: Array<string | number>): Promise<unknown>;
+    on(event: DriverEvent, handler: DriverEventHandler): void;
+    once(event: DriverEvent, handler: DriverEventHandler): void;
+    off(event: DriverEvent, handler: DriverEventHandler): void;
+    removeAllListeners(event?: DriverEvent): void;
+    /**
+     * Asserts that driver is connected.
+     * @throws DriverError if not connected
+     */
+    protected assertConnected(): void;
+    /**
+     * Emits driver event.
+     */
+    protected emit(event: DriverEvent, data?: unknown): void;
+    /**
+     * Logs message if logging is enabled.
+     */
+    protected log(message: string, data?: unknown): void;
+    /**
+     * Wraps execution with timeout.
+     */
+    protected withTimeout<T>(promise: Promise<T>, timeoutMs: number, operation: string): Promise<T>;
+}
+
+/**
+ * IoRedis driver adapter.
+ *
+ * Implements IRedisDriver using ioredis library.
+ * Supports single instance, cluster, and sentinel configurations.
+ *
+ * @example
+ * ```typescript
+ * const driver = new IoRedisAdapter({
+ *   host: 'localhost',
+ *   port: 6379,
+ * });
+ * await driver.connect();
+ * ```
+ */
+declare class IoRedisAdapter extends BaseRedisDriver {
+    private client;
+    constructor(config: ConnectionConfig, options?: {
+        enableLogging?: boolean;
+    });
+    protected doConnect(): Promise<void>;
+    protected doDisconnect(): Promise<void>;
+    protected executeCommand(command: string, ...args: unknown[]): Promise<unknown>;
+    protected createPipeline(): IPipeline;
+    protected createMulti(): IMulti;
+    private createSingleClient;
+    private createClusterClient;
+    private createSentinelClient;
+    private setupEventHandlers;
+    /**
+     * Gets underlying ioredis client.
+     * For advanced usage only.
+     */
+    getClient(): Redis | Cluster | null;
+}
+
+/**
+ * Union type for all supported node-redis client types.
+ */
+type NodeRedisClient = RedisClientType | RedisClusterType | RedisSentinelType;
+/**
+ * Node-Redis driver adapter.
+ *
+ * Implements IRedisDriver using redis (node-redis v4+) library.
+ * Supports single instance, cluster, and sentinel configurations.
+ *
+ * @example
+ * ```typescript
+ * // Single instance
+ * const driver = new NodeRedisAdapter({
+ *   type: 'single',
+ *   host: 'localhost',
+ *   port: 6379,
+ * });
+ *
+ * // Cluster
+ * const clusterDriver = new NodeRedisAdapter({
+ *   type: 'cluster',
+ *   nodes: [{ host: 'node1', port: 7000 }],
+ * });
+ *
+ * // Sentinel
+ * const sentinelDriver = new NodeRedisAdapter({
+ *   type: 'sentinel',
+ *   sentinels: [{ host: 'sentinel1', port: 26379 }],
+ *   name: 'mymaster',
+ * });
+ *
+ * await driver.connect();
+ * ```
+ */
+declare class NodeRedisAdapter extends BaseRedisDriver {
+    private client;
+    private isSentinel;
+    private isCluster;
+    private readonly keyPrefix;
+    constructor(config: ConnectionConfig, options?: {
+        enableLogging?: boolean;
+    });
+    protected doConnect(): Promise<void>;
+    protected doDisconnect(): Promise<void>;
+    protected executeCommand(command: string, ...args: unknown[]): Promise<unknown>;
+    protected createPipeline(): IPipeline;
+    protected createMulti(): IMulti;
+    /**
+     * Override hgetall to convert array response to object.
+     * Node-redis sendCommand returns ['field1', 'value1', 'field2', 'value2']
+     * but we need { field1: 'value1', field2: 'value2' }
+     */
+    hgetall(key: string): Promise<Record<string, string>>;
+    /**
+     * Override scan to normalize cursor response.
+     * Node-redis sendCommand returns [cursor, [keys...]]
+     */
+    scan(cursor: number, options?: {
+        match?: string;
+        count?: number;
+    }): Promise<[string, string[]]>;
+    /**
+     * Override hscan to normalize cursor response.
+     */
+    hscan(key: string, cursor: number, options?: {
+        match?: string;
+        count?: number;
+    }): Promise<[string, string[]]>;
+    /**
+     * Override sscan to normalize cursor response.
+     */
+    sscan(key: string, cursor: number, options?: {
+        match?: string;
+        count?: number;
+    }): Promise<[string, string[]]>;
+    /**
+     * Override zscan to normalize cursor response.
+     */
+    zscan(key: string, cursor: number, options?: {
+        match?: string;
+        count?: number;
+    }): Promise<[string, string[]]>;
+    /**
+     * Override info to return string.
+     */
+    info(section?: string): Promise<string>;
+    private createSingleClient;
+    private createClusterClient;
+    /**
+     * Creates a Redis Sentinel client using the proper createSentinel API.
+     * Returns already connected sentinel instance.
+     *
+     * NOTE: node-redis does not support natMap/nodeAddressMap for Sentinel.
+     * For Docker/NAT environments, use ioredis driver which supports sentinelOptions.natMap.
+     */
+    private createSentinelClient;
+    /**
+     * Safely disconnect the client, ignoring errors.
+     */
+    private safeDisconnect;
+    /**
+     * Default reconnection strategy: exponential backoff with max 30s delay.
+     * Returns a function that calculates delay based on retry count.
+     */
+    private getDefaultReconnectStrategy;
+    /**
+     * Get the first key from command arguments for cluster slot routing.
+     * Returns undefined for commands that don't require a key.
+     */
+    private getFirstKey;
+    /**
+     * Check if a command is readonly (doesn't modify data).
+     * Used for cluster to route reads to replicas if enabled.
+     */
+    private isReadonlyCommand;
+    /**
+     * Convert arguments to proper types for sendCommand.
+     * sendCommand expects string[] but we need to handle numbers properly.
+     */
+    private convertArgs;
+    /**
+     * Apply key prefix to key-based commands.
+     * This emulates ioredis keyPrefix functionality.
+     */
+    private applyKeyPrefix;
+    private setupEventHandlers;
+    /**
+     * Gets underlying node-redis client.
+     * For advanced usage only.
+     */
+    getClient(): NodeRedisClient | null;
+    /**
+     * Returns true if connected to Redis Sentinel.
+     */
+    isSentinelMode(): boolean;
+}
+
+/**
+ * Driver factory options.
+ */
+interface IDriverFactoryOptions {
+    /**
+     * Driver type to create.
+     * @default 'ioredis'
+     */
+    type?: DriverType;
+    /**
+     * Enable operation logging.
+     * @default false
+     */
+    enableLogging?: boolean;
+}
+/**
+ * Factory for creating Redis drivers.
+ *
+ * Creates driver instances based on configuration.
+ * Drivers are interchangeable - switching between ioredis and node-redis
+ * requires no code changes.
+ *
+ * @example
+ * ```typescript
+ * // Create ioredis driver
+ * const driver = createDriver(
+ *   { host: 'localhost', port: 6379 },
+ *   { type: 'ioredis' }
+ * );
+ *
+ * // Switch to node-redis (same interface)
+ * const driver = createDriver(
+ *   { host: 'localhost', port: 6379 },
+ *   { type: 'node-redis' }
+ * );
+ * ```
+ */
+declare function createDriver(config: ConnectionConfig, options?: IDriverFactoryOptions): IRedisDriver;
+/**
+ * Driver factory class for dependency injection.
+ *
+ * @example
+ * ```typescript
+ * @Module({
+ *   providers: [
+ *     {
+ *       provide: DRIVER_FACTORY,
+ *       useClass: DriverFactory,
+ *     },
+ *   ],
+ * })
+ * export class MyModule {}
+ * ```
+ */
+declare class DriverFactory {
+    /**
+     * Creates a driver instance.
+     */
+    create(config: ConnectionConfig, options?: IDriverFactoryOptions): IRedisDriver;
+    /**
+     * Gets supported driver types.
+     */
+    getSupportedTypes(): DriverType[];
+    /**
+     * Checks if driver type is supported.
+     */
+    isSupported(type: string): type is DriverType;
+    /**
+     * Gets default driver type.
+     */
+    getDefaultType(): DriverType;
+}
+/**
+ * Creates multiple drivers from configurations.
+ *
+ * @example
+ * ```typescript
+ * const drivers = createDrivers({
+ *   default: { host: 'localhost', port: 6379 },
+ *   cache: { host: 'cache.local', port: 6379 },
+ * });
+ * ```
+ */
+declare function createDrivers(configs: Record<string, ConnectionConfig>, options?: IDriverFactoryOptions): Record<string, IRedisDriver>;
+/**
+ * Driver type detection helper.
+ * Attempts to detect available driver library.
+ */
+declare function detectAvailableDriver(): DriverType | null;
+/**
+ * Gets recommended driver type based on environment.
+ */
+declare function getRecommendedDriver(): DriverType;
+
+/**
+ * Manages plugin lifecycle hooks and dependency ordering.
+ *
+ * Calls `onRegister()` and `onModuleInit()` on all plugins during
+ * NestJS module initialization, and `onModuleDestroy()` during shutdown.
+ * Plugins with `dependencies` are initialized in topological order.
+ */
+declare class PluginRegistryService implements OnModuleInit, OnModuleDestroy {
+    private readonly plugins;
+    private readonly clientManager;
+    private readonly options;
+    private readonly moduleRef;
+    private readonly logger;
+    constructor(plugins: IRedisXPlugin[], clientManager: RedisClientManager, options: IRedisModuleOptions, moduleRef: ModuleRef);
+    onModuleInit(): Promise<void>;
+    onModuleDestroy(): Promise<void>;
+    private createContext;
+    /**
+     * Topological sort of plugins by dependencies (Kahn's algorithm).
+     * Plugins without dependencies maintain their original order.
+     * Throws on circular dependencies.
+     */
+    sortByDependencies(plugins: IRedisXPlugin[]): IRedisXPlugin[];
+}
+
+/**
+ * All possible error codes in NestJS RedisX.
+ * Organized by domain for easier categorization and handling.
+ *
+ * Naming convention: {DOMAIN}_{SPECIFIC_ERROR}
+ *
+ * Domains:
+ * - CONN/DRIVER: Connection and networking errors
+ * - OP: Redis operation errors
+ * - CFG/CONFIG: Configuration and validation errors
+ * - LOCK: Distributed lock errors
+ * - CACHE: Caching errors
+ * - RATE: Rate limiting errors
+ * - STREAM: Stream processing errors
+ * - PLUGIN: Plugin system errors
+ * - IDEMPOTENCY: Idempotency errors
+ */
+declare enum ErrorCode {
+    /** Failed to establish connection to Redis server */
+    CONN_FAILED = "CONN_FAILED",
+    /** Connection attempt timed out */
+    CONN_TIMEOUT = "CONN_TIMEOUT",
+    /** Lost connection to Redis server */
+    CONN_DISCONNECTED = "CONN_DISCONNECTED",
+    /** Connection was refused by Redis server */
+    CONN_REFUSED = "CONN_REFUSED",
+    /** Authentication failed */
+    CONN_AUTH_FAILED = "CONN_AUTH_FAILED",
+    /** TLS/SSL connection error */
+    CONN_TLS_ERROR = "CONN_TLS_ERROR",
+    /** Redis cluster is down or unreachable */
+    CONN_CLUSTER_DOWN = "CONN_CLUSTER_DOWN",
+    /** Redis cluster slot migration in progress */
+    CONN_CLUSTER_MOVED = "CONN_CLUSTER_MOVED",
+    /** Redis cluster ASK redirection */
+    CONN_CLUSTER_ASK = "CONN_CLUSTER_ASK",
+    /** Redis cluster error */
+    CONN_CLUSTER_ERROR = "CONN_CLUSTER_ERROR",
+    /** Sentinel failover in progress */
+    CONN_SENTINEL_FAILOVER = "CONN_SENTINEL_FAILOVER",
+    /** No Sentinel master found */
+    CONN_SENTINEL_NO_MASTER = "CONN_SENTINEL_NO_MASTER",
+    /** Sentinel error */
+    CONN_SENTINEL_ERROR = "CONN_SENTINEL_ERROR",
+    /** Driver not connected */
+    DRIVER_NOT_CONNECTED = "DRIVER_NOT_CONNECTED",
+    /** Maximum connection retries exceeded */
+    CONN_MAX_RETRIES = "CONN_MAX_RETRIES",
+    /** Connection pool exhausted */
+    CONN_POOL_EXHAUSTED = "CONN_POOL_EXHAUSTED",
+    /** Redis operation failed */
+    OP_FAILED = "OP_FAILED",
+    /** Redis operation timed out */
+    OP_TIMEOUT = "OP_TIMEOUT",
+    /** Redis key not found */
+    OP_KEY_NOT_FOUND = "OP_KEY_NOT_FOUND",
+    /** Wrong Redis data type for operation */
+    OP_TYPE_MISMATCH = "OP_TYPE_MISMATCH",
+    /** Redis script execution failed */
+    OP_SCRIPT_ERROR = "OP_SCRIPT_ERROR",
+    /** Redis script timeout */
+    OP_SCRIPT_TIMEOUT = "OP_SCRIPT_TIMEOUT",
+    /** Redis transaction failed */
+    OP_TRANSACTION_FAILED = "OP_TRANSACTION_FAILED",
+    /** Redis pipeline execution failed */
+    OP_PIPELINE_FAILED = "OP_PIPELINE_FAILED",
+    /** Invalid operation arguments */
+    OP_INVALID_ARGS = "OP_INVALID_ARGS",
+    /** Operation not supported by driver */
+    OP_NOT_SUPPORTED = "OP_NOT_SUPPORTED",
+    /** Redis out of memory */
+    OP_OUT_OF_MEMORY = "OP_OUT_OF_MEMORY",
+    /** Redis NOAUTH error - authentication required */
+    OP_NO_AUTH = "OP_NO_AUTH",
+    /** Redis WRONGPASS error - invalid password */
+    OP_WRONG_PASS = "OP_WRONG_PASS",
+    /** Redis READONLY error - can't write to replica */
+    OP_READONLY = "OP_READONLY",
+    /** Redis BUSYKEY error - target key already exists */
+    OP_BUSY_KEY = "OP_BUSY_KEY",
+    /** Operation requires driver to be connected */
+    OP_NOT_CONNECTED = "OP_NOT_CONNECTED",
+    /** Invalid configuration */
+    CFG_INVALID = "CFG_INVALID",
+    /** Missing required configuration */
+    CFG_MISSING_REQUIRED = "CFG_MISSING_REQUIRED",
+    /** Invalid connection type */
+    CFG_INVALID_CONNECTION_TYPE = "CFG_INVALID_CONNECTION_TYPE",
+    /** Invalid host or port */
+    CFG_INVALID_HOST_PORT = "CFG_INVALID_HOST_PORT",
+    /** Invalid database number */
+    CFG_INVALID_DB = "CFG_INVALID_DB",
+    /** Invalid TTL value */
+    CFG_INVALID_TTL = "CFG_INVALID_TTL",
+    /** Invalid timeout value */
+    CFG_INVALID_TIMEOUT = "CFG_INVALID_TIMEOUT",
+    /** Invalid retry configuration */
+    CFG_INVALID_RETRY = "CFG_INVALID_RETRY",
+    /** Validation failed */
+    CFG_VALIDATION_FAILED = "CFG_VALIDATION_FAILED",
+    /** Incompatible configuration options */
+    CFG_INCOMPATIBLE = "CFG_INCOMPATIBLE",
+    /** Driver type not supported */
+    CFG_DRIVER_NOT_SUPPORTED = "CFG_DRIVER_NOT_SUPPORTED",
+    /** Invalid cluster nodes configuration */
+    CFG_INVALID_CLUSTER_NODES = "CFG_INVALID_CLUSTER_NODES",
+    /** Invalid sentinel configuration */
+    CFG_INVALID_SENTINEL = "CFG_INVALID_SENTINEL",
+    /** Invalid TLS configuration */
+    CFG_INVALID_TLS = "CFG_INVALID_TLS",
+    /** Cache key is invalid */
+    CACHE_KEY_INVALID = "CACHE_KEY_INVALID",
+    /** Cache key exceeds maximum length */
+    CACHE_KEY_TOO_LONG = "CACHE_KEY_TOO_LONG",
+    /** Failed to serialize value */
+    CACHE_SERIALIZATION_FAILED = "CACHE_SERIALIZATION_FAILED",
+    /** Failed to deserialize value */
+    CACHE_DESERIALIZATION_FAILED = "CACHE_DESERIALIZATION_FAILED",
+    /** Cache tag index corrupted */
+    CACHE_TAG_INDEX_CORRUPTED = "CACHE_TAG_INDEX_CORRUPTED",
+    /** Cache stampede protection timeout */
+    CACHE_STAMPEDE_TIMEOUT = "CACHE_STAMPEDE_TIMEOUT",
+    /** Cache loader function failed */
+    CACHE_LOADER_FAILED = "CACHE_LOADER_FAILED",
+    /** L1 cache error */
+    CACHE_L1_ERROR = "CACHE_L1_ERROR",
+    /** L2 cache error */
+    CACHE_L2_ERROR = "CACHE_L2_ERROR",
+    /** Cache set operation failed */
+    CACHE_SET_FAILED = "CACHE_SET_FAILED",
+    /** Cache delete operation failed */
+    CACHE_DELETE_FAILED = "CACHE_DELETE_FAILED",
+    /** Cache clear operation failed */
+    CACHE_CLEAR_FAILED = "CACHE_CLEAR_FAILED",
+    /** Cache operation failed */
+    CACHE_OPERATION_FAILED = "CACHE_OPERATION_FAILED",
+    /** Cache operation timeout */
+    CACHE_OPERATION_TIMEOUT = "CACHE_OPERATION_TIMEOUT",
+    /** Tag invalidation failed */
+    CACHE_TAG_INVALIDATION_FAILED = "CACHE_TAG_INVALIDATION_FAILED",
+    /** Failed to acquire lock */
+    LOCK_ACQUISITION_FAILED = "LOCK_ACQUISITION_FAILED",
+    /** Lock acquisition timed out */
+    LOCK_ACQUISITION_TIMEOUT = "LOCK_ACQUISITION_TIMEOUT",
+    /** Failed to extend lock TTL */
+    LOCK_EXTENSION_FAILED = "LOCK_EXTENSION_FAILED",
+    /** Failed to release lock */
+    LOCK_RELEASE_FAILED = "LOCK_RELEASE_FAILED",
+    /** Attempting to release lock not owned by caller */
+    LOCK_NOT_OWNED = "LOCK_NOT_OWNED",
+    /** Lock expired before operation completed */
+    LOCK_EXPIRED = "LOCK_EXPIRED",
+    /** Rate limit exceeded */
+    RATE_LIMIT_EXCEEDED = "RATE_LIMIT_EXCEEDED",
+    /** Rate limit script error */
+    RATE_LIMIT_SCRIPT_ERROR = "RATE_LIMIT_SCRIPT_ERROR",
+    /** Idempotency key is invalid */
+    IDEMPOTENCY_KEY_INVALID = "IDEMPOTENCY_KEY_INVALID",
+    /** Operation already in progress */
+    IDEMPOTENCY_IN_PROGRESS = "IDEMPOTENCY_IN_PROGRESS",
+    /** Previous operation failed */
+    IDEMPOTENCY_PREVIOUS_FAILED = "IDEMPOTENCY_PREVIOUS_FAILED",
+    /** Consumer group operation failed */
+    STREAM_CONSUMER_GROUP_ERROR = "STREAM_CONSUMER_GROUP_ERROR",
+    /** Stream ACK failed */
+    STREAM_ACK_FAILED = "STREAM_ACK_FAILED",
+    /** Stream read failed */
+    STREAM_READ_FAILED = "STREAM_READ_FAILED",
+    /** Plugin is invalid */
+    PLUGIN_INVALID = "PLUGIN_INVALID",
+    /** Plugin already registered */
+    PLUGIN_DUPLICATE = "PLUGIN_DUPLICATE",
+    /** Plugin not found */
+    PLUGIN_NOT_FOUND = "PLUGIN_NOT_FOUND",
+    /** Plugin registration failed */
+    PLUGIN_REGISTER_FAILED = "PLUGIN_REGISTER_FAILED",
+    /** Plugin initialization failed */
+    PLUGIN_INIT_FAILED = "PLUGIN_INIT_FAILED",
+    /** Circular plugin dependency */
+    PLUGIN_CIRCULAR_DEPENDENCY = "PLUGIN_CIRCULAR_DEPENDENCY",
+    /** Required plugin dependency missing */
+    PLUGIN_DEPENDENCY_MISSING = "PLUGIN_DEPENDENCY_MISSING",
+    /** Client not found */
+    CLIENT_NOT_FOUND = "CLIENT_NOT_FOUND",
+    /** Client already exists */
+    CLIENT_ALREADY_EXISTS = "CLIENT_ALREADY_EXISTS",
+    /** Service not initialized */
+    NOT_INITIALIZED = "NOT_INITIALIZED",
+    /** Generic operation failed */
+    OPERATION_FAILED = "OPERATION_FAILED",
+    /** Generic operation timeout */
+    OPERATION_TIMEOUT = "OPERATION_TIMEOUT",
+    /** Generic serialization failed */
+    SERIALIZATION_FAILED = "SERIALIZATION_FAILED",
+    /** Generic validation failed */
+    VALIDATION_FAILED = "VALIDATION_FAILED",
+    /** Unknown error */
+    UNKNOWN = "UNKNOWN"
+}
+/**
+ * Type guard to check if a string is a valid ErrorCode.
+ */
+declare function isErrorCode(value: string): value is ErrorCode;
+/**
+ * Get error domain from error code.
+ *
+ * @param code - Error code
+ * @returns Domain prefix (e.g., 'CONN', 'OP', 'CFG')
+ *
+ * @example
+ * ```typescript
+ * getErrorDomain(ErrorCode.CONN_FAILED) // 'CONN'
+ * getErrorDomain(ErrorCode.OP_TIMEOUT) // 'OP'
+ * ```
+ */
+declare function getErrorDomain(code: ErrorCode): string;
+/**
+ * Check if error code belongs to a domain.
+ *
+ * @param code - Error code to check
+ * @param domain - Domain to check against
+ * @returns True if code belongs to domain
+ *
+ * @example
+ * ```typescript
+ * isErrorDomain(ErrorCode.CONN_FAILED, 'CONN') // true
+ * isErrorDomain(ErrorCode.OP_TIMEOUT, 'CONN') // false
+ * ```
+ */
+declare function isErrorDomain(code: ErrorCode, domain: string): boolean;
+
+/**
+ * JSON representation of an error.
+ * Used for serialization in logs and API responses.
+ */
+interface IErrorJSON {
+    /** Error class name */
+    name: string;
+    /** Human-readable error message */
+    message: string;
+    /** Error code for programmatic handling */
+    code: string;
+    /** ISO timestamp when error occurred */
+    timestamp: string;
+    /** Additional context for debugging */
+    context?: Record<string, unknown>;
+    /** Stack trace */
+    stack?: string;
+    /** Cause error if wrapped */
+    cause?: {
+        name: string;
+        message: string;
+        stack?: string;
+    };
+}
+/**
+ * Base error class for all RedisX errors.
+ *
+ * Features:
+ * - Structured error codes for programmatic handling
+ * - Context preservation for debugging
+ * - JSON serialization for logging
+ * - Proper error chaining with cause
+ * - Timestamp tracking
+ *
+ * While this class can be instantiated directly, it's recommended
+ * to use or extend specific error classes for better error handling.
+ *
+ * @example
+ * ```typescript
+ * export class CacheError extends RedisXError {
+ *   constructor(message: string, cause?: Error) {
+ *     super(message, ErrorCode.CACHE_LOADER_FAILED, cause, {
+ *       key: 'user:123',
+ *       ttl: 3600,
+ *     });
+ *   }
+ * }
+ * ```
+ */
+declare class RedisXError extends Error {
+    readonly code: ErrorCode;
+    readonly cause?: Error | undefined;
+    readonly context?: Record<string, unknown> | undefined;
+    /**
+     * Timestamp when error was created.
+     */
+    readonly timestamp: Date;
+    /**
+     * Creates a new RedisXError.
+     *
+     * @param message - Human-readable error message
+     * @param code - Error code for programmatic handling
+     * @param cause - Original error that caused this error
+     * @param context - Additional context for debugging
+     */
+    constructor(message: string, code: ErrorCode, cause?: Error | undefined, context?: Record<string, unknown> | undefined);
+    /**
+     * Checks if error is of specific code.
+     *
+     * @param code - Error code to check
+     * @returns True if error matches code
+     *
+     * @example
+     * ```typescript
+     * if (error.is(ErrorCode.CONN_FAILED)) {
+     *   // Handle connection error
+     * }
+     * ```
+     */
+    is(code: ErrorCode): boolean;
+    /**
+     * Checks if error is any of specified codes.
+     *
+     * @param codes - Array of error codes to check
+     * @returns True if error matches any code
+     *
+     * @example
+     * ```typescript
+     * if (error.isAnyOf([ErrorCode.LOCK_EXPIRED, ErrorCode.LOCK_NOT_OWNED])) {
+     *   // Handle lock error
+     * }
+     * ```
+     */
+    isAnyOf(codes: ErrorCode[]): boolean;
+    /**
+     * Serializes error to JSON for logging.
+     *
+     * @returns JSON representation of error
+     *
+     * @example
+     * ```typescript
+     * logger.error('Operation failed', error.toJSON());
+     * ```
+     */
+    toJSON(): IErrorJSON;
+    /**
+     * Creates error string for logging.
+     *
+     * @returns Formatted error string
+     */
+    toString(): string;
+    /**
+     * Wraps unknown error in RedisXError.
+     *
+     * @param error - Error to wrap
+     * @param code - Error code to assign
+     * @returns RedisXError instance
+     *
+     * @example
+     * ```typescript
+     * try {
+     *   await someOperation();
+     * } catch (err) {
+     *   throw RedisXError.wrap(err, ErrorCode.CACHE_LOADER_FAILED);
+     * }
+     * ```
+     */
+    static wrap(error: unknown, code?: ErrorCode): RedisXError;
+    /**
+     * Checks if value is a RedisXError.
+     *
+     * @param error - Value to check
+     * @returns True if value is RedisXError
+     */
+    static isRedisXError(error: unknown): error is RedisXError;
+}
+
+/**
+ * Base class for all connection-related errors.
+ *
+ * Provides common context for connection failures including
+ * host, port, and connection type information.
+ */
+declare class RedisConnectionError extends RedisXError {
+    readonly host?: string | undefined;
+    readonly port?: number | undefined;
+    constructor(message: string, code: ErrorCode, host?: string | undefined, port?: number | undefined, cause?: Error, context?: Record<string, unknown>);
+    /**
+     * Creates connection error with default code.
+     */
+    static create(message: string, host?: string, port?: number, cause?: Error): RedisConnectionError;
+}
+/**
+ * Error thrown when connection or operation times out.
+ *
+ * Includes timeout duration and operation details for debugging.
+ *
+ * @example
+ * ```typescript
+ * throw new RedisTimeoutError(
+ *   'Connection',
+ *   5000,
+ *   'localhost',
+ *   6379,
+ * );
+ * ```
+ */
+declare class RedisTimeoutError extends RedisConnectionError {
+    readonly operation: string;
+    readonly timeoutMs: number;
+    constructor(operation: string, timeoutMs: number, host?: string, port?: number, cause?: Error);
+}
+/**
+ * Error thrown for Redis Cluster-specific failures.
+ *
+ * Handles cluster slot redirections (MOVED, ASK), cluster down states,
+ * and other cluster topology issues.
+ *
+ * @example
+ * ```typescript
+ * // Cluster down
+ * throw new RedisClusterError(
+ *   'Cluster is down',
+ *   ErrorCode.CONN_CLUSTER_DOWN,
+ * );
+ *
+ * // Slot migration
+ * throw new RedisClusterError(
+ *   'Key moved to different slot',
+ *   ErrorCode.CONN_CLUSTER_MOVED,
+ *   undefined,
+ *   undefined,
+ *   undefined,
+ *   { slot: 1234, targetNode: 'node2:7001' },
+ * );
+ * ```
+ */
+declare class RedisClusterError extends RedisConnectionError {
+    constructor(message: string, code: ErrorCode, host?: string, port?: number, cause?: Error, context?: Record<string, unknown>);
+    /**
+     * Creates cluster down error.
+     */
+    static clusterDown(host?: string, port?: number): RedisClusterError;
+    /**
+     * Creates MOVED redirection error.
+     */
+    static moved(slot: number, targetHost: string, targetPort: number, cause?: Error): RedisClusterError;
+    /**
+     * Creates ASK redirection error.
+     */
+    static ask(slot: number, targetHost: string, targetPort: number, cause?: Error): RedisClusterError;
+    /**
+     * Creates generic cluster error.
+     */
+    static generic(message: string, host?: string, port?: number, cause?: Error): RedisClusterError;
+}
+/**
+ * Error thrown for Redis Sentinel-specific failures.
+ *
+ * Handles sentinel master discovery, failover events, and sentinel
+ * connectivity issues.
+ *
+ * @example
+ * ```typescript
+ * // No master found
+ * throw RedisSentinelError.noMaster('mymaster', [
+ *   { host: 'sentinel1', port: 26379 },
+ *   { host: 'sentinel2', port: 26379 },
+ * ]);
+ *
+ * // Failover in progress
+ * throw RedisSentinelError.failover(
+ *   'mymaster',
+ *   'old-master:6379',
+ *   'new-master:6379',
+ * );
+ * ```
+ */
+declare class RedisSentinelError extends RedisConnectionError {
+    readonly masterName?: string | undefined;
+    constructor(message: string, code: ErrorCode, masterName?: string | undefined, host?: string, port?: number, cause?: Error, context?: Record<string, unknown>);
+    /**
+     * Creates no master found error.
+     */
+    static noMaster(masterName: string, sentinels?: Array<{
+        host: string;
+        port: number;
+    }>): RedisSentinelError;
+    /**
+     * Creates sentinel failover error.
+     */
+    static failover(masterName: string, oldMaster?: string, newMaster?: string): RedisSentinelError;
+    /**
+     * Creates generic sentinel error.
+     */
+    static generic(message: string, masterName?: string, cause?: Error): RedisSentinelError;
+}
+/**
+ * Error thrown when authentication fails.
+ *
+ * @example
+ * ```typescript
+ * throw new RedisAuthError('Invalid password', 'localhost', 6379);
+ * ```
+ */
+declare class RedisAuthError extends RedisConnectionError {
+    constructor(message?: string, host?: string, port?: number, cause?: Error);
+}
+/**
+ * Error thrown when TLS/SSL connection fails.
+ *
+ * @example
+ * ```typescript
+ * throw new RedisTLSError(
+ *   'Certificate verification failed',
+ *   'secure.redis.example.com',
+ *   6380,
+ *   originalError,
+ * );
+ * ```
+ */
+declare class RedisTLSError extends RedisConnectionError {
+    constructor(message?: string, host?: string, port?: number, cause?: Error);
+}
+/**
+ * Error thrown when maximum connection retries exceeded.
+ *
+ * @example
+ * ```typescript
+ * throw new RedisMaxRetriesError(
+ *   5,
+ *   'localhost',
+ *   6379,
+ *   lastError,
+ * );
+ * ```
+ */
+declare class RedisMaxRetriesError extends RedisConnectionError {
+    readonly maxRetries: number;
+    constructor(maxRetries: number, host?: string, port?: number, cause?: Error);
+}
+/**
+ * Error thrown when connection pool is exhausted.
+ *
+ * @example
+ * ```typescript
+ * throw new RedisPoolExhaustedError(10, 100);
+ * ```
+ */
+declare class RedisPoolExhaustedError extends RedisConnectionError {
+    readonly poolSize: number;
+    readonly waitingClients: number;
+    constructor(poolSize: number, waitingClients: number, cause?: Error);
+}
+
+/**
+ * Base class for all Redis operation errors.
+ *
+ * Provides common context for operation failures including
+ * command name and arguments.
+ */
+declare class RedisOperationError extends RedisXError {
+    readonly command?: string | undefined;
+    constructor(message: string, code: ErrorCode, command?: string | undefined, cause?: Error, context?: Record<string, unknown>);
+    /**
+     * Creates operation error with default code.
+     */
+    static create(message: string, command?: string, cause?: Error): RedisOperationError;
+    /**
+     * Creates operation error from command and arguments.
+     */
+    static fromCommand(command: string, args: unknown[], cause?: Error): RedisOperationError;
+}
+/**
+ * Error thrown when Redis key is not found.
+ *
+ * Used for operations that require a key to exist.
+ *
+ * @example
+ * ```typescript
+ * const value = await redis.get('user:123');
+ * if (!value) {
+ *   throw new RedisKeyNotFoundError('user:123', 'GET');
+ * }
+ * ```
+ */
+declare class RedisKeyNotFoundError extends RedisOperationError {
+    readonly key: string;
+    constructor(key: string, command?: string, cause?: Error);
+}
+/**
+ * Error thrown when Redis value type doesn't match expected type.
+ *
+ * For example, trying to LPUSH to a string value.
+ *
+ * @example
+ * ```typescript
+ * // Trying to use list command on a string
+ * throw new RedisTypeMismatchError(
+ *   'mykey',
+ *   'list',
+ *   'string',
+ *   'LPUSH',
+ * );
+ * ```
+ */
+declare class RedisTypeMismatchError extends RedisOperationError {
+    readonly key: string;
+    readonly expected: string;
+    readonly actual: string;
+    constructor(key: string, expected: string, actual: string, command?: string, cause?: Error);
+    /**
+     * Creates type mismatch from Redis WRONGTYPE error.
+     */
+    static fromRedisError(key: string, command: string, cause: Error): RedisTypeMismatchError;
+}
+/**
+ * Error thrown when Redis Lua script execution fails.
+ *
+ * Includes script SHA and error details for debugging.
+ *
+ * @example
+ * ```typescript
+ * throw new RedisScriptError(
+ *   'Script execution failed: division by zero',
+ *   'abc123...',
+ *   originalError,
+ *   { line: 42 },
+ * );
+ * ```
+ */
+declare class RedisScriptError extends RedisOperationError {
+    readonly scriptSha?: string | undefined;
+    constructor(message: string, scriptSha?: string | undefined, cause?: Error, context?: Record<string, unknown>);
+    /**
+     * Creates script timeout error.
+     */
+    static timeout(timeoutMs: number, scriptSha?: string): RedisScriptError;
+    /**
+     * Creates script not found error (NOSCRIPT).
+     */
+    static notFound(scriptSha: string): RedisScriptError;
+}
+/**
+ * Error thrown when Redis transaction (MULTI/EXEC) fails.
+ *
+ * @example
+ * ```typescript
+ * throw new RedisTransactionError(
+ *   'Transaction aborted due to WATCH key modification',
+ *   originalError,
+ * );
+ * ```
+ */
+declare class RedisTransactionError extends RedisOperationError {
+    constructor(message: string, cause?: Error, context?: Record<string, unknown>);
+    /**
+     * Creates transaction aborted error (WATCH failure).
+     */
+    static aborted(): RedisTransactionError;
+}
+/**
+ * Error thrown when Redis pipeline execution fails.
+ *
+ * @example
+ * ```typescript
+ * throw new RedisPipelineError(
+ *   'Pipeline execution failed: 3 of 10 commands failed',
+ *   10,
+ *   3,
+ *   originalError,
+ * );
+ * ```
+ */
+declare class RedisPipelineError extends RedisOperationError {
+    readonly totalCommands: number;
+    readonly failedCommands: number;
+    constructor(message: string, totalCommands: number, failedCommands: number, cause?: Error);
+}
+/**
+ * Error thrown when operation has invalid arguments.
+ *
+ * @example
+ * ```typescript
+ * throw new RedisInvalidArgsError(
+ *   'SET',
+ *   'TTL must be a positive number',
+ *   { ttl: -1 },
+ * );
+ * ```
+ */
+declare class RedisInvalidArgsError extends RedisOperationError {
+    readonly args?: Record<string, unknown> | undefined;
+    constructor(command: string, reason: string, args?: Record<string, unknown> | undefined);
+}
+/**
+ * Error thrown when Redis returns out of memory error.
+ *
+ * @example
+ * ```typescript
+ * throw new RedisOutOfMemoryError('SET', 'user:123');
+ * ```
+ */
+declare class RedisOutOfMemoryError extends RedisOperationError {
+    readonly key?: string | undefined;
+    constructor(command: string, key?: string | undefined, cause?: Error);
+}
+/**
+ * Error thrown when attempting to write to a read-only replica.
+ *
+ * @example
+ * ```typescript
+ * throw new RedisReadOnlyError('SET', 'user:123');
+ * ```
+ */
+declare class RedisReadOnlyError extends RedisOperationError {
+    readonly key?: string | undefined;
+    constructor(command: string, key?: string | undefined, cause?: Error);
+}
+/**
+ * Error thrown when operation is not supported by current driver.
+ *
+ * @example
+ * ```typescript
+ * throw new RedisNotSupportedError(
+ *   'GEOSEARCH',
+ *   'Requires Redis 6.2+',
+ * );
+ * ```
+ */
+declare class RedisNotSupportedError extends RedisOperationError {
+    readonly reason: string;
+    constructor(command: string, reason: string);
+}
+/**
+ * Error thrown when driver is not connected.
+ *
+ * @example
+ * ```typescript
+ * if (!this.isConnected()) {
+ *   throw new RedisNotConnectedError('GET');
+ * }
+ * ```
+ */
+declare class RedisNotConnectedError extends RedisOperationError {
+    constructor(command?: string);
+}
+
+/**
+ * Base class for all configuration errors.
+ *
+ * Thrown during module initialization when configuration is invalid.
+ */
+declare class RedisConfigError extends RedisXError {
+    constructor(message: string, code: ErrorCode, cause?: Error, context?: Record<string, unknown>);
+    /**
+     * Creates generic config error.
+     */
+    static create(message: string, cause?: Error, context?: Record<string, unknown>): RedisConfigError;
+    /**
+     * Creates missing required field error.
+     */
+    static missingRequired(field: string, parent?: string): RedisConfigError;
+    /**
+     * Creates invalid connection type error.
+     */
+    static invalidConnectionType(type: string, validTypes: string[]): RedisConfigError;
+    /**
+     * Creates invalid host/port error.
+     */
+    static invalidHostPort(host?: string, port?: number, reason?: string): RedisConfigError;
+    /**
+     * Creates invalid database number error.
+     */
+    static invalidDb(db: number, max?: number): RedisConfigError;
+    /**
+     * Creates invalid TTL error.
+     */
+    static invalidTTL(ttl: number, reason?: string): RedisConfigError;
+    /**
+     * Creates invalid timeout error.
+     */
+    static invalidTimeout(timeout: number, field: string, reason?: string): RedisConfigError;
+    /**
+     * Creates invalid retry configuration error.
+     */
+    static invalidRetry(reason: string, context?: Record<string, unknown>): RedisConfigError;
+    /**
+     * Creates incompatible configuration error.
+     */
+    static incompatible(option1: string, option2: string, reason?: string): RedisConfigError;
+    /**
+     * Creates driver not supported error.
+     */
+    static driverNotSupported(driver: string, supportedDrivers: string[]): RedisConfigError;
+    /**
+     * Creates invalid cluster nodes error.
+     */
+    static invalidClusterNodes(reason: string, nodes?: Array<{
+        host: string;
+        port: number;
+    }>): RedisConfigError;
+    /**
+     * Creates invalid sentinel configuration error.
+     */
+    static invalidSentinel(reason: string, context?: Record<string, unknown>): RedisConfigError;
+    /**
+     * Creates invalid TLS configuration error.
+     */
+    static invalidTLS(reason: string, context?: Record<string, unknown>): RedisConfigError;
+}
+/**
+ * Error thrown when configuration validation fails.
+ *
+ * Used for complex validation rules and schema validation.
+ *
+ * @example
+ * ```typescript
+ * throw new RedisValidationError(
+ *   'clients',
+ *   [
+ *     { field: 'host', message: 'Host is required' },
+ *     { field: 'port', message: 'Port must be between 1 and 65535' },
+ *   ],
+ * );
+ * ```
+ */
+declare class RedisValidationError extends RedisConfigError {
+    readonly field: string;
+    readonly errors: Array<{
+        field: string;
+        message: string;
+        value?: unknown;
+    }>;
+    constructor(field: string, errors: Array<{
+        field: string;
+        message: string;
+        value?: unknown;
+    }>, cause?: Error);
+    /**
+     * Creates validation error from single field.
+     */
+    static single(field: string, message: string, value?: unknown): RedisValidationError;
+    /**
+     * Creates validation error from multiple fields.
+     */
+    static multiple(parent: string, errors: Array<{
+        field: string;
+        message: string;
+        value?: unknown;
+    }>): RedisValidationError;
+    /**
+     * Adds a validation error to the list.
+     */
+    addError(field: string, message: string, value?: unknown): this;
+    /**
+     * Checks if validation has errors.
+     */
+    hasErrors(): boolean;
+    /**
+     * Gets all error messages.
+     */
+    getMessages(): string[];
+    /**
+     * Gets errors for specific field.
+     */
+    getFieldErrors(field: string): Array<{
+        field: string;
+        message: string;
+        value?: unknown;
+    }>;
+}
+/**
+ * Validation error collector for building up multiple validation errors.
+ *
+ * @example
+ * ```typescript
+ * const validator = new ValidationErrorCollector('connectionConfig');
+ *
+ * if (!config.host) {
+ *   validator.add('host', 'Host is required');
+ * }
+ *
+ * if (config.port < 1 || config.port > 65535) {
+ *   validator.add('port', 'Port must be between 1 and 65535', config.port);
+ * }
+ *
+ * validator.throwIfErrors();
+ * ```
+ */
+declare class ValidationErrorCollector {
+    private readonly parent;
+    private errors;
+    constructor(parent: string);
+    /**
+     * Adds a validation error.
+     */
+    add(field: string, message: string, value?: unknown): this;
+    /**
+     * Checks if there are any errors.
+     */
+    hasErrors(): boolean;
+    /**
+     * Gets error count.
+     */
+    count(): number;
+    /**
+     * Throws if there are any errors.
+     */
+    throwIfErrors(): void;
+    /**
+     * Gets all errors.
+     */
+    getErrors(): Array<{
+        field: string;
+        message: string;
+        value?: unknown;
+    }>;
+    /**
+     * Clears all errors.
+     */
+    clear(): void;
+}
+
+/**
+ * Driver-specific error classes with simplified constructors.
+ * Used internally by driver adapters (ioredis, node-redis).
+ */
+
+/**
+ * Base class for driver-related errors.
+ */
+declare class DriverError extends RedisConnectionError {
+    constructor(message: string, code: ErrorCode, cause?: Error, context?: Record<string, unknown>);
+}
+/**
+ * Error thrown when connection to Redis fails.
+ */
+declare class ConnectionError extends RedisConnectionError {
+    readonly host?: string | undefined;
+    readonly port?: number | undefined;
+    constructor(message: string, cause?: Error, host?: string | undefined, port?: number | undefined);
+}
+/**
+ * Error thrown when operation times out.
+ */
+declare class TimeoutError extends RedisTimeoutError {
+    constructor(operation: string, timeoutMs: number, cause?: Error);
+}
+/**
+ * Error thrown when Redis command fails.
+ */
+declare class CommandError extends RedisOperationError {
+    readonly command: string;
+    readonly args: unknown[];
+    constructor(command: string, args: unknown[], cause?: Error);
+}
+
+/**
+ * Dependency injection tokens for NestJS RedisX.
+ */
+/**
+ * Token for injecting module options.
+ * Used for synchronous and asynchronous configuration.
+ */
+declare const REDIS_MODULE_OPTIONS: unique symbol;
+/**
+ * Token for injecting default Redis client.
+ * Points to the 'default' named client.
+ */
+declare const REDIS_CLIENT: unique symbol;
+/**
+ * Token for injecting Redis clients map.
+ * Contains all registered named clients.
+ */
+declare const REDIS_CLIENTS_MAP: unique symbol;
+/**
+ * Token for injecting client manager.
+ * Manages lifecycle of all Redis clients.
+ */
+declare const CLIENT_MANAGER: unique symbol;
+/**
+ * Token for injecting Redis driver.
+ * Abstracts ioredis/node-redis implementation.
+ */
+declare const REDIS_DRIVER: unique symbol;
+/**
+ * Token for injecting RedisX configuration.
+ * Contains module-level and global configuration.
+ */
+declare const REDISX_CONFIG: unique symbol;
+/**
+ * Token for injecting plugin registry.
+ * Manages plugin lifecycle and dependencies.
+ */
+declare const PLUGIN_REGISTRY: unique symbol;
+/**
+ * Token for injecting registered plugins array.
+ * Used internally by PluginRegistryService.
+ */
+declare const REGISTERED_PLUGINS: unique symbol;
+/**
+ * Token for injecting logger.
+ * Provides structured logging for RedisX.
+ */
+declare const REDISX_LOGGER: unique symbol;
+/**
+ * Creates a token for named Redis client.
+ * @param name - Client name
+ * @returns Injection token
+ *
+ * @example
+ * ```typescript
+ * @Injectable()
+ * export class MyService {
+ *   constructor(
+ *     @Inject(getClientToken('cache'))
+ *     private readonly cacheClient: IRedisClient
+ *   ) {}
+ * }
+ * ```
+ */
+declare function getClientToken(name: string): symbol;
+/**
+ * Creates a token for named driver.
+ * @param name - Driver name
+ * @returns Injection token
+ */
+declare function getDriverToken(name: string): symbol;
+/**
+ * Default client name.
+ */
+declare const DEFAULT_CLIENT_NAME = "default";
+/**
+ * Default driver type.
+ */
+declare const DEFAULT_DRIVER_TYPE = "ioredis";
+/**
+ * Module name for logging.
+ */
+declare const MODULE_NAME = "RedisXModule";
+/**
+ * Default connection timeout (ms).
+ */
+declare const DEFAULT_CONNECTION_TIMEOUT = 10000;
+/**
+ * Default command timeout (ms).
+ */
+declare const DEFAULT_COMMAND_TIMEOUT = 5000;
+/**
+ * Default graceful shutdown timeout (ms).
+ */
+declare const DEFAULT_GRACEFUL_SHUTDOWN_TIMEOUT = 5000;
+/**
+ * Token for async clients initialization.
+ * Used internally to ensure clients are created before injection.
+ */
+declare const REDIS_CLIENTS_INITIALIZATION: unique symbol;
+/**
+ * Default health check interval (ms).
+ */
+declare const DEFAULT_HEALTH_CHECK_INTERVAL = 30000;
+
+/**
+ * Shared types for NestJS RedisX.
+ */
+/**
+ * Generic async function type.
+ */
+type AsyncFunction<TArgs extends unknown[] = [], TReturn = unknown> = (...args: TArgs) => Promise<TReturn>;
+/**
+ * Nullable type helper.
+ */
+type Nullable<T> = T | null;
+/**
+ * Optional type helper.
+ */
+type Optional<T> = T | undefined;
+/**
+ * Makes all properties optional recursively.
+ */
+type DeepPartial<T> = {
+    [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P];
+};
+/**
+ * Makes all properties required recursively.
+ */
+type DeepRequired<T> = {
+    [P in keyof T]-?: T[P] extends object ? DeepRequired<T[P]> : T[P];
+};
+
+export { type AsyncFunction, BaseRedisDriver, CLIENT_MANAGER, CommandError, type ConnectionConfig, ConnectionError, ConnectionStatus, DEFAULT_CLIENT_NAME, DEFAULT_COMMAND_TIMEOUT, DEFAULT_CONNECTION_TIMEOUT, DEFAULT_DRIVER_TYPE, DEFAULT_GRACEFUL_SHUTDOWN_TIMEOUT, DEFAULT_HEALTH_CHECK_INTERVAL, type DeepPartial, type DeepRequired, DriverError, DriverEvent, type DriverEventHandler, DriverFactory, type DriverType, ErrorCode, type GeoUnit, type IBaseConnectionConfig, type IClientHealthStatus, type IClientManager, type IClientMetadata, type IClientStats, type IClusterConnectionConfig, type IConnectionStats, type ICopyOptions, type IDriverFactoryOptions, type IErrorJSON, type IGeoSearchOptions, type IGeoSearchResult, type IGlobalConfig, type IHealthCheckResult, type IHealthStatus, type ILposOptions, type IManagerEventData, type IMulti, type IPipeline, type IPluginContext, type IReconnectionOptions, type IRedisClient, type IRedisClientOptions, type IRedisDriver, type IRedisDriverManager, type IRedisModuleAsyncOptions, type IRedisModuleOptions, type IRedisModuleOptionsFactory, type IRedisXPlugin, type IRestoreOptions, type IScanOptions, type ISentinelConnectionConfig, type ISetOptions, type ISingleConnectionConfig, type IStreamAddOptions, type IStreamEntry, type IStreamInfo, type IStreamPendingEntry, type IStreamPendingInfo, type IStreamReadGroupOptions, type IStreamReadOptions, type ITlsConfig, type IZRangeByScoreOptions, type IZStoreOptions, InjectRedis, IoRedisAdapter, MODULE_NAME, ManagerEvent, type ManagerEventHandler, NodeRedisAdapter, type Nullable, type Optional, PLUGIN_REGISTRY, PluginRegistryService, REDISX_CONFIG, REDISX_LOGGER, REDIS_CLIENT, REDIS_CLIENTS_INITIALIZATION, REDIS_CLIENTS_MAP, REDIS_DRIVER, REDIS_MODULE_OPTIONS, REGISTERED_PLUGINS, RedisAuthError, RedisClientManager, RedisClusterError, RedisConfigError, RedisConnectionError, RedisInvalidArgsError, RedisKeyNotFoundError, RedisMaxRetriesError, RedisModule, RedisNotConnectedError, RedisNotSupportedError, RedisOperationError, RedisOutOfMemoryError, RedisPipelineError, RedisPoolExhaustedError, RedisReadOnlyError, RedisScriptError, RedisSentinelError, RedisService, RedisTLSError, RedisTimeoutError, RedisTransactionError, RedisTypeMismatchError, RedisValidationError, RedisXError, type StreamReadResult, TimeoutError, ValidationErrorCollector, createDriver, createDrivers, detectAvailableDriver, getClientToken, getDriverToken, getErrorDomain, getRecommendedDriver, hasClass, hasExisting, hasFactory, isClusterConnection, isErrorCode, isErrorDomain, isSentinelConnection, isSingleConnection };