ioredis-toolkit 0.0.1

package/dist/types.d.ts

@@ -0,0 +1,782 @@
+import type { Redis as RedisType } from "ioredis";
+import { z } from "zod";
+import type { SessionManagerOptions } from "./session/session-manager.js";
+export declare const RateLimitAlgorithmSchema: z.ZodEnum<{
+    fixed: "fixed";
+    sliding: "sliding";
+}>;
+export declare const RateLimitOptionsSchema: z.ZodObject<{
+    limit: z.ZodDefault<z.ZodNumber>;
+    duration: z.ZodDefault<z.ZodNumber>;
+    algorithm: z.ZodDefault<z.ZodEnum<{
+        fixed: "fixed";
+        sliding: "sliding";
+    }>>;
+    namespace: z.ZodDefault<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * User-supplied rate-limit configuration.
+ *
+ * Defaults have not necessarily been materialized yet.
+ */
+export type RateLimitOptionsInput = z.input<typeof RateLimitOptionsSchema>;
+/**
+ * Fully normalized rate-limit configuration.
+ *
+ * All properties are guaranteed to exist after parsing.
+ */
+export type RateLimitOptions = z.output<typeof RateLimitOptionsSchema>;
+export declare const RedisModeSchema: z.ZodEnum<{
+    cluster: "cluster";
+    sentinel: "sentinel";
+    standalone: "standalone";
+}>;
+export type RedisMode = z.infer<typeof RedisModeSchema>;
+export declare const RedisNodeSchema: z.ZodObject<{
+    host: z.ZodString;
+    port: z.ZodNumber;
+}, z.core.$strict>;
+export type RedisNode = z.output<typeof RedisNodeSchema>;
+export declare const RedisTlsOptionsSchema: z.ZodObject<{
+    ca: z.ZodOptional<z.ZodString>;
+    cert: z.ZodOptional<z.ZodString>;
+    key: z.ZodOptional<z.ZodString>;
+    rejectUnauthorized: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strict>;
+export type RedisTlsOptionsInput = z.input<typeof RedisTlsOptionsSchema>;
+export type RedisTlsOptions = z.output<typeof RedisTlsOptionsSchema>;
+export declare const SessionOptionsSchema: z.ZodCustom<Partial<SessionManagerOptions>, Partial<SessionManagerOptions>>;
+export type SessionOptionsInput = z.input<typeof SessionOptionsSchema>;
+export type SessionOptions = z.output<typeof SessionOptionsSchema>;
+/**
+ * Configuration shared by all Redis topologies.
+ *
+ * IMPORTANT:
+ * - This schema describes the user-facing input.
+ * - `.default()` makes the property optional on input while guaranteeing
+ *   the value exists on output.
+ */
+export declare const BaseRedisConfigSchema: z.ZodObject<{
+    password: z.ZodOptional<z.ZodString>;
+    username: z.ZodOptional<z.ZodString>;
+    database: z.ZodDefault<z.ZodNumber>;
+    tls: z.ZodDefault<z.ZodBoolean>;
+    tlsOptions: z.ZodOptional<z.ZodObject<{
+        ca: z.ZodOptional<z.ZodString>;
+        cert: z.ZodOptional<z.ZodString>;
+        key: z.ZodOptional<z.ZodString>;
+        rejectUnauthorized: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strict>>;
+    maxRetries: z.ZodDefault<z.ZodNumber>;
+    retryDelay: z.ZodDefault<z.ZodNumber>;
+    connectionTimeout: z.ZodDefault<z.ZodNumber>;
+    maxFanOutConcurrency: z.ZodDefault<z.ZodNumber>;
+    maxBatchSize: z.ZodDefault<z.ZodNumber>;
+    defaultTTL: z.ZodDefault<z.ZodNumber>;
+    compressionThreshold: z.ZodDefault<z.ZodNumber>;
+    slowCommandThreshold: z.ZodDefault<z.ZodNumber>;
+    rateLimit: z.ZodDefault<z.ZodObject<{
+        limit: z.ZodDefault<z.ZodNumber>;
+        duration: z.ZodDefault<z.ZodNumber>;
+        algorithm: z.ZodDefault<z.ZodEnum<{
+            fixed: "fixed";
+            sliding: "sliding";
+        }>>;
+        namespace: z.ZodDefault<z.ZodString>;
+    }, z.core.$strip>>;
+    sessionOptions: z.ZodOptional<z.ZodCustom<Partial<SessionManagerOptions>, Partial<SessionManagerOptions>>>;
+}, z.core.$strict>;
+export type RedisCommonConfigInput = z.input<typeof BaseRedisConfigSchema>;
+export type RedisCommonConfig = z.output<typeof BaseRedisConfigSchema>;
+/**
+ * Standalone Redis configuration.
+ *
+ * `mode` is optional on input because standalone is the default topology.
+ */
+export declare const StandaloneRedisConfigSchema: z.ZodObject<{
+    password: z.ZodOptional<z.ZodString>;
+    username: z.ZodOptional<z.ZodString>;
+    database: z.ZodDefault<z.ZodNumber>;
+    tls: z.ZodDefault<z.ZodBoolean>;
+    tlsOptions: z.ZodOptional<z.ZodObject<{
+        ca: z.ZodOptional<z.ZodString>;
+        cert: z.ZodOptional<z.ZodString>;
+        key: z.ZodOptional<z.ZodString>;
+        rejectUnauthorized: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strict>>;
+    maxRetries: z.ZodDefault<z.ZodNumber>;
+    retryDelay: z.ZodDefault<z.ZodNumber>;
+    connectionTimeout: z.ZodDefault<z.ZodNumber>;
+    maxFanOutConcurrency: z.ZodDefault<z.ZodNumber>;
+    maxBatchSize: z.ZodDefault<z.ZodNumber>;
+    defaultTTL: z.ZodDefault<z.ZodNumber>;
+    compressionThreshold: z.ZodDefault<z.ZodNumber>;
+    slowCommandThreshold: z.ZodDefault<z.ZodNumber>;
+    rateLimit: z.ZodDefault<z.ZodObject<{
+        limit: z.ZodDefault<z.ZodNumber>;
+        duration: z.ZodDefault<z.ZodNumber>;
+        algorithm: z.ZodDefault<z.ZodEnum<{
+            fixed: "fixed";
+            sliding: "sliding";
+        }>>;
+        namespace: z.ZodDefault<z.ZodString>;
+    }, z.core.$strip>>;
+    sessionOptions: z.ZodOptional<z.ZodCustom<Partial<SessionManagerOptions>, Partial<SessionManagerOptions>>>;
+    mode: z.ZodOptional<z.ZodLiteral<"standalone">>;
+    host: z.ZodDefault<z.ZodString>;
+    port: z.ZodDefault<z.ZodNumber>;
+    url: z.ZodOptional<z.ZodURL>;
+}, z.core.$strict>;
+export type StandaloneRedisConfigInput = z.input<typeof StandaloneRedisConfigSchema>;
+export type StandaloneRedisConfig = Omit<z.output<typeof StandaloneRedisConfigSchema>, "mode"> & {
+    mode: "standalone";
+};
+export declare const SentinelRedisConfigSchema: z.ZodObject<{
+    password: z.ZodOptional<z.ZodString>;
+    username: z.ZodOptional<z.ZodString>;
+    database: z.ZodDefault<z.ZodNumber>;
+    tls: z.ZodDefault<z.ZodBoolean>;
+    tlsOptions: z.ZodOptional<z.ZodObject<{
+        ca: z.ZodOptional<z.ZodString>;
+        cert: z.ZodOptional<z.ZodString>;
+        key: z.ZodOptional<z.ZodString>;
+        rejectUnauthorized: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strict>>;
+    maxRetries: z.ZodDefault<z.ZodNumber>;
+    retryDelay: z.ZodDefault<z.ZodNumber>;
+    connectionTimeout: z.ZodDefault<z.ZodNumber>;
+    maxFanOutConcurrency: z.ZodDefault<z.ZodNumber>;
+    maxBatchSize: z.ZodDefault<z.ZodNumber>;
+    defaultTTL: z.ZodDefault<z.ZodNumber>;
+    compressionThreshold: z.ZodDefault<z.ZodNumber>;
+    slowCommandThreshold: z.ZodDefault<z.ZodNumber>;
+    rateLimit: z.ZodDefault<z.ZodObject<{
+        limit: z.ZodDefault<z.ZodNumber>;
+        duration: z.ZodDefault<z.ZodNumber>;
+        algorithm: z.ZodDefault<z.ZodEnum<{
+            fixed: "fixed";
+            sliding: "sliding";
+        }>>;
+        namespace: z.ZodDefault<z.ZodString>;
+    }, z.core.$strip>>;
+    sessionOptions: z.ZodOptional<z.ZodCustom<Partial<SessionManagerOptions>, Partial<SessionManagerOptions>>>;
+    mode: z.ZodLiteral<"sentinel">;
+    sentinelNodes: z.ZodArray<z.ZodObject<{
+        host: z.ZodString;
+        port: z.ZodNumber;
+    }, z.core.$strict>>;
+    sentinelMasterName: z.ZodString;
+}, z.core.$strict>;
+export type SentinelRedisConfigInput = z.input<typeof SentinelRedisConfigSchema>;
+export type SentinelRedisConfig = z.output<typeof SentinelRedisConfigSchema>;
+/**
+ * Redis Cluster only supports database 0.
+ */
+export declare const ClusterRedisConfigSchema: z.ZodObject<{
+    password: z.ZodOptional<z.ZodString>;
+    username: z.ZodOptional<z.ZodString>;
+    tls: z.ZodDefault<z.ZodBoolean>;
+    tlsOptions: z.ZodOptional<z.ZodObject<{
+        ca: z.ZodOptional<z.ZodString>;
+        cert: z.ZodOptional<z.ZodString>;
+        key: z.ZodOptional<z.ZodString>;
+        rejectUnauthorized: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strict>>;
+    maxRetries: z.ZodDefault<z.ZodNumber>;
+    retryDelay: z.ZodDefault<z.ZodNumber>;
+    connectionTimeout: z.ZodDefault<z.ZodNumber>;
+    maxFanOutConcurrency: z.ZodDefault<z.ZodNumber>;
+    maxBatchSize: z.ZodDefault<z.ZodNumber>;
+    defaultTTL: z.ZodDefault<z.ZodNumber>;
+    compressionThreshold: z.ZodDefault<z.ZodNumber>;
+    slowCommandThreshold: z.ZodDefault<z.ZodNumber>;
+    rateLimit: z.ZodDefault<z.ZodObject<{
+        limit: z.ZodDefault<z.ZodNumber>;
+        duration: z.ZodDefault<z.ZodNumber>;
+        algorithm: z.ZodDefault<z.ZodEnum<{
+            fixed: "fixed";
+            sliding: "sliding";
+        }>>;
+        namespace: z.ZodDefault<z.ZodString>;
+    }, z.core.$strip>>;
+    sessionOptions: z.ZodOptional<z.ZodCustom<Partial<SessionManagerOptions>, Partial<SessionManagerOptions>>>;
+    mode: z.ZodLiteral<"cluster">;
+    clusterNodes: z.ZodArray<z.ZodObject<{
+        host: z.ZodString;
+        port: z.ZodNumber;
+    }, z.core.$strict>>;
+    database: z.ZodDefault<z.ZodLiteral<0>>;
+}, z.core.$strict>;
+export type ClusterRedisConfigInput = z.input<typeof ClusterRedisConfigSchema>;
+export type ClusterRedisConfig = z.output<typeof ClusterRedisConfigSchema>;
+/**
+ * Raw configuration union.
+ *
+ * This is intentionally a normal union rather than a discriminated union
+ * because standalone allows `mode` to be omitted.
+ */
+export declare const RedisConfigInputSchema: z.ZodUnion<readonly [z.ZodObject<{
+    password: z.ZodOptional<z.ZodString>;
+    username: z.ZodOptional<z.ZodString>;
+    database: z.ZodDefault<z.ZodNumber>;
+    tls: z.ZodDefault<z.ZodBoolean>;
+    tlsOptions: z.ZodOptional<z.ZodObject<{
+        ca: z.ZodOptional<z.ZodString>;
+        cert: z.ZodOptional<z.ZodString>;
+        key: z.ZodOptional<z.ZodString>;
+        rejectUnauthorized: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strict>>;
+    maxRetries: z.ZodDefault<z.ZodNumber>;
+    retryDelay: z.ZodDefault<z.ZodNumber>;
+    connectionTimeout: z.ZodDefault<z.ZodNumber>;
+    maxFanOutConcurrency: z.ZodDefault<z.ZodNumber>;
+    maxBatchSize: z.ZodDefault<z.ZodNumber>;
+    defaultTTL: z.ZodDefault<z.ZodNumber>;
+    compressionThreshold: z.ZodDefault<z.ZodNumber>;
+    slowCommandThreshold: z.ZodDefault<z.ZodNumber>;
+    rateLimit: z.ZodDefault<z.ZodObject<{
+        limit: z.ZodDefault<z.ZodNumber>;
+        duration: z.ZodDefault<z.ZodNumber>;
+        algorithm: z.ZodDefault<z.ZodEnum<{
+            fixed: "fixed";
+            sliding: "sliding";
+        }>>;
+        namespace: z.ZodDefault<z.ZodString>;
+    }, z.core.$strip>>;
+    sessionOptions: z.ZodOptional<z.ZodCustom<Partial<SessionManagerOptions>, Partial<SessionManagerOptions>>>;
+    mode: z.ZodOptional<z.ZodLiteral<"standalone">>;
+    host: z.ZodDefault<z.ZodString>;
+    port: z.ZodDefault<z.ZodNumber>;
+    url: z.ZodOptional<z.ZodURL>;
+}, z.core.$strict>, z.ZodObject<{
+    password: z.ZodOptional<z.ZodString>;
+    username: z.ZodOptional<z.ZodString>;
+    database: z.ZodDefault<z.ZodNumber>;
+    tls: z.ZodDefault<z.ZodBoolean>;
+    tlsOptions: z.ZodOptional<z.ZodObject<{
+        ca: z.ZodOptional<z.ZodString>;
+        cert: z.ZodOptional<z.ZodString>;
+        key: z.ZodOptional<z.ZodString>;
+        rejectUnauthorized: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strict>>;
+    maxRetries: z.ZodDefault<z.ZodNumber>;
+    retryDelay: z.ZodDefault<z.ZodNumber>;
+    connectionTimeout: z.ZodDefault<z.ZodNumber>;
+    maxFanOutConcurrency: z.ZodDefault<z.ZodNumber>;
+    maxBatchSize: z.ZodDefault<z.ZodNumber>;
+    defaultTTL: z.ZodDefault<z.ZodNumber>;
+    compressionThreshold: z.ZodDefault<z.ZodNumber>;
+    slowCommandThreshold: z.ZodDefault<z.ZodNumber>;
+    rateLimit: z.ZodDefault<z.ZodObject<{
+        limit: z.ZodDefault<z.ZodNumber>;
+        duration: z.ZodDefault<z.ZodNumber>;
+        algorithm: z.ZodDefault<z.ZodEnum<{
+            fixed: "fixed";
+            sliding: "sliding";
+        }>>;
+        namespace: z.ZodDefault<z.ZodString>;
+    }, z.core.$strip>>;
+    sessionOptions: z.ZodOptional<z.ZodCustom<Partial<SessionManagerOptions>, Partial<SessionManagerOptions>>>;
+    mode: z.ZodLiteral<"sentinel">;
+    sentinelNodes: z.ZodArray<z.ZodObject<{
+        host: z.ZodString;
+        port: z.ZodNumber;
+    }, z.core.$strict>>;
+    sentinelMasterName: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    password: z.ZodOptional<z.ZodString>;
+    username: z.ZodOptional<z.ZodString>;
+    tls: z.ZodDefault<z.ZodBoolean>;
+    tlsOptions: z.ZodOptional<z.ZodObject<{
+        ca: z.ZodOptional<z.ZodString>;
+        cert: z.ZodOptional<z.ZodString>;
+        key: z.ZodOptional<z.ZodString>;
+        rejectUnauthorized: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strict>>;
+    maxRetries: z.ZodDefault<z.ZodNumber>;
+    retryDelay: z.ZodDefault<z.ZodNumber>;
+    connectionTimeout: z.ZodDefault<z.ZodNumber>;
+    maxFanOutConcurrency: z.ZodDefault<z.ZodNumber>;
+    maxBatchSize: z.ZodDefault<z.ZodNumber>;
+    defaultTTL: z.ZodDefault<z.ZodNumber>;
+    compressionThreshold: z.ZodDefault<z.ZodNumber>;
+    slowCommandThreshold: z.ZodDefault<z.ZodNumber>;
+    rateLimit: z.ZodDefault<z.ZodObject<{
+        limit: z.ZodDefault<z.ZodNumber>;
+        duration: z.ZodDefault<z.ZodNumber>;
+        algorithm: z.ZodDefault<z.ZodEnum<{
+            fixed: "fixed";
+            sliding: "sliding";
+        }>>;
+        namespace: z.ZodDefault<z.ZodString>;
+    }, z.core.$strip>>;
+    sessionOptions: z.ZodOptional<z.ZodCustom<Partial<SessionManagerOptions>, Partial<SessionManagerOptions>>>;
+    mode: z.ZodLiteral<"cluster">;
+    clusterNodes: z.ZodArray<z.ZodObject<{
+        host: z.ZodString;
+        port: z.ZodNumber;
+    }, z.core.$strict>>;
+    database: z.ZodDefault<z.ZodLiteral<0>>;
+}, z.core.$strict>]>;
+/**
+ * User-facing configuration.
+ *
+ * This represents what callers are allowed to provide.
+ */
+export type RedisConfigInput = z.input<typeof RedisConfigInputSchema>;
+/**
+ * Normalized configuration.
+ *
+ * After parsing:
+ *
+ * - standalone.mode === "standalone"
+ * - sentinel.mode === "sentinel"
+ * - cluster.mode === "cluster"
+ * - defaults have been materialized
+ */
+export declare const RedisConfigSchema: z.ZodPipe<z.ZodUnion<readonly [z.ZodObject<{
+    password: z.ZodOptional<z.ZodString>;
+    username: z.ZodOptional<z.ZodString>;
+    database: z.ZodDefault<z.ZodNumber>;
+    tls: z.ZodDefault<z.ZodBoolean>;
+    tlsOptions: z.ZodOptional<z.ZodObject<{
+        ca: z.ZodOptional<z.ZodString>;
+        cert: z.ZodOptional<z.ZodString>;
+        key: z.ZodOptional<z.ZodString>;
+        rejectUnauthorized: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strict>>;
+    maxRetries: z.ZodDefault<z.ZodNumber>;
+    retryDelay: z.ZodDefault<z.ZodNumber>;
+    connectionTimeout: z.ZodDefault<z.ZodNumber>;
+    maxFanOutConcurrency: z.ZodDefault<z.ZodNumber>;
+    maxBatchSize: z.ZodDefault<z.ZodNumber>;
+    defaultTTL: z.ZodDefault<z.ZodNumber>;
+    compressionThreshold: z.ZodDefault<z.ZodNumber>;
+    slowCommandThreshold: z.ZodDefault<z.ZodNumber>;
+    rateLimit: z.ZodDefault<z.ZodObject<{
+        limit: z.ZodDefault<z.ZodNumber>;
+        duration: z.ZodDefault<z.ZodNumber>;
+        algorithm: z.ZodDefault<z.ZodEnum<{
+            fixed: "fixed";
+            sliding: "sliding";
+        }>>;
+        namespace: z.ZodDefault<z.ZodString>;
+    }, z.core.$strip>>;
+    sessionOptions: z.ZodOptional<z.ZodCustom<Partial<SessionManagerOptions>, Partial<SessionManagerOptions>>>;
+    mode: z.ZodOptional<z.ZodLiteral<"standalone">>;
+    host: z.ZodDefault<z.ZodString>;
+    port: z.ZodDefault<z.ZodNumber>;
+    url: z.ZodOptional<z.ZodURL>;
+}, z.core.$strict>, z.ZodObject<{
+    password: z.ZodOptional<z.ZodString>;
+    username: z.ZodOptional<z.ZodString>;
+    database: z.ZodDefault<z.ZodNumber>;
+    tls: z.ZodDefault<z.ZodBoolean>;
+    tlsOptions: z.ZodOptional<z.ZodObject<{
+        ca: z.ZodOptional<z.ZodString>;
+        cert: z.ZodOptional<z.ZodString>;
+        key: z.ZodOptional<z.ZodString>;
+        rejectUnauthorized: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strict>>;
+    maxRetries: z.ZodDefault<z.ZodNumber>;
+    retryDelay: z.ZodDefault<z.ZodNumber>;
+    connectionTimeout: z.ZodDefault<z.ZodNumber>;
+    maxFanOutConcurrency: z.ZodDefault<z.ZodNumber>;
+    maxBatchSize: z.ZodDefault<z.ZodNumber>;
+    defaultTTL: z.ZodDefault<z.ZodNumber>;
+    compressionThreshold: z.ZodDefault<z.ZodNumber>;
+    slowCommandThreshold: z.ZodDefault<z.ZodNumber>;
+    rateLimit: z.ZodDefault<z.ZodObject<{
+        limit: z.ZodDefault<z.ZodNumber>;
+        duration: z.ZodDefault<z.ZodNumber>;
+        algorithm: z.ZodDefault<z.ZodEnum<{
+            fixed: "fixed";
+            sliding: "sliding";
+        }>>;
+        namespace: z.ZodDefault<z.ZodString>;
+    }, z.core.$strip>>;
+    sessionOptions: z.ZodOptional<z.ZodCustom<Partial<SessionManagerOptions>, Partial<SessionManagerOptions>>>;
+    mode: z.ZodLiteral<"sentinel">;
+    sentinelNodes: z.ZodArray<z.ZodObject<{
+        host: z.ZodString;
+        port: z.ZodNumber;
+    }, z.core.$strict>>;
+    sentinelMasterName: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    password: z.ZodOptional<z.ZodString>;
+    username: z.ZodOptional<z.ZodString>;
+    tls: z.ZodDefault<z.ZodBoolean>;
+    tlsOptions: z.ZodOptional<z.ZodObject<{
+        ca: z.ZodOptional<z.ZodString>;
+        cert: z.ZodOptional<z.ZodString>;
+        key: z.ZodOptional<z.ZodString>;
+        rejectUnauthorized: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strict>>;
+    maxRetries: z.ZodDefault<z.ZodNumber>;
+    retryDelay: z.ZodDefault<z.ZodNumber>;
+    connectionTimeout: z.ZodDefault<z.ZodNumber>;
+    maxFanOutConcurrency: z.ZodDefault<z.ZodNumber>;
+    maxBatchSize: z.ZodDefault<z.ZodNumber>;
+    defaultTTL: z.ZodDefault<z.ZodNumber>;
+    compressionThreshold: z.ZodDefault<z.ZodNumber>;
+    slowCommandThreshold: z.ZodDefault<z.ZodNumber>;
+    rateLimit: z.ZodDefault<z.ZodObject<{
+        limit: z.ZodDefault<z.ZodNumber>;
+        duration: z.ZodDefault<z.ZodNumber>;
+        algorithm: z.ZodDefault<z.ZodEnum<{
+            fixed: "fixed";
+            sliding: "sliding";
+        }>>;
+        namespace: z.ZodDefault<z.ZodString>;
+    }, z.core.$strip>>;
+    sessionOptions: z.ZodOptional<z.ZodCustom<Partial<SessionManagerOptions>, Partial<SessionManagerOptions>>>;
+    mode: z.ZodLiteral<"cluster">;
+    clusterNodes: z.ZodArray<z.ZodObject<{
+        host: z.ZodString;
+        port: z.ZodNumber;
+    }, z.core.$strict>>;
+    database: z.ZodDefault<z.ZodLiteral<0>>;
+}, z.core.$strict>]>, z.ZodTransform<{
+    password?: string | undefined;
+    username?: string | undefined;
+    database: number;
+    tls: boolean;
+    tlsOptions?: {
+        ca?: string | undefined;
+        cert?: string | undefined;
+        key?: string | undefined;
+        rejectUnauthorized: boolean;
+    } | undefined;
+    maxRetries: number;
+    retryDelay: number;
+    connectionTimeout: number;
+    maxFanOutConcurrency: number;
+    maxBatchSize: number;
+    defaultTTL: number;
+    compressionThreshold: number;
+    slowCommandThreshold: number;
+    rateLimit: {
+        limit: number;
+        duration: number;
+        algorithm: "fixed" | "sliding";
+        namespace: string;
+    };
+    sessionOptions?: Partial<SessionManagerOptions> | undefined;
+    mode: "sentinel";
+    sentinelNodes: {
+        host: string;
+        port: number;
+    }[];
+    sentinelMasterName: string;
+} | {
+    password?: string | undefined;
+    username?: string | undefined;
+    tls: boolean;
+    tlsOptions?: {
+        ca?: string | undefined;
+        cert?: string | undefined;
+        key?: string | undefined;
+        rejectUnauthorized: boolean;
+    } | undefined;
+    maxRetries: number;
+    retryDelay: number;
+    connectionTimeout: number;
+    maxFanOutConcurrency: number;
+    maxBatchSize: number;
+    defaultTTL: number;
+    compressionThreshold: number;
+    slowCommandThreshold: number;
+    rateLimit: {
+        limit: number;
+        duration: number;
+        algorithm: "fixed" | "sliding";
+        namespace: string;
+    };
+    sessionOptions?: Partial<SessionManagerOptions> | undefined;
+    mode: "cluster";
+    clusterNodes: {
+        host: string;
+        port: number;
+    }[];
+    database: 0;
+} | {
+    password?: string | undefined;
+    username?: string | undefined;
+    database: number;
+    tls: boolean;
+    tlsOptions?: {
+        ca?: string | undefined;
+        cert?: string | undefined;
+        key?: string | undefined;
+        rejectUnauthorized: boolean;
+    } | undefined;
+    maxRetries: number;
+    retryDelay: number;
+    connectionTimeout: number;
+    maxFanOutConcurrency: number;
+    maxBatchSize: number;
+    defaultTTL: number;
+    compressionThreshold: number;
+    slowCommandThreshold: number;
+    rateLimit: {
+        limit: number;
+        duration: number;
+        algorithm: "fixed" | "sliding";
+        namespace: string;
+    };
+    sessionOptions?: Partial<SessionManagerOptions> | undefined;
+    host: string;
+    port: number;
+    url?: string | undefined;
+    mode: "standalone";
+}, {
+    password?: string | undefined;
+    username?: string | undefined;
+    database: number;
+    tls: boolean;
+    tlsOptions?: {
+        ca?: string | undefined;
+        cert?: string | undefined;
+        key?: string | undefined;
+        rejectUnauthorized: boolean;
+    } | undefined;
+    maxRetries: number;
+    retryDelay: number;
+    connectionTimeout: number;
+    maxFanOutConcurrency: number;
+    maxBatchSize: number;
+    defaultTTL: number;
+    compressionThreshold: number;
+    slowCommandThreshold: number;
+    rateLimit: {
+        limit: number;
+        duration: number;
+        algorithm: "fixed" | "sliding";
+        namespace: string;
+    };
+    sessionOptions?: Partial<SessionManagerOptions> | undefined;
+    mode?: "standalone" | undefined;
+    host: string;
+    port: number;
+    url?: string | undefined;
+} | {
+    password?: string | undefined;
+    username?: string | undefined;
+    database: number;
+    tls: boolean;
+    tlsOptions?: {
+        ca?: string | undefined;
+        cert?: string | undefined;
+        key?: string | undefined;
+        rejectUnauthorized: boolean;
+    } | undefined;
+    maxRetries: number;
+    retryDelay: number;
+    connectionTimeout: number;
+    maxFanOutConcurrency: number;
+    maxBatchSize: number;
+    defaultTTL: number;
+    compressionThreshold: number;
+    slowCommandThreshold: number;
+    rateLimit: {
+        limit: number;
+        duration: number;
+        algorithm: "fixed" | "sliding";
+        namespace: string;
+    };
+    sessionOptions?: Partial<SessionManagerOptions> | undefined;
+    mode: "sentinel";
+    sentinelNodes: {
+        host: string;
+        port: number;
+    }[];
+    sentinelMasterName: string;
+} | {
+    password?: string | undefined;
+    username?: string | undefined;
+    tls: boolean;
+    tlsOptions?: {
+        ca?: string | undefined;
+        cert?: string | undefined;
+        key?: string | undefined;
+        rejectUnauthorized: boolean;
+    } | undefined;
+    maxRetries: number;
+    retryDelay: number;
+    connectionTimeout: number;
+    maxFanOutConcurrency: number;
+    maxBatchSize: number;
+    defaultTTL: number;
+    compressionThreshold: number;
+    slowCommandThreshold: number;
+    rateLimit: {
+        limit: number;
+        duration: number;
+        algorithm: "fixed" | "sliding";
+        namespace: string;
+    };
+    sessionOptions?: Partial<SessionManagerOptions> | undefined;
+    mode: "cluster";
+    clusterNodes: {
+        host: string;
+        port: number;
+    }[];
+    database: 0;
+}>>;
+export type RedisConfig = z.output<typeof RedisConfigSchema>;
+export type RedisConfigForMode<M extends RedisMode> = M extends "cluster" ? ClusterRedisConfig : M extends "sentinel" ? SentinelRedisConfig : StandaloneRedisConfig;
+export type CacheOptions = {
+    /**
+     * TTL in seconds.
+     *
+     * Falls back to the cache's `defaultTTL`.
+     */
+    ttl?: number;
+    /**
+     * Enable/disable compression.
+     *
+     * Default: true.
+     */
+    compress?: boolean;
+    /**
+     * Namespace prefix.
+     */
+    namespace?: string;
+};
+export type CacheStats = {
+    namespace: string;
+    connectionStatus: ConnectionStatus;
+};
+export type LockOptions = {
+    /**
+     * Lock TTL in milliseconds.
+     */
+    ttl?: number;
+    /**
+     * Number of acquisition attempts.
+     */
+    retryCount?: number;
+    /**
+     * Base retry delay in milliseconds.
+     */
+    retryDelay?: number;
+};
+export type DistributedLockOptions = LockOptions;
+export type LockInfo = {
+    locked: boolean;
+    ttl?: number;
+    lockId?: string;
+};
+export type HealthStatus = {
+    healthy: boolean;
+    status: "healthy" | "degraded" | "unhealthy";
+    latency: number;
+    timestamp: Date;
+    details: {
+        ping: boolean;
+        connections?: number;
+        memory?: string;
+    };
+};
+export type PubSubMessage<T = unknown> = {
+    channel: string;
+    message: T;
+};
+export type PubSubStats = {
+    subscriptions: number;
+    patternSubscriptions: number;
+    connected: boolean;
+};
+export type PubSubEventMap = {
+    message: {
+        channel: string;
+        message: string;
+    };
+    pmessage: {
+        pattern: string;
+        channel: string;
+        message: string;
+    };
+    subscribe: {
+        channel: string;
+        count: number;
+    };
+    unsubscribe: {
+        channel: string;
+        count: number;
+    };
+    psubscribe: {
+        pattern: string;
+        count: number;
+    };
+    punsubscribe: {
+        pattern: string;
+        count: number;
+    };
+    error: Error;
+};
+export type ClusterSlotNode = {
+    host: string;
+    port: number;
+    nodeId?: string;
+};
+export type ClusterSlotRange = {
+    start: number;
+    end: number;
+    master: ClusterSlotNode;
+    replicas: ClusterSlotNode[];
+};
+export type ClusterInfo = {
+    mode: RedisMode;
+    status: "ready" | "connecting" | "error";
+    nodeCount?: number;
+    slotCount?: number;
+    nodes?: Array<{
+        host: string;
+        port: number;
+        role?: string;
+    }>;
+    host?: string;
+    port?: number;
+    error?: string;
+};
+export type ConnectionState = "disconnected" | "connecting" | "connected" | "error" | "closed";
+export type ConnectionStatus = {
+    state: ConnectionState;
+    connected: boolean;
+    ready: boolean;
+    lastError?: Error;
+    reconnectAttempts: number;
+    uptime: number;
+};
+export type RedisEventMap = {
+    connect: void;
+    ready: void;
+    close: void;
+    reconnecting: {
+        attempt: number;
+        delay: number;
+    };
+    error: Error;
+    end: void;
+    status: ConnectionStatus;
+    nodeAdded: {
+        node: RedisType;
+    };
+    nodeRemoved: {
+        node: RedisType;
+    };
+    nodeError: {
+        node: RedisType;
+        error: Error;
+    };
+    moved: {
+        key: string;
+        target: string;
+    };
+    ask: {
+        key: string;
+        target: string;
+    };
+};
+export type Redis = RedisType;