@dexto/storage 1.6.0

package/dist/cache/memory-cache-store.js

@@ -0,0 +1,82 @@
+import { StorageError } from "@dexto/core";
+class MemoryCacheStore {
+  data = /* @__PURE__ */ new Map();
+  ttls = /* @__PURE__ */ new Map();
+  connected = false;
+  async connect() {
+    if (this.connected) return;
+    this.connected = true;
+  }
+  async disconnect() {
+    this.connected = false;
+    this.data.clear();
+    this.ttls.clear();
+  }
+  isConnected() {
+    return this.connected;
+  }
+  getStoreType() {
+    return "in-memory";
+  }
+  async get(key) {
+    this.checkConnection();
+    try {
+      this.checkTTL(key);
+      return this.data.get(key);
+    } catch (error) {
+      throw StorageError.readFailed(
+        "get",
+        error instanceof Error ? error.message : String(error),
+        { key }
+      );
+    }
+  }
+  async set(key, value, ttlSeconds) {
+    this.checkConnection();
+    try {
+      this.data.set(key, value);
+      if (ttlSeconds) {
+        this.ttls.set(key, Date.now() + ttlSeconds * 1e3);
+      } else {
+        this.ttls.delete(key);
+      }
+    } catch (error) {
+      throw StorageError.writeFailed(
+        "set",
+        error instanceof Error ? error.message : String(error),
+        { key }
+      );
+    }
+  }
+  async delete(key) {
+    this.checkConnection();
+    this.data.delete(key);
+    this.ttls.delete(key);
+  }
+  // Helper methods
+  checkConnection() {
+    if (!this.connected) {
+      throw StorageError.notConnected("MemoryCacheStore");
+    }
+  }
+  checkTTL(key) {
+    const expiry = this.ttls.get(key);
+    if (expiry && Date.now() > expiry) {
+      this.data.delete(key);
+      this.ttls.delete(key);
+    }
+  }
+  // Development helpers
+  async clear() {
+    this.data.clear();
+    this.ttls.clear();
+  }
+  async dump() {
+    return {
+      data: Object.fromEntries(this.data.entries())
+    };
+  }
+}
+export {
+  MemoryCacheStore
+};

package/dist/cache/redis-store.cjs

