@burdenoff/be-sdk 2026.510.79

package/dist/index-BODgvRtL.d.ts

@@ -0,0 +1,316 @@
+import { S as ServiceLayer } from './layer-DDip18KY.js';
+
+declare enum CacheProviderType {
+    VALKEY = "valkey",
+    MEMORY = "memory",
+    MEMCACHED = "memcached"
+}
+type CacheProviderTypeLiteral = 'valkey' | 'redis' | 'memory' | 'memcached';
+interface BaseCacheConfig {
+    type: CacheProviderType | CacheProviderTypeLiteral;
+    url?: string;
+    keyPrefix?: string;
+    defaultTTL?: number;
+    enableLogging?: boolean;
+    maxReconnectAttempts?: number;
+    reconnectTimeWait?: number;
+    connectionTimeout?: number;
+    name?: string;
+}
+interface ValkeyCacheConfig extends BaseCacheConfig {
+    type: CacheProviderType.VALKEY | 'valkey' | 'redis';
+    host?: string;
+    port?: number;
+    password?: string;
+    db?: number;
+    username?: string;
+    useTLS?: boolean;
+    tls?: {
+        enabled: boolean;
+        cert?: string;
+        key?: string;
+        ca?: string;
+    };
+    cluster?: boolean;
+    clusterNodes?: Array<{
+        host: string;
+        port: number;
+    }>;
+    sentinel?: {
+        enabled: boolean;
+        sentinels: Array<{
+            host: string;
+            port: number;
+        }>;
+        name: string;
+    };
+}
+interface MemoryCacheConfig extends BaseCacheConfig {
+    type: CacheProviderType.MEMORY | 'memory';
+    maxSize?: number;
+    evictionStrategy?: 'lru' | 'lfu' | 'fifo';
+}
+interface MemcachedCacheConfig extends BaseCacheConfig {
+    type: CacheProviderType.MEMCACHED | 'memcached';
+    servers?: string[];
+}
+type CacheConfig = ValkeyCacheConfig | MemoryCacheConfig | MemcachedCacheConfig;
+interface CacheHealthCheckResult {
+    status: 'healthy' | 'unhealthy' | 'degraded';
+    timestamp: string;
+    connected?: boolean;
+    latencyMs?: number;
+    details?: Record<string, unknown>;
+    error?: string;
+}
+interface CacheStatistics {
+    hits?: number;
+    misses?: number;
+    hitRate?: number;
+    keyCount?: number;
+    memoryUsed?: number;
+    totalOperations?: number;
+    avgOperationTimeMs?: number;
+    lastActivity?: string | null;
+    details?: Record<string, unknown>;
+}
+
+interface CacheEntry<T> {
+    data: T;
+    timestamp: number;
+    ttl: number;
+    metadata?: Record<string, unknown>;
+}
+interface CacheOptions {
+    ttl?: number;
+    tags?: string[];
+    compress?: boolean;
+    metadata?: Record<string, unknown>;
+}
+interface BatchCacheOptions extends CacheOptions {
+    parallel?: boolean;
+    batchSize?: number;
+}
+interface PatternOptions {
+    pattern: string;
+    limit?: number;
+    cursor?: string;
+}
+interface PatternResult {
+    keys: string[];
+    nextCursor: string | null;
+    totalCount?: number;
+}
+
+interface ICache {
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    healthCheck(): Promise<CacheHealthCheckResult>;
+    getStatistics(): Promise<CacheStatistics>;
+}
+
+interface ICacheProvider extends ICache {
+    get<T>(key: string, options?: CacheOptions): Promise<T | null>;
+    set<T>(key: string, value: T, options?: CacheOptions): Promise<boolean>;
+    delete(key: string): Promise<boolean>;
+    has(key: string): Promise<boolean>;
+    ttl(key: string): Promise<number>;
+    expire(key: string, ttl: number): Promise<boolean>;
+    mget<T>(keys: string[], options?: BatchCacheOptions): Promise<Map<string, T>>;
+    mset<T>(entries: Map<string, T>, options?: BatchCacheOptions): Promise<boolean>;
+    mdel(keys: string[]): Promise<number>;
+    clearPattern(pattern: string): Promise<number>;
+    keys(options: PatternOptions): Promise<PatternResult>;
+    clear(): Promise<boolean>;
+    increment(key: string, amount?: number): Promise<number>;
+    decrement(key: string, amount?: number): Promise<number>;
+    getOrSet<T>(key: string, fetcher: () => Promise<T>, options?: CacheOptions): Promise<T>;
+    invalidateTags(tags: string[]): Promise<number>;
+}
+
+declare class CacheFactory {
+    private static instances;
+    private static parseBoolean;
+    private static parseClusterNodes;
+    private static resolvePort;
+    static createCache(config: CacheConfig, namespace?: string): ICacheProvider;
+    static createCacheFromEnv(namespace?: string): ICacheProvider;
+    static getInstance(namespace?: string, config?: CacheConfig): ICacheProvider;
+    static closeInstance(namespace: string): Promise<void>;
+    static closeAll(): Promise<void>;
+    static createCacheForLayer(layer: ServiceLayer, serviceName: string, namespace?: string): ICacheProvider;
+    static getInstanceForLayer(layer: ServiceLayer, serviceName: string, namespace?: string): ICacheProvider;
+}
+
+interface ValkeyGlideConfig {
+    type: 'valkey-glide';
+    url?: string;
+    host?: string;
+    port?: number;
+    password?: string;
+    username?: string;
+    db?: number;
+    keyPrefix?: string;
+    defaultTTL?: number;
+    enableLogging?: boolean;
+    connectionTimeout?: number;
+    maxReconnectAttempts?: number;
+    reconnectTimeWait?: number;
+    name?: string;
+    useTLS?: boolean;
+    cluster?: boolean;
+    clusterNodes?: Array<{
+        host: string;
+        port: number;
+    }>;
+}
+declare class ValkeyGlideProvider implements ICacheProvider {
+    private client;
+    private clusterScanCursor;
+    private clientIsCluster;
+    private connected;
+    private readonly config;
+    private readonly namespace;
+    private readonly defaultTTL;
+    private readonly enableLogging;
+    private stats;
+    constructor(config: ValkeyGlideConfig, namespace?: string);
+    private serverReportsCluster;
+    private scanClusterKeys;
+    private getKeys;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    healthCheck(): Promise<CacheHealthCheckResult>;
+    getStatistics(): Promise<CacheStatistics>;
+    private buildKey;
+    get<T>(key: string, _options?: CacheOptions): Promise<T | null>;
+    set<T>(key: string, value: T, options?: CacheOptions): Promise<boolean>;
+    delete(key: string): Promise<boolean>;
+    has(key: string): Promise<boolean>;
+    ttl(key: string): Promise<number>;
+    expire(key: string, ttl: number): Promise<boolean>;
+    mget<T>(keys: string[], _options?: BatchCacheOptions): Promise<Map<string, T>>;
+    mset<T>(entries: Map<string, T>, options?: BatchCacheOptions): Promise<boolean>;
+    mdel(keys: string[]): Promise<number>;
+    clearPattern(pattern: string): Promise<number>;
+    keys(options: PatternOptions): Promise<PatternResult>;
+    clear(): Promise<boolean>;
+    increment(key: string, amount?: number): Promise<number>;
+    decrement(key: string, amount?: number): Promise<number>;
+    getOrSet<T>(key: string, fetcher: () => Promise<T>, options?: CacheOptions): Promise<T>;
+    invalidateTags(tags: string[]): Promise<number>;
+}
+
+declare class MemoryCacheProvider implements ICacheProvider {
+    private cache;
+    private readonly namespace;
+    private readonly defaultTTL;
+    private readonly maxSize;
+    private readonly enableLogging;
+    private connected;
+    private stats;
+    constructor(config: MemoryCacheConfig, namespace?: string);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    healthCheck(): Promise<CacheHealthCheckResult>;
+    getStatistics(): Promise<CacheStatistics>;
+    private buildKey;
+    private isExpired;
+    private evictIfNeeded;
+    private cleanup;
+    private startCleanupInterval;
+    get<T>(key: string, _options?: CacheOptions): Promise<T | null>;
+    set<T>(key: string, value: T, options?: CacheOptions): Promise<boolean>;
+    delete(key: string): Promise<boolean>;
+    has(key: string): Promise<boolean>;
+    ttl(key: string): Promise<number>;
+    expire(key: string, ttl: number): Promise<boolean>;
+    mget<T>(keys: string[], _options?: BatchCacheOptions): Promise<Map<string, T>>;
+    mset<T>(entries: Map<string, T>, options?: BatchCacheOptions): Promise<boolean>;
+    mdel(keys: string[]): Promise<number>;
+    private matchPattern;
+    clearPattern(pattern: string): Promise<number>;
+    keys(options: PatternOptions): Promise<PatternResult>;
+    clear(): Promise<boolean>;
+    increment(key: string, amount?: number): Promise<number>;
+    decrement(key: string, amount?: number): Promise<number>;
+    getOrSet<T>(key: string, fetcher: () => Promise<T>, options?: CacheOptions): Promise<T>;
+    invalidateTags(tags: string[]): Promise<number>;
+}
+
+declare function createCache(namespace?: string): ICacheProvider;
+declare function getCache(namespace?: string, config?: CacheConfig): ICacheProvider;
+interface ValkeyGlideClient {
+    get(key: string): Promise<string | null>;
+    set(key: string, value: string, options?: {
+        EX?: number;
+    }): Promise<string | null>;
+    del(keys: string[]): Promise<number>;
+    exists(keys: string[]): Promise<number>;
+    ttl(key: string): Promise<number>;
+    expire(key: string, seconds: number): Promise<boolean>;
+    mget(keys: string[]): Promise<(string | null)[]>;
+    mset(keyValuePairs: Record<string, string>): Promise<string | null>;
+    keys(pattern: string): Promise<string[]>;
+    incrBy(key: string, amount: number): Promise<number>;
+    decrBy(key: string, amount: number): Promise<number>;
+    ping(): Promise<string>;
+    info(section?: string): Promise<string>;
+    dbsize(): Promise<number>;
+    close(): Promise<void>;
+    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>;
+    lrange(key: string, start: number, stop: number): Promise<string[]>;
+    llen(key: string): Promise<number>;
+    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<boolean>;
+    hset(key: string, field: string, value: string): Promise<number>;
+    hget(key: string, field: string): Promise<string | null>;
+    hdel(key: string, ...fields: string[]): Promise<number>;
+    hgetall(key: string): Promise<Record<string, string>>;
+    publish(channel: string, message: string): Promise<number>;
+}
+declare function getValkeyClient(config?: ValkeyCacheConfig): Promise<ValkeyGlideClient>;
+declare function closeAllCaches(): Promise<void>;
+
+type index_BaseCacheConfig = BaseCacheConfig;
+type index_BatchCacheOptions = BatchCacheOptions;
+type index_CacheConfig = CacheConfig;
+type index_CacheEntry<T> = CacheEntry<T>;
+type index_CacheFactory = CacheFactory;
+declare const index_CacheFactory: typeof CacheFactory;
+type index_CacheHealthCheckResult = CacheHealthCheckResult;
+type index_CacheOptions = CacheOptions;
+type index_CacheProviderType = CacheProviderType;
+declare const index_CacheProviderType: typeof CacheProviderType;
+type index_CacheProviderTypeLiteral = CacheProviderTypeLiteral;
+type index_CacheStatistics = CacheStatistics;
+type index_ICache = ICache;
+type index_ICacheProvider = ICacheProvider;
+type index_MemcachedCacheConfig = MemcachedCacheConfig;
+type index_MemoryCacheConfig = MemoryCacheConfig;
+type index_MemoryCacheProvider = MemoryCacheProvider;
+declare const index_MemoryCacheProvider: typeof MemoryCacheProvider;
+type index_PatternOptions = PatternOptions;
+type index_PatternResult = PatternResult;
+type index_ValkeyCacheConfig = ValkeyCacheConfig;
+type index_ValkeyGlideClient = ValkeyGlideClient;
+type index_ValkeyGlideConfig = ValkeyGlideConfig;
+type index_ValkeyGlideProvider = ValkeyGlideProvider;
+declare const index_ValkeyGlideProvider: typeof ValkeyGlideProvider;
+declare const index_closeAllCaches: typeof closeAllCaches;
+declare const index_createCache: typeof createCache;
+declare const index_getCache: typeof getCache;
+declare const index_getValkeyClient: typeof getValkeyClient;
+declare namespace index {
+  export { type index_BaseCacheConfig as BaseCacheConfig, type index_BatchCacheOptions as BatchCacheOptions, type index_CacheConfig as CacheConfig, type index_CacheEntry as CacheEntry, index_CacheFactory as CacheFactory, type index_CacheHealthCheckResult as CacheHealthCheckResult, type index_CacheOptions as CacheOptions, index_CacheProviderType as CacheProviderType, type index_CacheProviderTypeLiteral as CacheProviderTypeLiteral, type index_CacheStatistics as CacheStatistics, type index_ICache as ICache, type index_ICacheProvider as ICacheProvider, type index_MemcachedCacheConfig as MemcachedCacheConfig, type index_MemoryCacheConfig as MemoryCacheConfig, index_MemoryCacheProvider as MemoryCacheProvider, type index_PatternOptions as PatternOptions, type index_PatternResult as PatternResult, type index_ValkeyCacheConfig as ValkeyCacheConfig, type index_ValkeyGlideClient as ValkeyGlideClient, type index_ValkeyGlideConfig as ValkeyGlideConfig, index_ValkeyGlideProvider as ValkeyGlideProvider, index_closeAllCaches as closeAllCaches, index_createCache as createCache, index_getCache as getCache, index_getValkeyClient as getValkeyClient };
+}
+
+export { type BaseCacheConfig as B, type CacheConfig as C, type ICache as I, type MemcachedCacheConfig as M, type PatternOptions as P, type ValkeyCacheConfig as V, type BatchCacheOptions as a, type CacheEntry as b, CacheFactory as c, type CacheHealthCheckResult as d, type CacheOptions as e, CacheProviderType as f, type CacheProviderTypeLiteral as g, type CacheStatistics as h, index as i, type ICacheProvider as j, type MemoryCacheConfig as k, MemoryCacheProvider as l, type PatternResult as m, type ValkeyGlideClient as n, type ValkeyGlideConfig as o, ValkeyGlideProvider as p, closeAllCaches as q, createCache as r, getCache as s, getValkeyClient as t };