@digilogiclabs/platform-core 1.0.0

package/dist/index.d.mts

@@ -0,0 +1,2045 @@
+import { p as ILogger, q as IMetrics, I as IPlatform, P as PlatformHealthStatus, u as MetricsSummary, e as IDatabase, k as IQueryBuilder, Q as QueryResult, l as ICache, m as IStorage, U as UploadOptions, S as StorageFile, n as IEmail, t as EmailMessage, v as EmailResult, o as IQueue, s as JobOptions, J as Job } from './ConsoleEmail-XeUBAnwc.mjs';
+export { an as BulkheadConfigSchema, ax as CacheConfig, ag as CacheConfigSchema, a9 as CacheProviderSchema, al as CircuitBreakerConfigSchema, C as ConsoleEmail, h as ConsoleLogger, aw as DatabaseConfig, af as DatabaseConfigSchema, a8 as DatabaseProviderSchema, a4 as EmailAddress, a5 as EmailAttachment, az as EmailConfig, ai as EmailConfigSchema, ab as EmailProviderSchema, E as EnvSecrets, G as GetSecretOptions, H as HistogramStats, w as ICacheOptions, r as ISecrets, _ as ISpan, Z as ITracing, x as JobResult, z as LogEntry, L as LogLevel, ae as LogLevelSchema, y as LogMeta, A as LoggerConfig, ap as LoggingConfigSchema, a as MemoryCache, M as MemoryDatabase, c as MemoryEmail, i as MemoryMetrics, d as MemoryQueue, f as MemorySecrets, b as MemoryStorage, X as MemoryTracing, B as MetricTags, aq as MetricsConfigSchema, aD as MiddlewareConfig, at as MiddlewareConfigSchema, N as NoopLogger, j as NoopMetrics, Y as NoopTracing, aC as ObservabilityConfig, as as ObservabilityConfigSchema, av as PlatformConfig, au as PlatformConfigSchema, aA as QueueConfig, aj as QueueConfigSchema, ac as QueueProviderSchema, aB as ResilienceConfig, ao as ResilienceConfigSchema, ak as RetryConfigSchema, R as RotateSecretOptions, O as RotationResult, D as Secret, F as SecretMetadata, K as SetSecretOptions, $ as SpanContext, a7 as SpanEvent, a2 as SpanKind, a0 as SpanOptions, a1 as SpanStatus, a6 as SpanStatusCode, ay as StorageConfig, ah as StorageConfigSchema, aa as StorageProviderSchema, am as TimeoutConfigSchema, T as TimingStats, a3 as TracingConfig, ar as TracingConfigSchema, ad as TracingProviderSchema, g as createPlatform, V as createPlatformAsync, W as createScopedMetrics, aH as getDefaultConfig, aE as loadConfig, aG as safeValidateConfig, aF as validateConfig } from './ConsoleEmail-XeUBAnwc.mjs';
+export { i as IMigrationDatabase, I as IMigrator, a as Migration, b as MigrationRecord, e as MigrationResult, f as MigrationStatus, M as Migrator, h as MigratorConfig, S as SQL, c as createMigration, d as defineMigration, g as generateVersion, s as sqlMigration } from './index-C_2W7Byw.mjs';
+import { SupabaseClient } from '@supabase/supabase-js';
+import { Pool } from 'pg';
+import { Redis } from '@upstash/redis';
+import { Redis as Redis$1 } from 'ioredis';
+import { S3Client } from '@aws-sdk/client-s3';
+import { getSignedUrl } from '@aws-sdk/s3-request-presigner';
+import { Resend } from 'resend';
+import 'zod';
+
+/**
+ * Health Check Interface
+ * Standardizes health check behavior across all adapters
+ */
+/**
+ * Result of a single health check
+ */
+interface HealthCheckResult {
+    /** Overall health status */
+    status: 'healthy' | 'degraded' | 'unhealthy';
+    /** Time taken to perform the check in milliseconds */
+    latencyMs: number;
+    /** When the check was performed */
+    timestamp: Date;
+    /** Optional message with details */
+    message?: string;
+    /** Additional details about the health check */
+    details?: Record<string, unknown>;
+}
+/**
+ * Aggregated health result for the entire platform
+ */
+interface PlatformHealthResult {
+    /** Overall platform status */
+    status: 'healthy' | 'degraded' | 'unhealthy';
+    /** When the check was performed */
+    timestamp: Date;
+    /** Individual service health results */
+    services: {
+        database: HealthCheckResult;
+        cache: HealthCheckResult;
+        storage: HealthCheckResult;
+        email: HealthCheckResult;
+        queue: HealthCheckResult;
+    };
+    /** Summary counts */
+    summary: {
+        total: number;
+        healthy: number;
+        degraded: number;
+        unhealthy: number;
+    };
+}
+/**
+ * Interface for services that support health checks
+ */
+interface IHealth {
+    /**
+     * Perform a health check on the service
+     * @returns Promise resolving to health check result
+     */
+    healthCheck(): Promise<HealthCheckResult>;
+}
+/**
+ * Interface for services that support simple boolean health checks
+ * (Legacy support - prefer IHealth for new implementations)
+ */
+interface IHealthCheckable {
+    /**
+     * Simple health check returning boolean
+     * @returns Promise resolving to true if healthy
+     */
+    healthCheck(): Promise<boolean>;
+}
+/**
+ * Helper to convert boolean health check to HealthCheckResult
+ */
+declare function toHealthCheckResult(healthy: boolean, latencyMs: number, message?: string): HealthCheckResult;
+/**
+ * Helper to perform a timed health check
+ */
+declare function timedHealthCheck<T>(fn: () => Promise<T>, successCheck?: (result: T) => boolean): Promise<HealthCheckResult>;
+
+/**
+ * Middleware System for Platform Core
+ *
+ * Provides cross-cutting concerns like logging, metrics, caching, and error handling
+ * through a composable middleware pattern.
+ */
+
+/**
+ * Context passed to middleware functions
+ */
+interface MiddlewareContext<TArgs = unknown, TResult = unknown> {
+    /** The operation being performed (e.g., 'db.query', 'cache.get') */
+    operation: string;
+    /** The service type (e.g., 'database', 'cache', 'storage') */
+    service: 'database' | 'cache' | 'storage' | 'email' | 'queue';
+    /** Arguments passed to the operation */
+    args: TArgs;
+    /** Result of the operation (only available in after/onError) */
+    result?: TResult;
+    /** Error if operation failed (only available in onError) */
+    error?: Error;
+    /** Timestamp when operation started */
+    startTime: number;
+    /** Duration in milliseconds (only available in after/onError) */
+    duration?: number;
+    /** Metadata bag for middleware to share data */
+    metadata: Map<string, unknown>;
+    /** Logger instance */
+    logger: ILogger;
+    /** Correlation ID for distributed tracing */
+    correlationId: string;
+    /** Tenant ID for multi-tenant applications */
+    tenantId?: string;
+    /** Whether to skip remaining middleware */
+    skip: boolean;
+    /** Cached result to return (bypasses actual operation) */
+    cachedResult?: TResult;
+}
+/**
+ * Middleware function signatures
+ */
+interface Middleware<TArgs = unknown, TResult = unknown> {
+    /** Unique name for the middleware */
+    name: string;
+    /** Priority for ordering (lower runs first) */
+    priority?: number;
+    /**
+     * Called before the operation executes.
+     * Can modify args, set cached result, or skip operation.
+     */
+    before?(ctx: MiddlewareContext<TArgs, TResult>): Promise<void> | void;
+    /**
+     * Called after successful operation.
+     * Can modify or transform the result.
+     */
+    after?(ctx: MiddlewareContext<TArgs, TResult>): Promise<void> | void;
+    /**
+     * Called when operation throws an error.
+     * Can handle, transform, or re-throw the error.
+     */
+    onError?(ctx: MiddlewareContext<TArgs, TResult>, error: Error): Promise<void> | void;
+}
+/**
+ * Middleware chain executor
+ */
+interface MiddlewareChain {
+    /** Add middleware to the chain */
+    use<TArgs = unknown, TResult = unknown>(middleware: Middleware<TArgs, TResult>): MiddlewareChain;
+    /** Remove middleware by name */
+    remove(name: string): MiddlewareChain;
+    /** Execute the middleware chain around an operation */
+    execute<TArgs, TResult>(ctx: Omit<MiddlewareContext<TArgs, TResult>, 'metadata' | 'skip' | 'cachedResult'>, operation: () => Promise<TResult>): Promise<TResult>;
+    /** Get all registered middleware */
+    getMiddleware(): Middleware[];
+}
+/**
+ * Options for creating a middleware chain
+ */
+interface MiddlewareChainOptions {
+    /** Logger for middleware operations */
+    logger?: ILogger;
+    /** Default correlation ID generator */
+    generateCorrelationId?: () => string;
+}
+
+/**
+ * Middleware Chain Implementation
+ */
+
+/**
+ * Create a new middleware chain
+ */
+declare function createMiddlewareChain(options?: MiddlewareChainOptions): MiddlewareChain;
+/**
+ * Create a context for middleware execution
+ */
+declare function createMiddlewareContext<TArgs = unknown, TResult = unknown>(service: MiddlewareContext['service'], operation: string, args: TArgs, logger: ILogger, options?: {
+    correlationId?: string;
+    tenantId?: string;
+}): Omit<MiddlewareContext<TArgs, TResult>, 'metadata' | 'skip' | 'cachedResult'>;
+
+/**
+ * Built-in Middleware Implementations
+ */
+
+/**
+ * Logging middleware - logs all operations with timing
+ */
+declare function createLoggingMiddleware(logger: ILogger): Middleware;
+/**
+ * Metrics middleware - records timing and counters
+ */
+declare function createMetricsMiddleware(metrics: IMetrics): Middleware;
+/**
+ * Slow query logging middleware
+ */
+declare function createSlowQueryMiddleware(logger: ILogger, thresholdMs?: number): Middleware;
+/**
+ * Tenant isolation middleware - ensures tenant context is set
+ */
+declare function createTenantMiddleware(options?: {
+    required?: boolean;
+    headerName?: string;
+}): Middleware;
+/**
+ * Request ID middleware - ensures correlation ID exists
+ */
+declare function createRequestIdMiddleware(): Middleware;
+/**
+ * Timeout middleware - enforces operation timeout
+ */
+declare function createTimeoutMiddleware(timeoutMs: number): Middleware;
+/**
+ * Cache middleware - caches results of read operations
+ */
+declare function createCacheMiddleware(cache: {
+    get: (key: string) => Promise<unknown>;
+    set: (key: string, value: unknown, ttl?: number) => Promise<void>;
+}, options?: {
+    ttl?: number;
+    keyPrefix?: string;
+    cacheableOperations?: string[];
+}): Middleware;
+/**
+ * Rate Limiting Error
+ */
+declare class RateLimitError extends Error {
+    readonly name = "RateLimitError";
+    readonly retryAfter: number;
+    readonly limit: number;
+    readonly remaining: number;
+    readonly resetAt: Date;
+    constructor(message: string, options: {
+        retryAfter: number;
+        limit: number;
+        remaining: number;
+        resetAt: Date;
+    });
+}
+/**
+ * Rate limit info for responses
+ */
+interface RateLimitInfo {
+    limit: number;
+    remaining: number;
+    resetAt: Date;
+}
+/**
+ * Rate limiter storage interface
+ */
+interface RateLimiterStorage {
+    /**
+     * Get current count and increment
+     * Returns: [currentCount, resetAt timestamp]
+     */
+    increment(key: string, windowMs: number): Promise<[number, number]>;
+    /**
+     * Get current state without incrementing
+     */
+    get(key: string): Promise<{
+        count: number;
+        resetAt: number;
+    } | null>;
+}
+/**
+ * In-memory rate limiter storage
+ */
+declare class MemoryRateLimiterStorage implements RateLimiterStorage {
+    private windows;
+    private cleanupInterval;
+    constructor(options?: {
+        cleanupIntervalMs?: number;
+    });
+    increment(key: string, windowMs: number): Promise<[number, number]>;
+    get(key: string): Promise<{
+        count: number;
+        resetAt: number;
+    } | null>;
+    /**
+     * Clear all windows (for testing)
+     */
+    clear(): void;
+    /**
+     * Stop cleanup interval
+     */
+    stop(): void;
+}
+/**
+ * Rate limiting algorithm types
+ */
+type RateLimitAlgorithm = 'fixed-window' | 'sliding-window' | 'token-bucket';
+/**
+ * Rate limiting options
+ */
+interface RateLimitOptions {
+    /** Maximum requests per window */
+    limit: number;
+    /** Time window in milliseconds */
+    windowMs: number;
+    /** Storage backend (defaults to memory) */
+    storage?: RateLimiterStorage;
+    /** Key generator function */
+    keyGenerator?: (ctx: MiddlewareContext) => string;
+    /** Skip rate limiting for certain requests */
+    skip?: (ctx: MiddlewareContext) => boolean;
+    /** Handler for rate limit exceeded */
+    onRateLimited?: (ctx: MiddlewareContext, info: RateLimitInfo) => void;
+    /** Whether to throw error or just log (defaults to throw) */
+    throwOnLimit?: boolean;
+    /** Custom message for rate limit error */
+    message?: string;
+    /** Headers to set with rate limit info */
+    setHeaders?: boolean;
+}
+/**
+ * Rate limiting middleware
+ * Prevents abuse by limiting request frequency
+ */
+declare function createRateLimitMiddleware(options: RateLimitOptions): Middleware;
+/**
+ * Create an IP-based rate limiter key generator
+ */
+declare function createIpKeyGenerator(getIp: (ctx: MiddlewareContext) => string | undefined): (ctx: MiddlewareContext) => string;
+/**
+ * Create a user-based rate limiter key generator
+ */
+declare function createUserKeyGenerator(getUserId: (ctx: MiddlewareContext) => string | undefined): (ctx: MiddlewareContext) => string;
+/**
+ * Sliding window rate limiter options
+ */
+interface SlidingWindowRateLimitOptions extends Omit<RateLimitOptions, 'algorithm'> {
+    /** Number of sub-windows (more = more accurate, more memory) */
+    precision?: number;
+}
+/**
+ * Token bucket rate limiter options
+ */
+interface TokenBucketOptions {
+    /** Bucket capacity (max tokens) */
+    capacity: number;
+    /** Token refill rate per second */
+    refillRate: number;
+    /** Storage backend */
+    storage?: RateLimiterStorage;
+    /** Key generator function */
+    keyGenerator?: (ctx: MiddlewareContext) => string;
+    /** Skip rate limiting for certain requests */
+    skip?: (ctx: MiddlewareContext) => boolean;
+    /** Whether to throw error or just log */
+    throwOnLimit?: boolean;
+    /** Custom message for rate limit error */
+    message?: string;
+}
+/**
+ * Pre-configured rate limit presets
+ */
+declare const RateLimitPresets: {
+    /** Standard API rate limit: 100 req/min */
+    readonly standard: {
+        readonly limit: 100;
+        readonly windowMs: number;
+    };
+    /** Strict rate limit: 10 req/min */
+    readonly strict: {
+        readonly limit: 10;
+        readonly windowMs: number;
+    };
+    /** Relaxed rate limit: 1000 req/min */
+    readonly relaxed: {
+        readonly limit: 1000;
+        readonly windowMs: number;
+    };
+    /** Burst protection: 50 req/sec */
+    readonly burst: {
+        readonly limit: 50;
+        readonly windowMs: 1000;
+    };
+    /** Auth rate limit: 5 attempts/15 min */
+    readonly auth: {
+        readonly limit: 5;
+        readonly windowMs: number;
+    };
+    /** Expensive operations: 10 req/hour */
+    readonly expensive: {
+        readonly limit: 10;
+        readonly windowMs: number;
+    };
+};
+
+/**
+ * Hooks System for Platform Core
+ *
+ * Provides lifecycle events and extensibility points for platform operations.
+ */
+
+/**
+ * All available platform hooks
+ */
+interface PlatformHooks {
+    /**
+     * Called when platform is fully initialized
+     */
+    onReady?: () => Promise<void> | void;
+    /**
+     * Called when platform is shutting down
+     */
+    onShutdown?: () => Promise<void> | void;
+    /**
+     * Called after health check completes
+     */
+    onHealthCheck?: (result: PlatformHealthResult) => Promise<void> | void;
+    /**
+     * Called before any database query
+     */
+    beforeQuery?: (context: QueryHookContext) => Promise<void> | void;
+    /**
+     * Called after successful database query
+     */
+    afterQuery?: (context: QueryHookContext & {
+        result: unknown;
+        duration: number;
+    }) => Promise<void> | void;
+    /**
+     * Called before insert operation
+     */
+    beforeInsert?: (context: InsertHookContext) => Promise<void> | void;
+    /**
+     * Called after successful insert
+     */
+    afterInsert?: (context: InsertHookContext & {
+        result: unknown;
+    }) => Promise<void> | void;
+    /**
+     * Called before update operation
+     */
+    beforeUpdate?: (context: UpdateHookContext) => Promise<void> | void;
+    /**
+     * Called after successful update
+     */
+    afterUpdate?: (context: UpdateHookContext & {
+        result: unknown;
+    }) => Promise<void> | void;
+    /**
+     * Called before delete operation
+     */
+    beforeDelete?: (context: DeleteHookContext) => Promise<void> | void;
+    /**
+     * Called after successful delete
+     */
+    afterDelete?: (context: DeleteHookContext & {
+        count: number;
+    }) => Promise<void> | void;
+    /**
+     * Called when cache hit occurs
+     */
+    onCacheHit?: (key: string, value: unknown) => Promise<void> | void;
+    /**
+     * Called when cache miss occurs
+     */
+    onCacheMiss?: (key: string) => Promise<void> | void;
+    /**
+     * Called when cache entry is set
+     */
+    onCacheSet?: (key: string, ttl?: number) => Promise<void> | void;
+    /**
+     * Called when cache entry is deleted
+     */
+    onCacheDelete?: (key: string) => Promise<void> | void;
+    /**
+     * Called before file upload
+     */
+    beforeUpload?: (context: UploadHookContext) => Promise<void> | void;
+    /**
+     * Called after successful upload
+     */
+    afterUpload?: (context: UploadHookContext & {
+        url: string;
+    }) => Promise<void> | void;
+    /**
+     * Called before file download
+     */
+    beforeDownload?: (key: string) => Promise<void> | void;
+    /**
+     * Called after successful download
+     */
+    afterDownload?: (key: string, size: number) => Promise<void> | void;
+    /**
+     * Called before file deletion
+     */
+    beforeStorageDelete?: (key: string) => Promise<void> | void;
+    /**
+     * Called after successful storage deletion
+     */
+    afterStorageDelete?: (key: string) => Promise<void> | void;
+    /**
+     * Called before email is sent
+     */
+    beforeEmailSend?: (context: EmailHookContext) => Promise<void> | void;
+    /**
+     * Called after email is sent successfully
+     */
+    afterEmailSend?: (context: EmailHookContext & {
+        messageId: string;
+    }) => Promise<void> | void;
+    /**
+     * Called when email send fails
+     */
+    onEmailFailed?: (context: EmailHookContext, error: Error) => Promise<void> | void;
+    /**
+     * Called when job is added to queue
+     */
+    onJobAdd?: (context: JobHookContext) => Promise<void> | void;
+    /**
+     * Called when job starts processing
+     */
+    onJobStart?: (context: JobHookContext) => Promise<void> | void;
+    /**
+     * Called when job completes successfully
+     */
+    onJobComplete?: (context: JobHookContext & {
+        result: unknown;
+    }) => Promise<void> | void;
+    /**
+     * Called when job fails
+     */
+    onJobFailed?: (context: JobHookContext, error: Error) => Promise<void> | void;
+    /**
+     * Called when job is retried
+     */
+    onJobRetry?: (context: JobHookContext & {
+        attempt: number;
+    }) => Promise<void> | void;
+    /**
+     * Global error handler for any platform operation
+     */
+    onError?: (context: ErrorHookContext) => Promise<void> | void;
+}
+/**
+ * Context for database query hooks
+ */
+interface QueryHookContext {
+    table: string;
+    operation: 'select' | 'insert' | 'update' | 'delete' | 'raw';
+    conditions?: Record<string, unknown>;
+    correlationId?: string;
+    tenantId?: string;
+}
+/**
+ * Context for insert hooks
+ */
+interface InsertHookContext {
+    table: string;
+    data: Record<string, unknown> | Record<string, unknown>[];
+    correlationId?: string;
+    tenantId?: string;
+}
+/**
+ * Context for update hooks
+ */
+interface UpdateHookContext {
+    table: string;
+    data: Record<string, unknown>;
+    conditions: Record<string, unknown>;
+    correlationId?: string;
+    tenantId?: string;
+}
+/**
+ * Context for delete hooks
+ */
+interface DeleteHookContext {
+    table: string;
+    conditions: Record<string, unknown>;
+    correlationId?: string;
+    tenantId?: string;
+}
+/**
+ * Context for upload hooks
+ */
+interface UploadHookContext {
+    key: string;
+    contentType?: string;
+    size?: number;
+    correlationId?: string;
+    tenantId?: string;
+}
+/**
+ * Context for email hooks
+ */
+interface EmailHookContext {
+    to: string | string[];
+    subject: string;
+    correlationId?: string;
+    tenantId?: string;
+}
+/**
+ * Context for job hooks
+ */
+interface JobHookContext {
+    jobId: string;
+    name: string;
+    data: unknown;
+    correlationId?: string;
+    tenantId?: string;
+}
+/**
+ * Context for error hooks
+ */
+interface ErrorHookContext {
+    service: 'database' | 'cache' | 'storage' | 'email' | 'queue';
+    operation: string;
+    error: Error;
+    correlationId?: string;
+    tenantId?: string;
+}
+/**
+ * Hook registry for managing platform hooks
+ */
+interface HookRegistry {
+    /**
+     * Register hooks
+     */
+    register(hooks: Partial<PlatformHooks>): void;
+    /**
+     * Unregister all hooks
+     */
+    clear(): void;
+    /**
+     * Execute a hook by name
+     */
+    execute<K extends keyof PlatformHooks>(hookName: K, ...args: Parameters<NonNullable<PlatformHooks[K]>>): Promise<void>;
+    /**
+     * Get registered hooks
+     */
+    getHooks(): PlatformHooks;
+}
+
+/**
+ * Hook Registry Implementation
+ */
+
+/**
+ * Create a hook registry
+ */
+declare function createHookRegistry(logger?: ILogger): HookRegistry;
+/**
+ * Compose multiple hook registries
+ */
+declare function composeHookRegistries(...registries: HookRegistry[]): HookRegistry;
+
+/**
+ * Retry Pattern Implementation
+ *
+ * Provides configurable retry logic with exponential backoff and jitter.
+ */
+
+/**
+ * Options for retry behavior
+ */
+interface RetryOptions {
+    /**
+     * Maximum number of retry attempts
+     * @default 3
+     */
+    maxAttempts: number;
+    /**
+     * Initial delay between retries in milliseconds
+     * @default 100
+     */
+    baseDelay: number;
+    /**
+     * Maximum delay between retries in milliseconds
+     * @default 10000
+     */
+    maxDelay: number;
+    /**
+     * Multiplier for exponential backoff
+     * @default 2
+     */
+    backoffMultiplier: number;
+    /**
+     * Whether to add random jitter to delays
+     * @default true
+     */
+    jitter: boolean;
+    /**
+     * Maximum jitter in milliseconds
+     * @default 100
+     */
+    maxJitter: number;
+    /**
+     * Function to determine if error is retryable
+     * @default All errors are retryable
+     */
+    retryIf?: (error: Error) => boolean;
+    /**
+     * Function to determine if error is non-retryable
+     * Takes precedence over retryIf
+     */
+    abortIf?: (error: Error) => boolean;
+    /**
+     * Callback on each retry attempt
+     */
+    onRetry?: (error: Error, attempt: number, delay: number) => void;
+    /**
+     * Logger for retry operations
+     */
+    logger?: ILogger;
+}
+/**
+ * Default retry options
+ */
+declare const DEFAULT_RETRY_OPTIONS: RetryOptions;
+/**
+ * Result of a retry operation
+ */
+interface RetryResult<T> {
+    /** Whether the operation succeeded */
+    success: boolean;
+    /** The result if successful */
+    result?: T;
+    /** The final error if all attempts failed */
+    error?: Error;
+    /** Number of attempts made */
+    attempts: number;
+    /** Total time spent in milliseconds */
+    totalTime: number;
+}
+/**
+ * Execute a function with retry logic
+ */
+declare function withRetry<T>(fn: () => Promise<T>, options?: Partial<RetryOptions>): Promise<T>;
+/**
+ * Execute with retry and return detailed result
+ */
+declare function withRetryResult<T>(fn: () => Promise<T>, options?: Partial<RetryOptions>): Promise<RetryResult<T>>;
+/**
+ * Create a retryable version of a function
+ */
+declare function retryable<TArgs extends unknown[], TResult>(fn: (...args: TArgs) => Promise<TResult>, options?: Partial<RetryOptions>): (...args: TArgs) => Promise<TResult>;
+/**
+ * Common retry predicates
+ */
+declare const RetryPredicates: {
+    /**
+     * Retry on network errors
+     */
+    networkErrors: (error: Error) => boolean;
+    /**
+     * Retry on HTTP 5xx errors
+     */
+    serverErrors: (error: Error) => boolean;
+    /**
+     * Retry on HTTP 429 (rate limit) errors
+     */
+    rateLimitErrors: (error: Error) => boolean;
+    /**
+     * Retry on database deadlock errors
+     */
+    deadlockErrors: (error: Error) => boolean;
+    /**
+     * Never retry on authentication errors
+     */
+    authenticationErrors: (error: Error) => boolean;
+    /**
+     * Never retry on validation errors
+     */
+    validationErrors: (error: Error) => boolean;
+};
+/**
+ * Common retry configurations
+ */
+declare const RetryConfigs: {
+    /**
+     * Fast retry for quick failures
+     */
+    fast: Partial<RetryOptions>;
+    /**
+     * Standard retry configuration
+     */
+    standard: Partial<RetryOptions>;
+    /**
+     * Aggressive retry for critical operations
+     */
+    aggressive: Partial<RetryOptions>;
+    /**
+     * Conservative retry for rate-limited APIs
+     */
+    rateLimited: Partial<RetryOptions>;
+    /**
+     * Database retry configuration
+     */
+    database: Partial<RetryOptions>;
+};
+
+/**
+ * Circuit Breaker Pattern Implementation
+ *
+ * Prevents cascading failures by temporarily blocking calls to a failing service.
+ */
+
+/**
+ * Circuit breaker states
+ */
+type CircuitState = 'closed' | 'open' | 'half-open';
+/**
+ * Options for circuit breaker behavior
+ */
+interface CircuitBreakerOptions {
+    /**
+     * Name of the circuit (for logging)
+     */
+    name: string;
+    /**
+     * Number of failures before opening the circuit
+     * @default 5
+     */
+    failureThreshold: number;
+    /**
+     * Time in milliseconds before attempting to close the circuit
+     * @default 30000
+     */
+    resetTimeout: number;
+    /**
+     * Number of successful requests needed in half-open state to close the circuit
+     * @default 3
+     */
+    successThreshold: number;
+    /**
+     * Time window in milliseconds for counting failures
+     * @default 60000
+     */
+    failureWindow: number;
+    /**
+     * Function to determine if error should trip the circuit
+     * @default All errors trip the circuit
+     */
+    shouldTrip?: (error: Error) => boolean;
+    /**
+     * Callback when circuit state changes
+     */
+    onStateChange?: (from: CircuitState, to: CircuitState) => void;
+    /**
+     * Callback when circuit opens
+     */
+    onOpen?: (failures: number, lastError: Error) => void;
+    /**
+     * Callback when circuit closes
+     */
+    onClose?: () => void;
+    /**
+     * Callback when request is rejected due to open circuit
+     */
+    onReject?: (state: CircuitState) => void;
+    /**
+     * Logger for circuit breaker events
+     */
+    logger?: ILogger;
+}
+/**
+ * Default circuit breaker options
+ */
+declare const DEFAULT_CIRCUIT_BREAKER_OPTIONS: Omit<CircuitBreakerOptions, 'name'>;
+/**
+ * Error thrown when circuit is open
+ */
+declare class CircuitOpenError extends Error {
+    readonly name = "CircuitOpenError";
+    readonly circuitName: string;
+    readonly state: CircuitState;
+    readonly nextAttemptAt: Date;
+    constructor(circuitName: string, state: CircuitState, resetTimeout: number);
+}
+/**
+ * Circuit breaker statistics
+ */
+interface CircuitBreakerStats {
+    state: CircuitState;
+    failures: number;
+    successes: number;
+    lastFailure?: Date;
+    lastSuccess?: Date;
+    lastStateChange?: Date;
+    totalRequests: number;
+    rejectedRequests: number;
+}
+/**
+ * Circuit breaker implementation
+ */
+declare class CircuitBreaker {
+    private state;
+    private failures;
+    private successes;
+    private failureTimestamps;
+    private lastFailure?;
+    private lastSuccess?;
+    private lastStateChange?;
+    private lastOpenedAt?;
+    private totalRequests;
+    private rejectedRequests;
+    private lastError?;
+    private readonly options;
+    private readonly logger;
+    constructor(options: CircuitBreakerOptions);
+    /**
+     * Execute a function with circuit breaker protection
+     */
+    execute<T>(fn: () => Promise<T>): Promise<T>;
+    /**
+     * Check if circuit allows execution
+     */
+    canExecute(): boolean;
+    /**
+     * Record a successful execution
+     */
+    private onSuccess;
+    /**
+     * Record a failed execution
+     */
+    private onFailure;
+    /**
+     * Transition to a new state
+     */
+    private transitionTo;
+    /**
+     * Check if reset timeout has passed
+     */
+    private shouldAttemptReset;
+    /**
+     * Get remaining time until reset attempt
+     */
+    private getRemainingTimeout;
+    /**
+     * Get current circuit state
+     */
+    getState(): CircuitState;
+    /**
+     * Get circuit breaker statistics
+     */
+    getStats(): CircuitBreakerStats;
+    /**
+     * Manually reset the circuit to closed state
+     */
+    reset(): void;
+    /**
+     * Manually trip the circuit to open state
+     */
+    trip(): void;
+    /**
+     * Check if circuit is open
+     */
+    isOpen(): boolean;
+    /**
+     * Check if circuit is closed
+     */
+    isClosed(): boolean;
+    /**
+     * Check if circuit is half-open
+     */
+    isHalfOpen(): boolean;
+}
+/**
+ * Create a circuit breaker
+ */
+declare function createCircuitBreaker(options: CircuitBreakerOptions): CircuitBreaker;
+/**
+ * Circuit breaker registry for managing multiple circuits
+ */
+declare class CircuitBreakerRegistry {
+    private circuits;
+    private readonly logger;
+    private readonly defaultOptions;
+    constructor(options?: {
+        logger?: ILogger;
+        defaults?: Partial<CircuitBreakerOptions>;
+    });
+    /**
+     * Get or create a circuit breaker
+     */
+    get(name: string, options?: Partial<CircuitBreakerOptions>): CircuitBreaker;
+    /**
+     * Execute with a named circuit breaker
+     */
+    execute<T>(name: string, fn: () => Promise<T>, options?: Partial<CircuitBreakerOptions>): Promise<T>;
+    /**
+     * Get all circuit statistics
+     */
+    getAllStats(): Record<string, CircuitBreakerStats>;
+    /**
+     * Reset all circuits
+     */
+    resetAll(): void;
+    /**
+     * Clear all circuits
+     */
+    clear(): void;
+}
+
+/**
+ * Timeout Pattern Implementation
+ *
+ * Enforces time limits on operations to prevent hanging.
+ */
+/**
+ * Error thrown when operation times out
+ */
+declare class TimeoutError extends Error {
+    readonly name = "TimeoutError";
+    readonly operation: string;
+    readonly timeout: number;
+    constructor(operation: string, timeout: number);
+}
+/**
+ * Options for timeout behavior
+ */
+interface TimeoutOptions {
+    /**
+     * Timeout in milliseconds
+     */
+    timeout: number;
+    /**
+     * Operation name (for error messages)
+     */
+    operation?: string;
+    /**
+     * Whether to abort the operation on timeout (if supported)
+     */
+    abortOnTimeout?: boolean;
+}
+/**
+ * Execute a function with a timeout
+ */
+declare function withTimeout<T>(fn: () => Promise<T>, options: TimeoutOptions | number): Promise<T>;
+/**
+ * Create a timeout-wrapped version of a function
+ */
+declare function withTimeoutWrapper<TArgs extends unknown[], TResult>(fn: (...args: TArgs) => Promise<TResult>, options: TimeoutOptions | number): (...args: TArgs) => Promise<TResult>;
+/**
+ * Race a promise against a timeout
+ */
+declare function raceTimeout<T>(promise: Promise<T>, timeout: number, operation?: string): Promise<T>;
+/**
+ * Default timeouts for different operations
+ */
+declare const DefaultTimeouts: {
+    /** Quick operations like cache lookups */
+    fast: number;
+    /** Standard database queries */
+    database: number;
+    /** API calls to external services */
+    api: number;
+    /** File uploads/downloads */
+    storage: number;
+    /** Email sending */
+    email: number;
+    /** Long-running background jobs */
+    job: number;
+};
+
+/**
+ * Bulkhead Pattern Implementation
+ *
+ * Isolates failures by limiting concurrent operations.
+ */
+
+/**
+ * Options for bulkhead behavior
+ */
+interface BulkheadOptions {
+    /**
+     * Name of the bulkhead (for logging)
+     */
+    name: string;
+    /**
+     * Maximum concurrent executions allowed
+     * @default 10
+     */
+    maxConcurrent: number;
+    /**
+     * Maximum queue size for waiting requests
+     * @default 100
+     */
+    maxQueue: number;
+    /**
+     * Timeout for queued requests in milliseconds
+     * @default 30000
+     */
+    queueTimeout: number;
+    /**
+     * Callback when execution is rejected
+     */
+    onReject?: (reason: 'concurrent' | 'queue' | 'timeout') => void;
+    /**
+     * Logger for bulkhead events
+     */
+    logger?: ILogger;
+}
+/**
+ * Default bulkhead options
+ */
+declare const DEFAULT_BULKHEAD_OPTIONS: Omit<BulkheadOptions, 'name'>;
+/**
+ * Error thrown when bulkhead rejects a request
+ */
+declare class BulkheadRejectedError extends Error {
+    readonly name = "BulkheadRejectedError";
+    readonly bulkheadName: string;
+    readonly reason: 'concurrent' | 'queue' | 'timeout';
+    constructor(bulkheadName: string, reason: 'concurrent' | 'queue' | 'timeout');
+}
+/**
+ * Bulkhead statistics
+ */
+interface BulkheadStats {
+    activeCalls: number;
+    queuedCalls: number;
+    maxConcurrent: number;
+    maxQueue: number;
+    totalExecutions: number;
+    rejectedCalls: number;
+    availableSlots: number;
+    availableQueueSlots: number;
+}
+/**
+ * Bulkhead implementation
+ */
+declare class Bulkhead {
+    private activeCalls;
+    private queue;
+    private totalExecutions;
+    private rejectedCalls;
+    private readonly options;
+    private readonly logger;
+    constructor(options: BulkheadOptions);
+    /**
+     * Execute a function with bulkhead protection
+     */
+    execute<T>(fn: () => Promise<T>): Promise<T>;
+    /**
+     * Run an execution immediately
+     */
+    private runExecution;
+    /**
+     * Queue a request for later execution
+     */
+    private queueExecution;
+    /**
+     * Process queued requests
+     */
+    private processQueue;
+    /**
+     * Get bulkhead statistics
+     */
+    getStats(): BulkheadStats;
+    /**
+     * Check if bulkhead is at capacity
+     */
+    isAtCapacity(): boolean;
+    /**
+     * Check if queue is full
+     */
+    isQueueFull(): boolean;
+    /**
+     * Drain the queue (reject all pending)
+     */
+    drain(): void;
+}
+/**
+ * Create a bulkhead
+ */
+declare function createBulkhead(options: BulkheadOptions): Bulkhead;
+/**
+ * Bulkhead registry for managing multiple bulkheads
+ */
+declare class BulkheadRegistry {
+    private bulkheads;
+    private readonly logger;
+    private readonly defaultOptions;
+    constructor(options?: {
+        logger?: ILogger;
+        defaults?: Partial<BulkheadOptions>;
+    });
+    /**
+     * Get or create a bulkhead
+     */
+    get(name: string, options?: Partial<BulkheadOptions>): Bulkhead;
+    /**
+     * Execute with a named bulkhead
+     */
+    execute<T>(name: string, fn: () => Promise<T>, options?: Partial<BulkheadOptions>): Promise<T>;
+    /**
+     * Get all bulkhead statistics
+     */
+    getAllStats(): Record<string, BulkheadStats>;
+    /**
+     * Drain all bulkheads
+     */
+    drainAll(): void;
+    /**
+     * Clear all bulkheads
+     */
+    clear(): void;
+}
+
+/**
+ * Fallback Pattern Implementation
+ *
+ * Provides fallback strategies when primary operations fail.
+ */
+
+/**
+ * Fallback options
+ */
+interface FallbackOptions<T> {
+    /**
+     * Static fallback value
+     */
+    value?: T;
+    /**
+     * Fallback function (called with the error)
+     */
+    fallbackFn?: (error: Error) => T | Promise<T>;
+    /**
+     * Cache the fallback result
+     */
+    cache?: boolean;
+    /**
+     * Cache TTL in milliseconds
+     */
+    cacheTTL?: number;
+    /**
+     * Callback when fallback is used
+     */
+    onFallback?: (error: Error, fallbackValue: T) => void;
+    /**
+     * Errors to ignore (not trigger fallback)
+     */
+    ignoreErrors?: (error: Error) => boolean;
+    /**
+     * Logger for fallback events
+     */
+    logger?: ILogger;
+}
+/**
+ * Result of a fallback operation
+ */
+interface FallbackResult<T> {
+    /** The result value */
+    value: T;
+    /** Whether fallback was used */
+    usedFallback: boolean;
+    /** The original error (if fallback was used) */
+    error?: Error;
+    /** Whether the value came from cache */
+    cached?: boolean;
+}
+/**
+ * Execute with fallback
+ */
+declare function withFallback<T>(fn: () => Promise<T>, options: FallbackOptions<T>): Promise<T>;
+/**
+ * Execute with fallback and return detailed result
+ */
+declare function withFallbackResult<T>(fn: () => Promise<T>, options: FallbackOptions<T>): Promise<FallbackResult<T>>;
+/**
+ * Create a cached fallback
+ */
+declare function createCachedFallback<T>(options: {
+    getValue: () => Promise<T>;
+    cacheTTL?: number;
+    logger?: ILogger;
+}): () => Promise<T>;
+/**
+ * Fallback chain - try multiple fallbacks in order
+ */
+declare function withFallbackChain<T>(primary: () => Promise<T>, fallbacks: Array<() => Promise<T>>, options?: {
+    logger?: ILogger;
+    onFallback?: (index: number, error: Error) => void;
+}): Promise<T>;
+/**
+ * Common fallback strategies
+ */
+declare const FallbackStrategies: {
+    /**
+     * Return empty array
+     */
+    emptyArray: <T>() => FallbackOptions<T[]>;
+    /**
+     * Return null
+     */
+    nullable: <T>() => FallbackOptions<T | null>;
+    /**
+     * Return default value
+     */
+    defaultValue: <T>(value: T) => FallbackOptions<T>;
+    /**
+     * Return cached value from a cache function
+     */
+    fromCache: <T>(getCached: () => Promise<T | null>, defaultValue: T) => FallbackOptions<T>;
+    /**
+     * Degrade gracefully with partial data
+     */
+    degrade: <T>(getDegraded: (error: Error) => T) => FallbackOptions<T>;
+};
+
+/**
+ * Health Check HTTP Endpoints
+ *
+ * Provides standardized health check endpoints for Kubernetes probes
+ * and monitoring systems.
+ *
+ * Endpoints:
+ * - /health/live   - Liveness probe (is the process alive?)
+ * - /health/ready  - Readiness probe (can it serve traffic?)
+ * - /health/startup - Startup probe (has it finished initializing?)
+ * - /health        - Detailed health status for dashboards
+ */
+
+type HealthStatus = 'healthy' | 'degraded' | 'unhealthy';
+interface LivenessResponse {
+    status: 'ok' | 'error';
+}
+interface ReadinessResponse {
+    status: 'ok' | 'error';
+    checks: {
+        database: boolean;
+        cache: boolean;
+        storage: boolean;
+        email: boolean;
+        queue: boolean;
+    };
+}
+interface StartupResponse {
+    status: 'ok' | 'error';
+    ready: boolean;
+}
+interface ServiceHealth {
+    status: HealthStatus;
+    latencyMs?: number;
+    message?: string;
+    lastChecked?: string;
+}
+interface DetailedHealthResponse {
+    status: HealthStatus;
+    version: string;
+    environment: string;
+    uptime: number;
+    uptimeFormatted: string;
+    timestamp: string;
+    services: {
+        database: ServiceHealth;
+        cache: ServiceHealth;
+        storage: ServiceHealth;
+        email: ServiceHealth;
+        queue: ServiceHealth;
+    };
+    system?: {
+        memoryUsage: {
+            heapUsed: number;
+            heapTotal: number;
+            external: number;
+            rss: number;
+        };
+        cpuUsage?: {
+            user: number;
+            system: number;
+        };
+    };
+}
+interface HealthEndpoints {
+    /**
+     * Liveness probe - is the process alive?
+     * Returns 200 if alive, 503 if dead.
+     * K8s will restart the pod if this fails.
+     */
+    live(): Promise<LivenessResponse>;
+    /**
+     * Readiness probe - can it serve traffic?
+     * Returns 200 if ready, 503 if not ready.
+     * K8s will remove from load balancer if this fails.
+     */
+    ready(): Promise<ReadinessResponse>;
+    /**
+     * Startup probe - has it finished initializing?
+     * Returns 200 when startup is complete.
+     * K8s waits for this before starting liveness/readiness probes.
+     */
+    startup(): Promise<StartupResponse>;
+    /**
+     * Detailed health status for monitoring dashboards.
+     * Includes service-level health, latencies, and system metrics.
+     */
+    detailed(): Promise<DetailedHealthResponse>;
+    /**
+     * Mark startup as complete (call after initialization)
+     */
+    markStartupComplete(): void;
+    /**
+     * Get raw health status for custom integrations
+     */
+    getRawStatus(): Promise<PlatformHealthStatus>;
+}
+interface HealthEndpointsOptions {
+    /** Application version */
+    version?: string;
+    /** Environment name */
+    environment?: string;
+    /** Include system metrics in detailed response */
+    includeSystemMetrics?: boolean;
+    /** Custom health checks to include */
+    customChecks?: Record<string, () => Promise<boolean>>;
+    /** Timeout for individual health checks (ms) */
+    checkTimeout?: number;
+}
+declare function createHealthEndpoints(platform: IPlatform, options?: HealthEndpointsOptions): HealthEndpoints;
+/**
+ * Create Express-compatible health route handlers
+ */
+declare function createExpressHealthHandlers(endpoints: HealthEndpoints): {
+    live: (_req: unknown, res: {
+        status: (code: number) => {
+            json: (data: unknown) => void;
+        };
+    }) => Promise<void>;
+    ready: (_req: unknown, res: {
+        status: (code: number) => {
+            json: (data: unknown) => void;
+        };
+    }) => Promise<void>;
+    startup: (_req: unknown, res: {
+        status: (code: number) => {
+            json: (data: unknown) => void;
+        };
+    }) => Promise<void>;
+    detailed: (_req: unknown, res: {
+        status: (code: number) => {
+            json: (data: unknown) => void;
+        };
+    }) => Promise<void>;
+};
+/**
+ * Create a simple HTTP server for health checks (standalone, no framework)
+ */
+declare function createHealthServer(endpoints: HealthEndpoints, port?: number): Promise<{
+    close: () => Promise<void>;
+}>;
+
+/**
+ * Prometheus Metrics HTTP Endpoint
+ *
+ * Provides a /metrics endpoint that exports metrics in Prometheus text format.
+ * This enables scraping by Prometheus, Grafana Agent, or other compatible systems.
+ *
+ * @example
+ * ```typescript
+ * import { createMetricsEndpoint } from '@digilogiclabs/platform-core';
+ *
+ * const metricsEndpoint = createMetricsEndpoint(platform.metrics, {
+ *   prefix: 'myapp',
+ *   defaultLabels: { service: 'api', environment: 'production' },
+ * });
+ *
+ * // Get Prometheus format output
+ * const prometheusText = metricsEndpoint.getPrometheusMetrics();
+ *
+ * // Or use the built-in server
+ * const server = await createMetricsServer(metricsEndpoint, 9090);
+ * ```
+ */
+
+interface MetricsEndpointOptions {
+    /** Prefix for all metric names */
+    prefix?: string;
+    /** Default labels to add to all metrics */
+    defaultLabels?: Record<string, string>;
+    /** Include process metrics (memory, cpu, etc.) */
+    includeProcessMetrics?: boolean;
+    /** Include Node.js event loop metrics */
+    includeEventLoopMetrics?: boolean;
+    /** Histogram buckets for timing metrics */
+    histogramBuckets?: number[];
+}
+interface MetricsEndpoint {
+    /**
+     * Get metrics in Prometheus text exposition format
+     */
+    getPrometheusMetrics(): string;
+    /**
+     * Get metrics as JSON (for debugging)
+     */
+    getJsonMetrics(): MetricsSummary;
+    /**
+     * Record a custom metric
+     */
+    recordMetric(type: 'counter' | 'gauge' | 'histogram', name: string, value: number, labels?: Record<string, string>): void;
+}
+declare function createMetricsEndpoint(metrics: IMetrics, options?: MetricsEndpointOptions): MetricsEndpoint;
+/**
+ * Create Express-compatible metrics handler
+ */
+declare function createExpressMetricsHandler(endpoint: MetricsEndpoint): (_req: unknown, res: {
+    setHeader: (name: string, value: string) => void;
+    status: (code: number) => {
+        send: (data: string) => void;
+    };
+}) => void;
+/**
+ * Create a standalone HTTP server for metrics (no framework required)
+ */
+declare function createMetricsServer(endpoint: MetricsEndpoint, port?: number): Promise<{
+    close: () => Promise<void>;
+    port: number;
+}>;
+
+/**
+ * Create a combined server that serves both health and metrics endpoints
+ *
+ * Endpoints:
+ * - /health/live, /healthz - Liveness probe
+ * - /health/ready, /readyz - Readiness probe
+ * - /health/startup, /startupz - Startup probe
+ * - /health - Detailed health
+ * - /metrics - Prometheus metrics
+ * - /metrics.json - JSON metrics (debugging)
+ */
+declare function createObservabilityServer(healthEndpoints: HealthEndpoints, metricsEndpoint: MetricsEndpoint, port?: number): Promise<{
+    close: () => Promise<void>;
+    port: number;
+}>;
+
+/**
+ * Supabase Database Adapter
+ * Production implementation using Supabase as the database provider
+ */
+
+declare class SupabaseDatabase implements IDatabase {
+    private client;
+    constructor(client: SupabaseClient);
+    from<T = unknown>(table: string): IQueryBuilder<T>;
+    raw<T = unknown>(sql: string, params?: unknown[]): Promise<QueryResult<T>>;
+    transaction<T>(fn: (tx: IDatabase) => Promise<T>): Promise<T>;
+    healthCheck(): Promise<boolean>;
+    close(): Promise<void>;
+}
+
+/**
+ * PostgreSQL Direct Database Adapter
+ *
+ * Production implementation using pg (node-postgres) for direct PostgreSQL connections.
+ * Provides true ACID transaction support, connection pooling, and prepared statements.
+ *
+ * This adapter is vendor-agnostic - works with any PostgreSQL-compatible database:
+ * - PostgreSQL (self-hosted or managed)
+ * - Amazon RDS PostgreSQL
+ * - Azure Database for PostgreSQL
+ * - Google Cloud SQL for PostgreSQL
+ * - CockroachDB (PostgreSQL wire protocol)
+ * - YugabyteDB
+ * - Neon, Supabase (direct connection, not REST)
+ */
+
+interface PostgresConfig {
+    /** Connection string (postgresql://user:pass@host:port/database) */
+    connectionString?: string;
+    /** Host name */
+    host?: string;
+    /** Port number */
+    port?: number;
+    /** Database name */
+    database?: string;
+    /** Username */
+    user?: string;
+    /** Password */
+    password?: string;
+    /** SSL configuration */
+    ssl?: boolean | {
+        rejectUnauthorized?: boolean;
+        ca?: string;
+    };
+    /** Maximum number of connections in pool */
+    max?: number;
+    /** Idle timeout in milliseconds */
+    idleTimeoutMillis?: number;
+    /** Connection timeout in milliseconds */
+    connectionTimeoutMillis?: number;
+    /** Statement timeout in milliseconds (0 = no limit) */
+    statementTimeout?: number;
+    /** Query timeout in milliseconds (0 = no limit) */
+    queryTimeout?: number;
+    /** Application name for connection identification */
+    applicationName?: string;
+}
+declare class PostgresDatabase implements IDatabase {
+    private pool;
+    private config;
+    constructor(pool: Pool, config?: PostgresConfig);
+    /**
+     * Create a PostgresDatabase from configuration
+     */
+    static create(config: PostgresConfig): Promise<PostgresDatabase>;
+    /**
+     * Create from environment variables
+     */
+    static fromEnv(): Promise<PostgresDatabase>;
+    from<T = unknown>(table: string): IQueryBuilder<T>;
+    raw<T = unknown>(sql: string, params?: unknown[]): Promise<QueryResult<T>>;
+    /**
+     * Execute a function within a database transaction.
+     * Provides true ACID guarantees - either all operations succeed or all are rolled back.
+     */
+    transaction<T>(fn: (tx: IDatabase) => Promise<T>): Promise<T>;
+    healthCheck(): Promise<boolean>;
+    close(): Promise<void>;
+    /**
+     * Get pool statistics for monitoring
+     */
+    getPoolStats(): {
+        totalCount: number;
+        idleCount: number;
+        waitingCount: number;
+    };
+}
+
+/**
+ * Upstash Redis Cache Adapter
+ * Production implementation using Upstash Redis REST API
+ */
+
+declare class UpstashCache implements ICache {
+    private client;
+    constructor(client: Redis);
+    get<T = unknown>(key: string): Promise<T | null>;
+    set<T = unknown>(key: string, value: T, ttl?: number): Promise<void>;
+    delete(key: string): Promise<void>;
+    exists(key: string): Promise<boolean>;
+    deletePattern(pattern: string): Promise<number>;
+    mget<T = unknown>(keys: string[]): Promise<(T | null)[]>;
+    mset<T = unknown>(entries: Array<{
+        key: string;
+        value: T;
+        ttl?: number;
+    }>): Promise<void>;
+    incr(key: string, by?: number): Promise<number>;
+    publish(channel: string, message: string): Promise<void>;
+    subscribe(channel: string, callback: (message: string) => void): Promise<() => void>;
+    healthCheck(): Promise<boolean>;
+    close(): Promise<void>;
+}
+
+/**
+ * Redis Direct Cache Adapter
+ *
+ * Production implementation using ioredis for direct Redis connections.
+ * Provides lower latency than REST-based solutions, true pub/sub support,
+ * and full Redis command set.
+ *
+ * This adapter is vendor-agnostic - works with any Redis-compatible server:
+ * - Redis (self-hosted or managed)
+ * - Amazon ElastiCache for Redis
+ * - Azure Cache for Redis
+ * - Google Cloud Memorystore for Redis
+ * - Redis Enterprise
+ * - KeyDB
+ * - DragonflyDB
+ */
+
+interface RedisConfig {
+    /** Connection URL (redis://user:pass@host:port/db) */
+    url?: string;
+    /** Host name */
+    host?: string;
+    /** Port number */
+    port?: number;
+    /** Password */
+    password?: string;
+    /** Database number (0-15) */
+    db?: number;
+    /** Username (Redis 6+) */
+    username?: string;
+    /** Connection name for identification */
+    name?: string;
+    /** Key prefix for namespacing */
+    keyPrefix?: string;
+    /** Enable TLS */
+    tls?: boolean | {
+        rejectUnauthorized?: boolean;
+        ca?: string;
+    };
+    /** Connection timeout in milliseconds */
+    connectTimeout?: number;
+    /** Command timeout in milliseconds */
+    commandTimeout?: number;
+    /** Keep alive timeout */
+    keepAlive?: number;
+    /** Max retries per request */
+    maxRetriesPerRequest?: number;
+    /** Enable auto-reconnect */
+    autoReconnect?: boolean;
+    /** Lazy connect (don't connect until first command) */
+    lazyConnect?: boolean;
+    /** Enable offline queue */
+    enableOfflineQueue?: boolean;
+    /** Sentinel configuration for HA */
+    sentinel?: {
+        sentinels: Array<{
+            host: string;
+            port: number;
+        }>;
+        name: string;
+        password?: string;
+    };
+    /** Cluster configuration */
+    cluster?: {
+        nodes: Array<{
+            host: string;
+            port: number;
+        }>;
+        options?: {
+            scaleReads?: 'master' | 'slave' | 'all';
+            maxRedirections?: number;
+        };
+    };
+}
+declare class RedisCache implements ICache {
+    private client;
+    private subscriberClient;
+    private config;
+    private subscriptions;
+    constructor(client: Redis$1, config?: RedisConfig);
+    /**
+     * Create a RedisCache from configuration
+     */
+    static create(config: RedisConfig): Promise<RedisCache>;
+    /**
+     * Create from environment variables
+     */
+    static fromEnv(): Promise<RedisCache>;
+    get<T = unknown>(key: string): Promise<T | null>;
+    set<T = unknown>(key: string, value: T, ttl?: number): Promise<void>;
+    delete(key: string): Promise<void>;
+    exists(key: string): Promise<boolean>;
+    deletePattern(pattern: string): Promise<number>;
+    mget<T = unknown>(keys: string[]): Promise<(T | null)[]>;
+    mset<T = unknown>(entries: Array<{
+        key: string;
+        value: T;
+        ttl?: number;
+    }>): Promise<void>;
+    incr(key: string, by?: number): Promise<number>;
+    publish(channel: string, message: string): Promise<void>;
+    subscribe(channel: string, callback: (message: string) => void): Promise<() => void>;
+    healthCheck(): Promise<boolean>;
+    close(): Promise<void>;
+    /**
+     * Get connection info for monitoring
+     */
+    getConnectionInfo(): {
+        status: string;
+        host?: string;
+        port?: number;
+    };
+    /**
+     * Execute arbitrary Redis command
+     */
+    command<T = unknown>(command: string, ...args: unknown[]): Promise<T>;
+    /**
+     * Get TTL of a key
+     */
+    ttl(key: string): Promise<number>;
+    /**
+     * Set expiry on an existing key
+     */
+    expire(key: string, seconds: number): Promise<boolean>;
+    /**
+     * Get all keys matching a pattern (use with caution in production)
+     */
+    keys(pattern: string): Promise<string[]>;
+}
+
+/**
+ * S3 Storage Adapter
+ * Production implementation using AWS S3 (compatible with MinIO, R2, etc.)
+ */
+
+declare class S3Storage implements IStorage {
+    private client;
+    private bucket;
+    private publicUrl?;
+    private signedUrlFn;
+    constructor(client: S3Client, bucket: string, getSignedUrlFn: typeof getSignedUrl, publicUrl?: string);
+    upload(key: string, data: Buffer | Blob | ReadableStream, options?: UploadOptions): Promise<{
+        url: string;
+    }>;
+    download(key: string): Promise<Buffer>;
+    getSignedUrl(key: string, expiresIn?: number): Promise<string>;
+    private createSignedUrl;
+    delete(key: string): Promise<void>;
+    deleteMany(keys: string[]): Promise<void>;
+    list(prefix?: string): Promise<StorageFile[]>;
+    exists(key: string): Promise<boolean>;
+    getMetadata(key: string): Promise<StorageFile | null>;
+    healthCheck(): Promise<boolean>;
+}
+
+/**
+ * Supabase Storage Adapter
+ *
+ * Production implementation using Supabase Storage for file management.
+ * Provides vendor-agnostic file storage via Supabase's storage buckets.
+ *
+ * Features:
+ * - Simple bucket-based file storage
+ * - Automatic public URL generation
+ * - Signed URL support for private files
+ * - Built-in CDN caching
+ */
+
+interface SupabaseStorageConfig {
+    /** Supabase project URL */
+    url: string;
+    /** Supabase API key (anon or service role) */
+    apiKey: string;
+    /** Default bucket name */
+    bucket: string;
+    /** Whether the bucket is public */
+    publicBucket?: boolean;
+    /** Default signed URL expiry in seconds */
+    signedUrlExpiry?: number;
+}
+declare class SupabaseStorage implements IStorage {
+    private client;
+    private bucket;
+    private publicBucket;
+    private signedUrlExpiry;
+    constructor(client: SupabaseClient, config: {
+        bucket: string;
+        publicBucket?: boolean;
+        signedUrlExpiry?: number;
+    });
+    /**
+     * Create a SupabaseStorage adapter from configuration
+     */
+    static create(config: SupabaseStorageConfig): Promise<SupabaseStorage>;
+    /**
+     * Create from environment variables
+     */
+    static fromEnv(): Promise<SupabaseStorage>;
+    upload(key: string, data: Buffer | Blob | ReadableStream, options?: UploadOptions): Promise<{
+        url: string;
+    }>;
+    download(path: string): Promise<Buffer>;
+    delete(path: string): Promise<void>;
+    deleteMany(paths: string[]): Promise<void>;
+    getMetadata(path: string): Promise<StorageFile | null>;
+    exists(path: string): Promise<boolean>;
+    list(prefix?: string): Promise<StorageFile[]>;
+    getSignedUrl(path: string, expiresIn?: number): Promise<string>;
+    healthCheck(): Promise<boolean>;
+    /**
+     * Get URL for a file (public URL or signed URL based on bucket config)
+     */
+    private getUrl;
+    /**
+     * Get directory from path
+     */
+    private getDirectory;
+    /**
+     * Get filename from path
+     */
+    private getFilename;
+    /**
+     * Get storage bucket info
+     */
+    getBucketInfo(): {
+        bucket: string;
+        publicBucket: boolean;
+    };
+    /**
+     * Copy file to new location
+     */
+    copy(sourcePath: string, destPath: string): Promise<{
+        key: string;
+        url: string;
+    }>;
+    /**
+     * Move file to new location
+     */
+    move(sourcePath: string, destPath: string): Promise<{
+        key: string;
+        url: string;
+    }>;
+}
+
+/**
+ * Resend Email Adapter
+ * Production implementation using Resend for transactional emails
+ */
+
+declare class ResendEmail implements IEmail {
+    private client;
+    private defaultFrom;
+    constructor(client: Resend, defaultFrom?: string);
+    send(message: EmailMessage): Promise<EmailResult>;
+    sendBatch(messages: EmailMessage[]): Promise<EmailResult[]>;
+    healthCheck(): Promise<boolean>;
+    private formatAddress;
+    private formatAddresses;
+}
+
+/**
+ * SMTP Email Adapter
+ *
+ * Production implementation using nodemailer for direct SMTP connections.
+ * Provides vendor-agnostic email sending via standard SMTP protocol.
+ *
+ * Compatible with any SMTP server:
+ * - Self-hosted mail servers (Postfix, Sendmail)
+ * - Gmail SMTP
+ * - Amazon SES (SMTP interface)
+ * - SendGrid SMTP
+ * - Mailgun SMTP
+ * - Microsoft 365 SMTP
+ * - Any standard SMTP relay
+ */
+
+interface SmtpConfig {
+    /** SMTP host */
+    host: string;
+    /** SMTP port (typically 25, 465, or 587) */
+    port: number;
+    /** Use TLS/SSL */
+    secure?: boolean;
+    /** SMTP username */
+    username?: string;
+    /** SMTP password */
+    password?: string;
+    /** Default from address */
+    from?: string;
+    /** Connection timeout in milliseconds */
+    connectionTimeout?: number;
+    /** Socket timeout in milliseconds */
+    socketTimeout?: number;
+    /** Enable debug logging */
+    debug?: boolean;
+    /** Reject unauthorized certificates */
+    rejectUnauthorized?: boolean;
+}
+declare class SmtpEmail implements IEmail {
+    private transporter;
+    private config;
+    constructor(config: SmtpConfig);
+    /**
+     * Create an SmtpEmail adapter from configuration
+     */
+    static create(config: SmtpConfig): Promise<SmtpEmail>;
+    /**
+     * Create from environment variables
+     */
+    static fromEnv(): Promise<SmtpEmail>;
+    /**
+     * Initialize the SMTP transporter
+     */
+    private initialize;
+    send(message: EmailMessage): Promise<EmailResult>;
+    sendBatch(messages: EmailMessage[]): Promise<EmailResult[]>;
+    healthCheck(): Promise<boolean>;
+    /**
+     * Close the transporter and release connections
+     */
+    close(): Promise<void>;
+    /**
+     * Get transporter info for debugging
+     */
+    getTransporterInfo(): {
+        host: string;
+        port: number;
+        secure: boolean;
+    };
+}
+
+/**
+ * BullMQ Queue Adapter
+ * Production queue implementation using BullMQ (Redis-backed)
+ */
+
+interface BullMQConfig {
+    /** Redis connection URL */
+    redisUrl?: string;
+    /** Redis host */
+    host?: string;
+    /** Redis port */
+    port?: number;
+    /** Redis password */
+    password?: string;
+    /** Redis database number */
+    db?: number;
+    /** Queue name */
+    queueName: string;
+    /** Default job options */
+    defaultJobOptions?: JobOptions;
+}
+/**
+ * BullMQ Queue Adapter
+ * Requires: pnpm add bullmq ioredis
+ */
+declare class BullMQQueue<T = unknown> implements IQueue<T> {
+    private queue;
+    private worker;
+    private config;
+    private initialized;
+    constructor(config: BullMQConfig);
+    /**
+     * Initialize the queue (called lazily on first use)
+     */
+    private ensureInitialized;
+    private getConnectionConfig;
+    add(name: string, data: T, options?: JobOptions): Promise<Job<T>>;
+    addBulk(jobs: Array<{
+        name: string;
+        data: T;
+        options?: JobOptions;
+    }>): Promise<Job<T>[]>;
+    process(handler: (job: Job<T>) => Promise<unknown>): void;
+    private startWorker;
+    getJob(id: string): Promise<Job<T> | null>;
+    removeJob(id: string): Promise<void>;
+    pause(): Promise<void>;
+    resume(): Promise<void>;
+    getStats(): Promise<{
+        waiting: number;
+        active: number;
+        completed: number;
+        failed: number;
+        delayed: number;
+    }>;
+    healthCheck(): Promise<boolean>;
+    close(): Promise<void>;
+    private mapJob;
+}
+
+export { Bulkhead, type BulkheadOptions, BulkheadRegistry, BulkheadRejectedError, type BulkheadStats, type BullMQConfig, BullMQQueue, CircuitBreaker, type CircuitBreakerOptions, CircuitBreakerRegistry, type CircuitBreakerStats, CircuitOpenError, type CircuitState, DEFAULT_BULKHEAD_OPTIONS, DEFAULT_CIRCUIT_BREAKER_OPTIONS, DEFAULT_RETRY_OPTIONS, DefaultTimeouts, type DeleteHookContext, type DetailedHealthResponse, type EmailHookContext, EmailMessage, EmailResult, type ErrorHookContext, type FallbackOptions, type FallbackResult, FallbackStrategies, type HealthCheckResult, type HealthEndpoints, type HealthEndpointsOptions, type HealthStatus, type HookRegistry, ICache, IDatabase, IEmail, type IHealth, type IHealthCheckable, ILogger, IMetrics, IPlatform, IQueryBuilder, IQueue, IStorage, type InsertHookContext, Job, type JobHookContext, JobOptions, type LivenessResponse, MemoryRateLimiterStorage, type MetricsEndpoint, type MetricsEndpointOptions, MetricsSummary, type Middleware, type MiddlewareChain, type MiddlewareChainOptions, type MiddlewareContext, type PlatformHealthResult, PlatformHealthStatus, type PlatformHooks, type PostgresConfig, PostgresDatabase, type QueryHookContext, QueryResult, type RateLimitAlgorithm, RateLimitError, type RateLimitInfo, type RateLimitOptions, RateLimitPresets, type RateLimiterStorage, type ReadinessResponse, RedisCache, type RedisConfig, ResendEmail, RetryConfigs, type RetryOptions, RetryPredicates, type RetryResult, S3Storage, type ServiceHealth, type SlidingWindowRateLimitOptions, type SmtpConfig, SmtpEmail, type StartupResponse, StorageFile, SupabaseDatabase, SupabaseStorage, type SupabaseStorageConfig, TimeoutError, type TimeoutOptions, type TokenBucketOptions, type UpdateHookContext, type UploadHookContext, UploadOptions, UpstashCache, composeHookRegistries, createBulkhead, createCacheMiddleware, createCachedFallback, createCircuitBreaker, createExpressHealthHandlers, createExpressMetricsHandler, createHealthEndpoints, createHealthServer, createHookRegistry, createIpKeyGenerator, createLoggingMiddleware, createMetricsEndpoint, createMetricsMiddleware, createMetricsServer, createMiddlewareChain, createMiddlewareContext, createObservabilityServer, createRateLimitMiddleware, createRequestIdMiddleware, createSlowQueryMiddleware, createTenantMiddleware, createTimeoutMiddleware, createUserKeyGenerator, raceTimeout, retryable, timedHealthCheck, toHealthCheckResult, withFallback, withFallbackChain, withFallbackResult, withRetry, withRetryResult, withTimeout, withTimeoutWrapper };