@@ -0,0 +1,176 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var redis_store_exports = {};
+__export(redis_store_exports, {
+  RedisStore: () => RedisStore
+});
+module.exports = __toCommonJS(redis_store_exports);
+var import_ioredis = require("ioredis");
+var import_core = require("@dexto/core");
+class RedisStore {
+  constructor(config, logger) {
+    this.config = config;
+    this.logger = logger.createChild(import_core.DextoLogComponent.STORAGE);
+  }
+  redis = null;
+  connected = false;
+  logger;
+  async connect() {
+    if (this.connected) return;
+    this.redis = new import_ioredis.Redis({
+      ...this.config.host && { host: this.config.host },
+      ...this.config.port && { port: this.config.port },
+      ...this.config.password && { password: this.config.password },
+      db: this.config.database || 0,
+      family: 4,
+      // IPv4 by default
+      ...this.config.connectionTimeoutMillis && {
+        connectTimeout: this.config.connectionTimeoutMillis
+      },
+      ...this.config.connectionTimeoutMillis && {
+        commandTimeout: this.config.connectionTimeoutMillis
+      },
+      maxRetriesPerRequest: 3,
+      lazyConnect: true,
+      ...this.config.options
+    });
+    this.redis.on("error", (error) => {
+      if (error instanceof Error) {
+        this.logger.trackException(error, { operation: "redis.connection_error" });
+        return;
+      }
+      this.logger.error("Redis connection error", { error: String(error) });
+    });
+    this.redis.on("connect", () => {
+      this.connected = true;
+    });
+    this.redis.on("close", () => {
+      this.connected = false;
+    });
+    await this.redis.connect();
+  }
+  async disconnect() {
+    if (this.redis) {
+      await this.redis.quit();
+      this.redis = null;
+    }
+    this.connected = false;
+  }
+  isConnected() {
+    return this.connected && this.redis?.status === "ready";
+  }
+  getStoreType() {
+    return "redis";
+  }
+  // Core operations
+  async get(key) {
+    this.checkConnection();
+    try {
+      const value = await this.redis.get(key);
+      return value ? JSON.parse(value) : void 0;
+    } catch (error) {
+      throw import_core.StorageError.readFailed(
+        "get",
+        error instanceof Error ? error.message : String(error),
+        { key }
+      );
+    }
+  }
+  async set(key, value, ttlSeconds) {
+    this.checkConnection();
+    try {
+      const serialized = JSON.stringify(value);
+      if (ttlSeconds) {
+        await this.redis.setex(key, ttlSeconds, serialized);
+      } else {
+        await this.redis.set(key, serialized);
+      }
+    } catch (error) {
+      throw import_core.StorageError.writeFailed(
+        "set",
+        error instanceof Error ? error.message : String(error),
+        { key }
+      );
+    }
+  }
+  async delete(key) {
+    this.checkConnection();
+    try {
+      await this.redis.del(key);
+    } catch (error) {
+      throw import_core.StorageError.deleteFailed(
+        "delete",
+        error instanceof Error ? error.message : String(error),
+        { key }
+      );
+    }
+  }
+  // Redis-specific optimizations
+  async mget(keys) {
+    this.checkConnection();
+    if (keys.length === 0) return [];
+    const values = await this.redis.mget(...keys);
+    return values.map((value) => value ? JSON.parse(value) : void 0);
+  }
+  async mset(entries) {
+    this.checkConnection();
+    if (entries.length === 0) return;
+    const pipeline = this.redis.pipeline();
+    for (const [key, value] of entries) {
+      pipeline.set(key, JSON.stringify(value));
+    }
+    await pipeline.exec();
+  }
+  async exists(key) {
+    this.checkConnection();
+    const result = await this.redis.exists(key);
+    return result === 1;
+  }
+  async expire(key, ttlSeconds) {
+    this.checkConnection();
+    await this.redis.expire(key, ttlSeconds);
+  }
+  // Cache-specific operations
+  async increment(key, by = 1) {
+    this.checkConnection();
+    return await this.redis.incrby(key, by);
+  }
+  async decrement(key, by = 1) {
+    this.checkConnection();
+    return await this.redis.decrby(key, by);
+  }
+  checkConnection() {
+    if (!this.connected || !this.redis || this.redis.status !== "ready") {
+      throw import_core.StorageError.notConnected("RedisStore");
+    }
+  }
+  // Maintenance operations
+  async flushdb() {
+    this.checkConnection();
+    await this.redis.flushdb();
+  }
+  async info() {
+    this.checkConnection();
+    return await this.redis.info();
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RedisStore
+});

package/dist/cache/redis-store.d.cts

@@ -0,0 +1,34 @@
+import { Cache, Logger } from '@dexto/core';
+import { RedisCacheConfig } from './schemas.cjs';
+import 'zod';
+
+/**
+ * Redis cache store for production cache operations.
+ * Implements the Cache interface with connection pooling and optimizations.
+ * EXPERIMENTAL - NOT FULLY TESTED YET
+ */
+declare class RedisStore implements Cache {
+    private config;
+    private redis;
+    private connected;
+    private logger;
+    constructor(config: RedisCacheConfig, logger: Logger);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    getStoreType(): string;
+    get<T>(key: string): Promise<T | undefined>;
+    set<T>(key: string, value: T, ttlSeconds?: number): Promise<void>;
+    delete(key: string): Promise<void>;
+    mget<T>(keys: string[]): Promise<(T | undefined)[]>;
+    mset<T>(entries: [string, T][]): Promise<void>;
+    exists(key: string): Promise<boolean>;
+    expire(key: string, ttlSeconds: number): Promise<void>;
+    increment(key: string, by?: number): Promise<number>;
+    decrement(key: string, by?: number): Promise<number>;
+    private checkConnection;
+    flushdb(): Promise<void>;
+    info(): Promise<string>;
+}
+
+export { RedisStore };

package/dist/cache/redis-store.d.ts

@@ -0,0 +1,32 @@
+import type { Cache } from './types.js';
+import type { RedisCacheConfig } from './schemas.js';
+import type { Logger } from '@dexto/core';
+/**
+ * Redis cache store for production cache operations.
+ * Implements the Cache interface with connection pooling and optimizations.
+ * EXPERIMENTAL - NOT FULLY TESTED YET
+ */
+export declare class RedisStore implements Cache {
+    private config;
+    private redis;
+    private connected;
+    private logger;
+    constructor(config: RedisCacheConfig, logger: Logger);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    getStoreType(): string;
+    get<T>(key: string): Promise<T | undefined>;
+    set<T>(key: string, value: T, ttlSeconds?: number): Promise<void>;
+    delete(key: string): Promise<void>;
+    mget<T>(keys: string[]): Promise<(T | undefined)[]>;
+    mset<T>(entries: [string, T][]): Promise<void>;
+    exists(key: string): Promise<boolean>;
+    expire(key: string, ttlSeconds: number): Promise<void>;
+    increment(key: string, by?: number): Promise<number>;
+    decrement(key: string, by?: number): Promise<number>;
+    private checkConnection;
+    flushdb(): Promise<void>;
+    info(): Promise<string>;
+}
+//# sourceMappingURL=redis-store.d.ts.map

