import { DynamicModule, OnModuleInit } from '@nestjs/common';
import type { Redis } from 'ioredis';
import { RedisLockService } from './redis-lock.service';
/**
 * Injection token for Redis Lock Service
 */
export declare const REDIS_LOCK_SERVICE: unique symbol;
/**
 * Redis Lock module configuration options
 */
export interface RedisLockModuleOptions {
    /**
     * Whether to make the module global
     * @default true
     */
    isGlobal?: boolean;
    /**
     * Redis client instance (required)
     * RedisLockService requires an external Redis client to function
     */
    redisClient: Redis;
    /**
     * Default TTL for locks in milliseconds
     */
    defaultTtl?: number;
    /**
     * Default key prefix for locks
     */
    defaultKeyPrefix?: string;
    /**
     * Default retry count for lock acquisition
     */
    defaultRetryCount?: number;
    /**
     * Default retry delay in milliseconds
     */
    defaultRetryDelay?: number;
    /**
     * Enable automatic lock cleanup on startup
     * This includes heartbeat mechanism and comprehensive cleanup
     * @default true
     */
    enableCleanup?: boolean;
    /**
     * Additional key prefixes to include in startup/shutdown cleanup.
     * The module always includes the RedisLockService default prefix.
     */
    cleanupKeyPrefixes?: string[];
}
/**
 * Redis Lock module with distributed locking support
 *
 * Provides RedisLockService and @UseRedisLock decorator for
 * distributed locking mechanisms using Redis.
 *
 * Requires an external Redis client to function.
 *
 * @example
 * ```typescript
 * // With Redis client injection
 * import { RedisModule } from '@songkeys/nestjs-redis';
 *
 * @Module({
 *   imports: [
 *     RedisModule.forRoot({ ... }),
 *     RedisLockModule.forRootAsync({
 *       imports: [RedisModule],
 *       inject: [RedisService],
 *       useFactory: (redisService: RedisService) => ({
 *         redisClient: redisService.getClient()
 *       })
 *     })
 *   ]
 * })
 * export class AppModule {}
 * ```
 */
export declare class RedisLockModule implements OnModuleInit {
    private readonly redisLockService?;
    constructor(redisLockService?: RedisLockService);
    /**
     * Register Redis Lock module with options
     */
    static forRoot(options: RedisLockModuleOptions): DynamicModule;
    /**
     * Register Redis Lock module asynchronously
     */
    static forRootAsync(options: {
        imports?: any[];
        inject?: any[];
        useFactory: (...args: any[]) => Promise<RedisLockModuleOptions> | RedisLockModuleOptions;
        isGlobal?: boolean;
    }): DynamicModule;
    onModuleInit(): void;
}