package/dist/cache/redis-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"redis-store.d.ts","sourceRoot":"","sources":["../../src/cache/redis-store.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACxC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AACrD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAG1C;;;;GAIG;AACH,qBAAa,UAAW,YAAW,KAAK;IAMhC,OAAO,CAAC,MAAM;IALlB,OAAO,CAAC,KAAK,CAAsB;IACnC,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,MAAM,CAAS;gBAGX,MAAM,EAAE,gBAAgB,EAChC,MAAM,EAAE,MAAM;IAKZ,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAwCxB,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAQjC,WAAW,IAAI,OAAO;IAItB,YAAY,IAAI,MAAM;IAKhB,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,GAAG,SAAS,CAAC;IAc3C,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,EAAE,UAAU,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAmBjE,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAclC,IAAI,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC,EAAE,CAAC;IAQnD,IAAI,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,MAAM,EAAE,CAAC,CAAC,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAW9C,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAMrC,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAMtD,SAAS,CAAC,GAAG,EAAE,MAAM,EAAE,EAAE,GAAE,MAAU,GAAG,OAAO,CAAC,MAAM,CAAC;IAKvD,SAAS,CAAC,GAAG,EAAE,MAAM,EAAE,EAAE,GAAE,MAAU,GAAG,OAAO,CAAC,MAAM,CAAC;IAK7D,OAAO,CAAC,eAAe;IAOjB,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAKxB,IAAI,IAAI,OAAO,CAAC,MAAM,CAAC;CAIhC"}

package/dist/cache/redis-store.js

@@ -0,0 +1,152 @@
+import { Redis } from "ioredis";
+import { DextoLogComponent, StorageError } from "@dexto/core";
+class RedisStore {
+  constructor(config, logger) {
+    this.config = config;
+    this.logger = logger.createChild(DextoLogComponent.STORAGE);
+  }
+  redis = null;
+  connected = false;
+  logger;
+  async connect() {
+    if (this.connected) return;
+    this.redis = new Redis({
+      ...this.config.host && { host: this.config.host },
+      ...this.config.port && { port: this.config.port },
+      ...this.config.password && { password: this.config.password },
+      db: this.config.database || 0,
+      family: 4,
+      // IPv4 by default
+      ...this.config.connectionTimeoutMillis && {
+        connectTimeout: this.config.connectionTimeoutMillis
+      },
+      ...this.config.connectionTimeoutMillis && {
+        commandTimeout: this.config.connectionTimeoutMillis
+      },
+      maxRetriesPerRequest: 3,
+      lazyConnect: true,
+      ...this.config.options
+    });
+    this.redis.on("error", (error) => {
+      if (error instanceof Error) {
+        this.logger.trackException(error, { operation: "redis.connection_error" });
+        return;
+      }
+      this.logger.error("Redis connection error", { error: String(error) });
+    });
+    this.redis.on("connect", () => {
+      this.connected = true;
+    });
+    this.redis.on("close", () => {
+      this.connected = false;
+    });
+    await this.redis.connect();
+  }
+  async disconnect() {
+    if (this.redis) {
+      await this.redis.quit();
+      this.redis = null;
+    }
+    this.connected = false;
+  }
+  isConnected() {
+    return this.connected && this.redis?.status === "ready";
+  }
+  getStoreType() {
+    return "redis";
+  }
+  // Core operations
+  async get(key) {
+    this.checkConnection();
+    try {
+      const value = await this.redis.get(key);
+      return value ? JSON.parse(value) : void 0;
+    } catch (error) {
+      throw StorageError.readFailed(
+        "get",
+        error instanceof Error ? error.message : String(error),
+        { key }
+      );
+    }
+  }
+  async set(key, value, ttlSeconds) {
+    this.checkConnection();
+    try {
+      const serialized = JSON.stringify(value);
+      if (ttlSeconds) {
+        await this.redis.setex(key, ttlSeconds, serialized);
+      } else {
+        await this.redis.set(key, serialized);
+      }
+    } catch (error) {
+      throw StorageError.writeFailed(
+        "set",
+        error instanceof Error ? error.message : String(error),
+        { key }
+      );
+    }
+  }
+  async delete(key) {
+    this.checkConnection();
+    try {
+      await this.redis.del(key);
+    } catch (error) {
+      throw StorageError.deleteFailed(
+        "delete",
+        error instanceof Error ? error.message : String(error),
+        { key }
+      );
+    }
+  }
+  // Redis-specific optimizations
+  async mget(keys) {
+    this.checkConnection();
+    if (keys.length === 0) return [];
+    const values = await this.redis.mget(...keys);
+    return values.map((value) => value ? JSON.parse(value) : void 0);
+  }
+  async mset(entries) {
+    this.checkConnection();
+    if (entries.length === 0) return;
+    const pipeline = this.redis.pipeline();
+    for (const [key, value] of entries) {
+      pipeline.set(key, JSON.stringify(value));
+    }
+    await pipeline.exec();
+  }
+  async exists(key) {
+    this.checkConnection();
+    const result = await this.redis.exists(key);
+    return result === 1;
+  }
+  async expire(key, ttlSeconds) {
+    this.checkConnection();
+    await this.redis.expire(key, ttlSeconds);
+  }
+  // Cache-specific operations
+  async increment(key, by = 1) {
+    this.checkConnection();
+    return await this.redis.incrby(key, by);
+  }
+  async decrement(key, by = 1) {
+    this.checkConnection();
+    return await this.redis.decrby(key, by);
+  }
+  checkConnection() {
+    if (!this.connected || !this.redis || this.redis.status !== "ready") {
+      throw StorageError.notConnected("RedisStore");
+    }
+  }
+  // Maintenance operations
+  async flushdb() {
+    this.checkConnection();
+    await this.redis.flushdb();
+  }
+  async info() {
+    this.checkConnection();
+    return await this.redis.info();
+  }
+}
+export {
+  RedisStore
+};

package/dist/cache/schemas.cjs

@@ -0,0 +1,70 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var schemas_exports = {};
+__export(schemas_exports, {
+  CACHE_TYPES: () => CACHE_TYPES,
+  CacheConfigSchema: () => CacheConfigSchema,
+  InMemoryCacheSchema: () => InMemoryCacheSchema,
+  RedisCacheSchema: () => RedisCacheSchema
+});
+module.exports = __toCommonJS(schemas_exports);
+var import_zod = require("zod");
+var import_core = require("@dexto/core");
+const CACHE_TYPES = ["in-memory", "redis"];
+const BaseCacheSchema = import_zod.z.object({
+  maxConnections: import_zod.z.number().int().positive().optional().describe("Maximum connections"),
+  idleTimeoutMillis: import_zod.z.number().int().positive().optional().describe("Idle timeout in milliseconds"),
+  connectionTimeoutMillis: import_zod.z.number().int().positive().optional().describe("Connection timeout in milliseconds"),
+  options: import_zod.z.record(import_zod.z.unknown()).optional().describe("Backend-specific options")
+});
+const InMemoryCacheSchema = BaseCacheSchema.extend({
+  type: import_zod.z.literal("in-memory")
+  // In-memory cache doesn't need connection options, but inherits pool options for consistency
+}).strict();
+const RedisCacheSchema = BaseCacheSchema.extend({
+  type: import_zod.z.literal("redis"),
+  url: (0, import_core.EnvExpandedString)().optional().describe("Redis connection URL (redis://...)"),
+  host: import_zod.z.string().optional().describe("Redis host"),
+  port: import_zod.z.number().int().positive().optional().describe("Redis port"),
+  password: import_zod.z.string().optional().describe("Redis password"),
+  database: import_zod.z.number().int().nonnegative().optional().describe("Redis database number")
+}).strict().superRefine((data, ctx) => {
+  if (!data.url && !data.host) {
+    ctx.addIssue({
+      code: import_zod.z.ZodIssueCode.custom,
+      message: "Redis cache requires either 'url' or 'host' to be specified",
+      path: ["url"],
+      params: {
+        code: import_core.StorageErrorCode.CONNECTION_CONFIG_MISSING,
+        scope: import_core.ErrorScope.STORAGE,
+        type: import_core.ErrorType.USER
+      }
+    });
+  }
+});
+const CacheConfigSchema = import_zod.z.object({
+  type: import_zod.z.string().describe("Cache backend type identifier")
+}).passthrough().describe("Cache configuration (validated by image factory)");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CACHE_TYPES,
+  CacheConfigSchema,
+  InMemoryCacheSchema,
+  RedisCacheSchema
+});

package/dist/cache/schemas.d.cts

@@ -0,0 +1,93 @@
+import { z } from 'zod';
+
+declare const CACHE_TYPES: readonly ["in-memory", "redis"];
+type CacheType = (typeof CACHE_TYPES)[number];
+declare const InMemoryCacheSchema: z.ZodObject<{
+    maxConnections: z.ZodOptional<z.ZodNumber>;
+    idleTimeoutMillis: z.ZodOptional<z.ZodNumber>;
+    connectionTimeoutMillis: z.ZodOptional<z.ZodNumber>;
+    options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+} & {
+    type: z.ZodLiteral<"in-memory">;
+}, "strict", z.ZodTypeAny, {
+    type: "in-memory";
+    maxConnections?: number | undefined;
+    idleTimeoutMillis?: number | undefined;
+    connectionTimeoutMillis?: number | undefined;
+    options?: Record<string, unknown> | undefined;
+}, {
+    type: "in-memory";
+    maxConnections?: number | undefined;
+    idleTimeoutMillis?: number | undefined;
+    connectionTimeoutMillis?: number | undefined;
+    options?: Record<string, unknown> | undefined;
+}>;
+type InMemoryCacheConfig = z.output<typeof InMemoryCacheSchema>;
+declare const RedisCacheSchema: z.ZodEffects<z.ZodObject<{
+    maxConnections: z.ZodOptional<z.ZodNumber>;
+    idleTimeoutMillis: z.ZodOptional<z.ZodNumber>;
+    connectionTimeoutMillis: z.ZodOptional<z.ZodNumber>;
+    options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+} & {
+    type: z.ZodLiteral<"redis">;
+    url: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+    host: z.ZodOptional<z.ZodString>;
+    port: z.ZodOptional<z.ZodNumber>;
+    password: z.ZodOptional<z.ZodString>;
+    database: z.ZodOptional<z.ZodNumber>;
+}, "strict", z.ZodTypeAny, {
+    type: "redis";
+    maxConnections?: number | undefined;
+    idleTimeoutMillis?: number | undefined;
+    connectionTimeoutMillis?: number | undefined;
+    options?: Record<string, unknown> | undefined;
+    url?: string | undefined;
+    host?: string | undefined;
+    port?: number | undefined;
+    password?: string | undefined;
+    database?: number | undefined;
+}, {
+    type: "redis";
+    maxConnections?: number | undefined;
+    idleTimeoutMillis?: number | undefined;
+    connectionTimeoutMillis?: number | undefined;
+    options?: Record<string, unknown> | undefined;
+    url?: string | undefined;
+    host?: string | undefined;
+    port?: number | undefined;
+    password?: string | undefined;
+    database?: number | undefined;
+}>, {
+    type: "redis";
+    maxConnections?: number | undefined;
+    idleTimeoutMillis?: number | undefined;
+    connectionTimeoutMillis?: number | undefined;
+    options?: Record<string, unknown> | undefined;
+    url?: string | undefined;
+    host?: string | undefined;
+    port?: number | undefined;
+    password?: string | undefined;
+    database?: number | undefined;
+}, {
+    type: "redis";
+    maxConnections?: number | undefined;
+    idleTimeoutMillis?: number | undefined;
+    connectionTimeoutMillis?: number | undefined;
+    options?: Record<string, unknown> | undefined;
+    url?: string | undefined;
+    host?: string | undefined;
+    port?: number | undefined;
+    password?: string | undefined;
+    database?: number | undefined;
+}>;
+type RedisCacheConfig = z.output<typeof RedisCacheSchema>;
+declare const CacheConfigSchema: z.ZodObject<{
+    type: z.ZodString;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    type: z.ZodString;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    type: z.ZodString;
+}, z.ZodTypeAny, "passthrough">>;
+type CacheConfig = z.output<typeof CacheConfigSchema>;
+
+export { CACHE_TYPES, type CacheConfig, CacheConfigSchema, type CacheType, type InMemoryCacheConfig, InMemoryCacheSchema, type RedisCacheConfig, RedisCacheSchema };