@digilogiclabs/platform-core 1.0.0

package/dist/ConsoleEmail-XeUBAnwc.d.mts

@@ -0,0 +1,2786 @@
+import { z } from 'zod';
+
+/**
+ * Database abstraction interface
+ * Provides a vendor-agnostic way to interact with SQL databases
+ */
+interface QueryResult<T = unknown> {
+    data: T[];
+    count?: number;
+    error?: Error;
+}
+interface IDatabase {
+    /**
+     * Query data from a table
+     */
+    from<T = unknown>(table: string): IQueryBuilder<T>;
+    /**
+     * Execute a raw SQL query
+     */
+    raw<T = unknown>(sql: string, params?: unknown[]): Promise<QueryResult<T>>;
+    /**
+     * Begin a transaction
+     */
+    transaction<T>(fn: (tx: IDatabase) => Promise<T>): Promise<T>;
+    /**
+     * Check database connectivity
+     */
+    healthCheck(): Promise<boolean>;
+    /**
+     * Close database connection
+     */
+    close(): Promise<void>;
+}
+interface IQueryBuilder<T = unknown> {
+    select(columns?: string | string[]): IQueryBuilder<T>;
+    insert(data: Partial<T> | Partial<T>[]): IQueryBuilder<T>;
+    update(data: Partial<T>): IQueryBuilder<T>;
+    delete(): IQueryBuilder<T>;
+    where(column: string, operator: string, value: unknown): IQueryBuilder<T>;
+    whereIn(column: string, values: unknown[]): IQueryBuilder<T>;
+    orderBy(column: string, direction?: 'asc' | 'desc'): IQueryBuilder<T>;
+    limit(count: number): IQueryBuilder<T>;
+    offset(count: number): IQueryBuilder<T>;
+    single(): Promise<{
+        data: T | null;
+        error?: Error;
+    }>;
+    execute(): Promise<QueryResult<T>>;
+}
+
+/**
+ * Cache abstraction interface
+ * Provides a vendor-agnostic way to interact with key-value caches
+ */
+interface ICacheOptions {
+    /** Time to live in seconds */
+    ttl?: number;
+    /** Cache key prefix */
+    prefix?: string;
+}
+interface ICache {
+    /**
+     * Get a value from cache
+     */
+    get<T = unknown>(key: string): Promise<T | null>;
+    /**
+     * Set a value in cache
+     */
+    set<T = unknown>(key: string, value: T, ttl?: number): Promise<void>;
+    /**
+     * Delete a value from cache
+     */
+    delete(key: string): Promise<void>;
+    /**
+     * Check if key exists
+     */
+    exists(key: string): Promise<boolean>;
+    /**
+     * Delete all keys matching pattern
+     */
+    deletePattern(pattern: string): Promise<number>;
+    /**
+     * Get multiple values
+     */
+    mget<T = unknown>(keys: string[]): Promise<(T | null)[]>;
+    /**
+     * Set multiple values
+     */
+    mset<T = unknown>(entries: Array<{
+        key: string;
+        value: T;
+        ttl?: number;
+    }>): Promise<void>;
+    /**
+     * Increment a numeric value
+     */
+    incr(key: string, by?: number): Promise<number>;
+    /**
+     * Publish a message to a channel
+     */
+    publish(channel: string, message: string): Promise<void>;
+    /**
+     * Subscribe to a channel
+     */
+    subscribe(channel: string, callback: (message: string) => void): Promise<() => void>;
+    /**
+     * Check cache connectivity
+     */
+    healthCheck(): Promise<boolean>;
+    /**
+     * Close cache connection
+     */
+    close(): Promise<void>;
+}
+
+/**
+ * Storage abstraction interface
+ * Provides a vendor-agnostic way to interact with file/blob storage
+ */
+interface StorageFile {
+    key: string;
+    size: number;
+    contentType?: string;
+    lastModified?: Date;
+    etag?: string;
+}
+interface UploadOptions {
+    contentType?: string;
+    metadata?: Record<string, string>;
+    public?: boolean;
+}
+interface IStorage {
+    /**
+     * Upload a file
+     */
+    upload(key: string, data: Buffer | Blob | ReadableStream, options?: UploadOptions): Promise<{
+        url: string;
+    }>;
+    /**
+     * Download a file
+     */
+    download(key: string): Promise<Buffer>;
+    /**
+     * Get a signed URL for download
+     */
+    getSignedUrl(key: string, expiresIn?: number): Promise<string>;
+    /**
+     * Delete a file
+     */
+    delete(key: string): Promise<void>;
+    /**
+     * Delete multiple files
+     */
+    deleteMany(keys: string[]): Promise<void>;
+    /**
+     * List files in a path
+     */
+    list(prefix?: string): Promise<StorageFile[]>;
+    /**
+     * Check if file exists
+     */
+    exists(key: string): Promise<boolean>;
+    /**
+     * Get file metadata
+     */
+    getMetadata(key: string): Promise<StorageFile | null>;
+    /**
+     * Check storage connectivity
+     */
+    healthCheck(): Promise<boolean>;
+}
+
+/**
+ * Email abstraction interface
+ * Provides a vendor-agnostic way to send emails
+ */
+interface EmailAddress {
+    email: string;
+    name?: string;
+}
+interface EmailAttachment {
+    filename: string;
+    content: Buffer | string;
+    contentType?: string;
+}
+interface EmailMessage {
+    to: EmailAddress | EmailAddress[];
+    from?: EmailAddress;
+    replyTo?: EmailAddress;
+    subject: string;
+    text?: string;
+    html?: string;
+    attachments?: EmailAttachment[];
+    headers?: Record<string, string>;
+    tags?: string[];
+}
+interface EmailResult {
+    id: string;
+    success: boolean;
+    error?: Error;
+}
+interface IEmail {
+    /**
+     * Send an email
+     */
+    send(message: EmailMessage): Promise<EmailResult>;
+    /**
+     * Send multiple emails (batch)
+     */
+    sendBatch(messages: EmailMessage[]): Promise<EmailResult[]>;
+    /**
+     * Check email service connectivity
+     */
+    healthCheck(): Promise<boolean>;
+}
+
+/**
+ * Queue abstraction interface
+ * Provides a vendor-agnostic way to work with job queues
+ */
+interface JobOptions {
+    /** Delay before job is processed (ms) */
+    delay?: number;
+    /** Number of retry attempts */
+    attempts?: number;
+    /** Backoff strategy */
+    backoff?: {
+        type: 'fixed' | 'exponential';
+        delay: number;
+    };
+    /** Job priority (higher = more priority) */
+    priority?: number;
+    /** Remove job after completion */
+    removeOnComplete?: boolean | number;
+    /** Remove job after failure */
+    removeOnFail?: boolean | number;
+}
+interface Job<T = unknown> {
+    id: string;
+    name: string;
+    data: T;
+    attemptsMade: number;
+    progress: number;
+    timestamp: number;
+}
+interface JobResult<T = unknown> {
+    jobId: string;
+    result?: T;
+    error?: Error;
+}
+interface IQueue<T = unknown> {
+    /**
+     * Add a job to the queue
+     */
+    add(name: string, data: T, options?: JobOptions): Promise<Job<T>>;
+    /**
+     * Add multiple jobs
+     */
+    addBulk(jobs: Array<{
+        name: string;
+        data: T;
+        options?: JobOptions;
+    }>): Promise<Job<T>[]>;
+    /**
+     * Process jobs
+     */
+    process(handler: (job: Job<T>) => Promise<unknown>): void;
+    /**
+     * Get a job by ID
+     */
+    getJob(id: string): Promise<Job<T> | null>;
+    /**
+     * Remove a job
+     */
+    removeJob(id: string): Promise<void>;
+    /**
+     * Pause the queue
+     */
+    pause(): Promise<void>;
+    /**
+     * Resume the queue
+     */
+    resume(): Promise<void>;
+    /**
+     * Get queue statistics
+     */
+    getStats(): Promise<{
+        waiting: number;
+        active: number;
+        completed: number;
+        failed: number;
+        delayed: number;
+    }>;
+    /**
+     * Check queue connectivity
+     */
+    healthCheck(): Promise<boolean>;
+    /**
+     * Close queue connection
+     */
+    close(): Promise<void>;
+}
+
+/**
+ * Logger Interface
+ * Standardizes logging across the platform
+ */
+/**
+ * Log levels in order of severity
+ */
+type LogLevel = 'debug' | 'info' | 'warn' | 'error';
+/**
+ * Metadata that can be attached to log entries
+ */
+interface LogMeta {
+    /** Error object if logging an error */
+    error?: Error;
+    /** Duration in milliseconds (for timing operations) */
+    duration?: number;
+    /** Request ID for tracing */
+    requestId?: string;
+    /** User ID if applicable */
+    userId?: string;
+    /** Any additional key-value pairs */
+    [key: string]: unknown;
+}
+/**
+ * A structured log entry
+ */
+interface LogEntry {
+    /** Log level */
+    level: LogLevel;
+    /** Log message */
+    message: string;
+    /** When the log was created */
+    timestamp: Date;
+    /** Optional metadata */
+    meta?: LogMeta;
+    /** Logger context (e.g., service name) */
+    context?: Record<string, unknown>;
+}
+/**
+ * Logger interface for structured logging
+ */
+interface ILogger {
+    /**
+     * Log a debug message (for development/troubleshooting)
+     */
+    debug(message: string, meta?: LogMeta): void;
+    /**
+     * Log an informational message
+     */
+    info(message: string, meta?: LogMeta): void;
+    /**
+     * Log a warning message
+     */
+    warn(message: string, meta?: LogMeta): void;
+    /**
+     * Log an error message
+     */
+    error(message: string, meta?: LogMeta): void;
+    /**
+     * Create a child logger with additional context
+     * @param context Additional context to include in all logs from this child
+     */
+    child(context: Record<string, unknown>): ILogger;
+}
+/**
+ * Configuration options for loggers
+ */
+interface LoggerConfig {
+    /** Minimum level to log */
+    level?: LogLevel;
+    /** Whether to pretty print (for development) */
+    pretty?: boolean;
+    /** Service name to include in logs */
+    service?: string;
+    /** Environment name */
+    environment?: string;
+}
+/**
+ * Console logger implementation (for development)
+ */
+declare class ConsoleLogger implements ILogger {
+    private context;
+    private level;
+    private static levelPriority;
+    constructor(config?: LoggerConfig);
+    private shouldLog;
+    private log;
+    debug(message: string, meta?: LogMeta): void;
+    info(message: string, meta?: LogMeta): void;
+    warn(message: string, meta?: LogMeta): void;
+    error(message: string, meta?: LogMeta): void;
+    child(context: Record<string, unknown>): ILogger;
+}
+/**
+ * No-op logger for testing or when logging is disabled
+ */
+declare class NoopLogger implements ILogger {
+    debug(): void;
+    info(): void;
+    warn(): void;
+    error(): void;
+    child(): ILogger;
+}
+
+/**
+ * Metrics Interface
+ *
+ * Provides observability through counters, gauges, histograms, and timers.
+ */
+/**
+ * Tags for metrics (key-value pairs for dimensions)
+ */
+type MetricTags = Record<string, string | number | boolean>;
+/**
+ * Metrics interface for observability
+ */
+interface IMetrics {
+    /**
+     * Increment a counter by a value (default 1)
+     *
+     * @example
+     * metrics.increment('api.requests', 1, { method: 'GET', path: '/users' })
+     */
+    increment(name: string, value?: number, tags?: MetricTags): void;
+    /**
+     * Decrement a counter by a value (default 1)
+     *
+     * @example
+     * metrics.decrement('active.connections', 1, { server: 'api-1' })
+     */
+    decrement(name: string, value?: number, tags?: MetricTags): void;
+    /**
+     * Set a gauge to a specific value
+     *
+     * @example
+     * metrics.gauge('queue.size', 42, { queue: 'emails' })
+     */
+    gauge(name: string, value: number, tags?: MetricTags): void;
+    /**
+     * Record a value in a histogram (for distributions)
+     *
+     * @example
+     * metrics.histogram('response.size', 1024, { endpoint: '/api/users' })
+     */
+    histogram(name: string, value: number, tags?: MetricTags): void;
+    /**
+     * Record a timing value in milliseconds
+     *
+     * @example
+     * metrics.timing('db.query.duration', 42, { table: 'users' })
+     */
+    timing(name: string, value: number, tags?: MetricTags): void;
+    /**
+     * Start a timer and return a function to stop it
+     *
+     * @example
+     * const stop = metrics.startTimer('api.request.duration', { method: 'GET' })
+     * // ... do work ...
+     * stop() // Records the duration
+     */
+    startTimer(name: string, tags?: MetricTags): () => void;
+    /**
+     * Record a distribution value (similar to histogram but for Datadog)
+     *
+     * @example
+     * metrics.distribution('payment.amount', 99.99, { currency: 'USD' })
+     */
+    distribution?(name: string, value: number, tags?: MetricTags): void;
+    /**
+     * Record a set value (count unique elements)
+     *
+     * @example
+     * metrics.set('unique.users', 'user-123')
+     */
+    set?(name: string, value: string | number, tags?: MetricTags): void;
+    /**
+     * Flush all pending metrics to the backend
+     */
+    flush(): Promise<void>;
+    /**
+     * Close the metrics client
+     */
+    close(): Promise<void>;
+}
+/**
+ * Memory-based metrics implementation for testing
+ */
+declare class MemoryMetrics implements IMetrics {
+    private counters;
+    private gauges;
+    private histograms;
+    private timings;
+    private sets;
+    increment(name: string, value?: number, tags?: MetricTags): void;
+    decrement(name: string, value?: number, tags?: MetricTags): void;
+    gauge(name: string, value: number, tags?: MetricTags): void;
+    histogram(name: string, value: number, tags?: MetricTags): void;
+    timing(name: string, value: number, tags?: MetricTags): void;
+    startTimer(name: string, tags?: MetricTags): () => void;
+    distribution(name: string, value: number, tags?: MetricTags): void;
+    set(name: string, value: string | number, tags?: MetricTags): void;
+    flush(): Promise<void>;
+    close(): Promise<void>;
+    /**
+     * Get counter value
+     */
+    getCounter(name: string, tags?: MetricTags): number;
+    /**
+     * Get gauge value
+     */
+    getGauge(name: string, tags?: MetricTags): number | undefined;
+    /**
+     * Get histogram values
+     */
+    getHistogram(name: string, tags?: MetricTags): number[];
+    /**
+     * Get timing values
+     */
+    getTiming(name: string, tags?: MetricTags): number[];
+    /**
+     * Get set size
+     */
+    getSetSize(name: string, tags?: MetricTags): number;
+    /**
+     * Get all metrics as a summary
+     */
+    getSummary(): MetricsSummary;
+    /**
+     * Reset all metrics
+     */
+    reset(): void;
+    private createKey;
+    private percentile;
+}
+/**
+ * No-op metrics implementation
+ */
+declare class NoopMetrics implements IMetrics {
+    increment(): void;
+    decrement(): void;
+    gauge(): void;
+    histogram(): void;
+    timing(): void;
+    startTimer(): () => void;
+    distribution(): void;
+    set(): void;
+    flush(): Promise<void>;
+    close(): Promise<void>;
+}
+/**
+ * Summary of all metrics
+ */
+interface MetricsSummary {
+    counters: Record<string, number>;
+    gauges: Record<string, number>;
+    histograms: Record<string, HistogramStats>;
+    timings: Record<string, TimingStats>;
+    sets: Record<string, number>;
+}
+/**
+ * Histogram statistics
+ */
+interface HistogramStats {
+    count: number;
+    sum: number;
+    min: number;
+    max: number;
+    avg: number;
+}
+/**
+ * Timing statistics
+ */
+interface TimingStats extends HistogramStats {
+    p50: number;
+    p95: number;
+    p99: number;
+}
+/**
+ * Create a scoped metrics instance with a prefix
+ */
+declare function createScopedMetrics(metrics: IMetrics, prefix: string, defaultTags?: MetricTags): IMetrics;
+
+/**
+ * Distributed Tracing Interface
+ *
+ * Provides vendor-agnostic distributed tracing for observability.
+ * Supports OpenTelemetry, Jaeger, Zipkin, and custom implementations.
+ */
+type SpanKind = 'internal' | 'server' | 'client' | 'producer' | 'consumer';
+type SpanStatusCode = 'unset' | 'ok' | 'error';
+interface SpanStatus {
+    code: SpanStatusCode;
+    message?: string;
+}
+interface SpanContext {
+    traceId: string;
+    spanId: string;
+    traceFlags: number;
+    traceState?: string;
+}
+interface SpanOptions {
+    /** Type of span */
+    kind?: SpanKind;
+    /** Initial attributes */
+    attributes?: Record<string, string | number | boolean>;
+    /** Parent span (for manual context propagation) */
+    parent?: ISpan;
+    /** Links to other spans */
+    links?: SpanContext[];
+    /** Start time (defaults to now) */
+    startTime?: number;
+}
+interface SpanEvent {
+    name: string;
+    timestamp: number;
+    attributes?: Record<string, string | number | boolean>;
+}
+interface ISpan {
+    /** Span name */
+    readonly name: string;
+    /** Span context (trace ID, span ID) */
+    readonly context: SpanContext;
+    /** Whether the span is recording */
+    readonly isRecording: boolean;
+    /**
+     * Set a single attribute
+     */
+    setAttribute(key: string, value: string | number | boolean): this;
+    /**
+     * Set multiple attributes
+     */
+    setAttributes(attributes: Record<string, string | number | boolean>): this;
+    /**
+     * Add an event to the span
+     */
+    addEvent(name: string, attributes?: Record<string, string | number | boolean>): this;
+    /**
+     * Set the span status
+     */
+    setStatus(status: SpanStatus): this;
+    /**
+     * Record an exception
+     */
+    recordException(exception: Error, attributes?: Record<string, string | number | boolean>): this;
+    /**
+     * Update the span name
+     */
+    updateName(name: string): this;
+    /**
+     * End the span (required to export)
+     */
+    end(endTime?: number): void;
+}
+interface ITracing {
+    /**
+     * Create and start a new span
+     */
+    startSpan(name: string, options?: SpanOptions): ISpan;
+    /**
+     * Get the currently active span
+     */
+    getCurrentSpan(): ISpan | undefined;
+    /**
+     * Execute a function within a span context
+     */
+    withSpan<T>(name: string, fn: (span: ISpan) => T, options?: SpanOptions): T;
+    /**
+     * Execute an async function within a span context
+     */
+    withSpanAsync<T>(name: string, fn: (span: ISpan) => Promise<T>, options?: SpanOptions): Promise<T>;
+    /**
+     * Instrument a function with automatic span creation
+     */
+    instrument<TArgs extends unknown[], TReturn>(name: string, fn: (...args: TArgs) => TReturn, options?: SpanOptions): (...args: TArgs) => TReturn;
+    /**
+     * Instrument an async function with automatic span creation
+     */
+    instrumentAsync<TArgs extends unknown[], TReturn>(name: string, fn: (...args: TArgs) => Promise<TReturn>, options?: SpanOptions): (...args: TArgs) => Promise<TReturn>;
+    /**
+     * Extract trace context from headers (for incoming requests)
+     */
+    extractContext(headers: Record<string, string | string[] | undefined>): SpanContext | undefined;
+    /**
+     * Inject trace context into headers (for outgoing requests)
+     */
+    injectContext(headers: Record<string, string>): void;
+    /**
+     * Check if tracing is enabled and healthy
+     */
+    healthCheck(): Promise<boolean>;
+    /**
+     * Flush pending spans to the exporter
+     */
+    flush(): Promise<void>;
+    /**
+     * Shutdown the tracer
+     */
+    close(): Promise<void>;
+}
+interface TracingConfig {
+    /** Enable tracing */
+    enabled: boolean;
+    /** Service name for traces */
+    serviceName: string;
+    /** Service version */
+    serviceVersion?: string;
+    /** Environment (dev, staging, production) */
+    environment?: string;
+    /** Sampling rate (0.0 to 1.0) */
+    sampleRate?: number;
+    /** Exporter type */
+    exporter?: 'console' | 'otlp' | 'jaeger' | 'zipkin' | 'none';
+    /** Exporter endpoint */
+    endpoint?: string;
+    /** Additional resource attributes */
+    resourceAttributes?: Record<string, string>;
+    /** Propagation format */
+    propagation?: 'w3c' | 'b3' | 'jaeger';
+}
+declare class MemorySpan implements ISpan {
+    readonly name: string;
+    readonly context: SpanContext;
+    readonly isRecording: boolean;
+    private _attributes;
+    private _events;
+    private _status;
+    private _endTime?;
+    private _startTime;
+    constructor(name: string, traceId: string, parentSpanId?: string);
+    private generateSpanId;
+    setAttribute(key: string, value: string | number | boolean): this;
+    setAttributes(attributes: Record<string, string | number | boolean>): this;
+    addEvent(name: string, attributes?: Record<string, string | number | boolean>): this;
+    setStatus(status: SpanStatus): this;
+    recordException(exception: Error, attributes?: Record<string, string | number | boolean>): this;
+    updateName(name: string): this;
+    end(endTime?: number): void;
+    getAttributes(): Record<string, string | number | boolean>;
+    getEvents(): SpanEvent[];
+    getStatus(): SpanStatus;
+    getDuration(): number | undefined;
+    isEnded(): boolean;
+}
+declare class MemoryTracing implements ITracing {
+    private spans;
+    private currentSpan;
+    private traceId;
+    constructor();
+    private generateTraceId;
+    startSpan(name: string, options?: SpanOptions): ISpan;
+    getCurrentSpan(): ISpan | undefined;
+    withSpan<T>(name: string, fn: (span: ISpan) => T, options?: SpanOptions): T;
+    withSpanAsync<T>(name: string, fn: (span: ISpan) => Promise<T>, options?: SpanOptions): Promise<T>;
+    instrument<TArgs extends unknown[], TReturn>(name: string, fn: (...args: TArgs) => TReturn, options?: SpanOptions): (...args: TArgs) => TReturn;
+    instrumentAsync<TArgs extends unknown[], TReturn>(name: string, fn: (...args: TArgs) => Promise<TReturn>, options?: SpanOptions): (...args: TArgs) => Promise<TReturn>;
+    extractContext(headers: Record<string, string | string[] | undefined>): SpanContext | undefined;
+    injectContext(headers: Record<string, string>): void;
+    healthCheck(): Promise<boolean>;
+    flush(): Promise<void>;
+    close(): Promise<void>;
+    getSpans(): MemorySpan[];
+    getCompletedSpans(): MemorySpan[];
+    clear(): void;
+}
+declare class NoopTracing implements ITracing {
+    private noopSpan;
+    startSpan(): ISpan;
+    getCurrentSpan(): ISpan | undefined;
+    withSpan<T>(_name: string, fn: (span: ISpan) => T): T;
+    withSpanAsync<T>(_name: string, fn: (span: ISpan) => Promise<T>): Promise<T>;
+    instrument<TArgs extends unknown[], TReturn>(_name: string, fn: (...args: TArgs) => TReturn): (...args: TArgs) => TReturn;
+    instrumentAsync<TArgs extends unknown[], TReturn>(_name: string, fn: (...args: TArgs) => Promise<TReturn>): (...args: TArgs) => Promise<TReturn>;
+    extractContext(): SpanContext | undefined;
+    injectContext(): void;
+    healthCheck(): Promise<boolean>;
+    flush(): Promise<void>;
+    close(): Promise<void>;
+}
+
+/**
+ * Main Platform interface
+ * Combines all infrastructure services into a single entry point
+ */
+
+interface PlatformHealthStatus {
+    healthy: boolean;
+    services: {
+        database: boolean;
+        cache: boolean;
+        storage: boolean;
+        email: boolean;
+        queue: boolean;
+        tracing?: boolean;
+    };
+    timestamp: number;
+}
+interface IPlatform {
+    /** Database service */
+    readonly db: IDatabase;
+    /** Cache service */
+    readonly cache: ICache;
+    /** Storage service */
+    readonly storage: IStorage;
+    /** Email service */
+    readonly email: IEmail;
+    /** Queue service */
+    readonly queue: IQueue;
+    /** Logger service (optional) */
+    readonly logger?: ILogger;
+    /** Metrics service (optional) */
+    readonly metrics?: IMetrics;
+    /** Tracing service (optional) */
+    readonly tracing?: ITracing;
+    /**
+     * Check health of all services
+     */
+    healthCheck(): Promise<PlatformHealthStatus>;
+    /**
+     * Close all connections
+     */
+    close(): Promise<void>;
+}
+
+/**
+ * Secrets Management Interface
+ *
+ * Provides a vendor-agnostic abstraction for secrets management.
+ * Supports various backends: Environment variables, HashiCorp Vault,
+ * AWS Secrets Manager, Azure Key Vault, GCP Secret Manager, etc.
+ */
+/**
+ * Secret metadata
+ */
+interface SecretMetadata {
+    /** Secret version or ETag */
+    version?: string;
+    /** Creation timestamp */
+    createdAt?: Date;
+    /** Last updated timestamp */
+    updatedAt?: Date;
+    /** Expiration timestamp */
+    expiresAt?: Date;
+    /** Custom tags/labels */
+    tags?: Record<string, string>;
+}
+/**
+ * Secret with metadata
+ */
+interface Secret<T = string> {
+    /** Secret key/name */
+    key: string;
+    /** Secret value */
+    value: T;
+    /** Secret metadata */
+    metadata?: SecretMetadata;
+}
+/**
+ * Options for getting secrets
+ */
+interface GetSecretOptions {
+    /** Specific version to retrieve */
+    version?: string;
+    /** Include metadata in response */
+    includeMetadata?: boolean;
+    /** Cache TTL in seconds (0 = no cache) */
+    cacheTtl?: number;
+}
+/**
+ * Options for setting secrets
+ */
+interface SetSecretOptions {
+    /** Expiration timestamp */
+    expiresAt?: Date;
+    /** Custom tags/labels */
+    tags?: Record<string, string>;
+    /** Description */
+    description?: string;
+}
+/**
+ * Options for rotating secrets
+ */
+interface RotateSecretOptions {
+    /** Custom rotation function */
+    rotationFn?: () => Promise<string>;
+    /** Rotation period in days */
+    rotationPeriodDays?: number;
+    /** Keep previous version count */
+    keepPreviousVersions?: number;
+}
+/**
+ * Result of a rotation operation
+ */
+interface RotationResult {
+    /** New secret value */
+    newValue: string;
+    /** Previous secret value (for rollback) */
+    previousValue?: string;
+    /** New version identifier */
+    newVersion: string;
+    /** Previous version identifier */
+    previousVersion?: string;
+}
+/**
+ * Secrets Management Interface
+ */
+interface ISecrets {
+    /**
+     * Get a secret value by key
+     */
+    get(key: string, options?: GetSecretOptions): Promise<string | null>;
+    /**
+     * Get a secret with metadata
+     */
+    getWithMetadata(key: string, options?: GetSecretOptions): Promise<Secret | null>;
+    /**
+     * Get multiple secrets at once
+     */
+    mget(keys: string[]): Promise<Map<string, string | null>>;
+    /**
+     * Set a secret value
+     */
+    set(key: string, value: string, options?: SetSecretOptions): Promise<void>;
+    /**
+     * Delete a secret
+     */
+    delete(key: string): Promise<void>;
+    /**
+     * Check if a secret exists
+     */
+    exists(key: string): Promise<boolean>;
+    /**
+     * List all secret keys (optionally filtered by prefix)
+     */
+    list(prefix?: string): Promise<string[]>;
+    /**
+     * Rotate a secret (generate new value)
+     */
+    rotate(key: string, options?: RotateSecretOptions): Promise<RotationResult>;
+    /**
+     * Get all versions of a secret
+     */
+    getVersions(key: string): Promise<SecretMetadata[]>;
+    /**
+     * Health check
+     */
+    healthCheck(): Promise<boolean>;
+}
+/**
+ * Environment Variables Secrets Adapter
+ * Simple implementation using process.env - suitable for development
+ * and containerized deployments with injected secrets
+ */
+declare class EnvSecrets implements ISecrets {
+    private prefix;
+    private cache;
+    constructor(options?: {
+        prefix?: string;
+    });
+    private getEnvKey;
+    get(key: string, options?: GetSecretOptions): Promise<string | null>;
+    getWithMetadata(key: string, options?: GetSecretOptions): Promise<Secret | null>;
+    mget(keys: string[]): Promise<Map<string, string | null>>;
+    set(key: string, value: string, _options?: SetSecretOptions): Promise<void>;
+    delete(key: string): Promise<void>;
+    exists(key: string): Promise<boolean>;
+    list(prefix?: string): Promise<string[]>;
+    rotate(key: string, options?: RotateSecretOptions): Promise<RotationResult>;
+    getVersions(_key: string): Promise<SecretMetadata[]>;
+    healthCheck(): Promise<boolean>;
+    private generateSecureValue;
+    /**
+     * Clear the internal cache
+     */
+    clearCache(): void;
+}
+/**
+ * Memory-based Secrets Adapter
+ * For testing purposes only - stores secrets in memory
+ */
+declare class MemorySecrets implements ISecrets {
+    private secrets;
+    private versions;
+    get(key: string, _options?: GetSecretOptions): Promise<string | null>;
+    getWithMetadata(key: string, options?: GetSecretOptions): Promise<Secret | null>;
+    mget(keys: string[]): Promise<Map<string, string | null>>;
+    set(key: string, value: string, options?: SetSecretOptions): Promise<void>;
+    delete(key: string): Promise<void>;
+    exists(key: string): Promise<boolean>;
+    list(prefix?: string): Promise<string[]>;
+    rotate(key: string, options?: RotateSecretOptions): Promise<RotationResult>;
+    getVersions(key: string): Promise<SecretMetadata[]>;
+    healthCheck(): Promise<boolean>;
+    private generateSecureValue;
+    /**
+     * Clear all secrets (for testing)
+     */
+    clear(): void;
+    /**
+     * Get count of secrets (for testing)
+     */
+    get size(): number;
+}
+
+/**
+ * Platform Configuration
+ * Comprehensive Zod schema for all platform options with validation
+ */
+
+declare const DatabaseProviderSchema: z.ZodEnum<["memory", "postgres", "supabase"]>;
+declare const CacheProviderSchema: z.ZodEnum<["memory", "redis", "upstash"]>;
+declare const StorageProviderSchema: z.ZodEnum<["memory", "s3", "minio", "r2", "supabase"]>;
+declare const EmailProviderSchema: z.ZodEnum<["memory", "console", "smtp", "resend"]>;
+declare const QueueProviderSchema: z.ZodEnum<["memory", "bullmq"]>;
+declare const TracingProviderSchema: z.ZodEnum<["noop", "memory", "otlp"]>;
+declare const LogLevelSchema: z.ZodEnum<["debug", "info", "warn", "error"]>;
+declare const DatabaseConfigSchema: z.ZodEffects<z.ZodObject<{
+    provider: z.ZodDefault<z.ZodEnum<["memory", "postgres", "supabase"]>>;
+    url: z.ZodOptional<z.ZodString>;
+    connectionString: z.ZodOptional<z.ZodString>;
+    supabaseUrl: z.ZodOptional<z.ZodString>;
+    supabaseAnonKey: z.ZodOptional<z.ZodString>;
+    supabaseServiceRoleKey: z.ZodOptional<z.ZodString>;
+    poolSize: z.ZodDefault<z.ZodNumber>;
+    connectionTimeout: z.ZodDefault<z.ZodNumber>;
+    ssl: z.ZodOptional<z.ZodUnion<[z.ZodBoolean, z.ZodObject<{
+        rejectUnauthorized: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        rejectUnauthorized?: boolean | undefined;
+    }, {
+        rejectUnauthorized?: boolean | undefined;
+    }>]>>;
+}, "strip", z.ZodTypeAny, {
+    provider: "memory" | "postgres" | "supabase";
+    poolSize: number;
+    connectionTimeout: number;
+    url?: string | undefined;
+    connectionString?: string | undefined;
+    supabaseUrl?: string | undefined;
+    supabaseAnonKey?: string | undefined;
+    supabaseServiceRoleKey?: string | undefined;
+    ssl?: boolean | {
+        rejectUnauthorized?: boolean | undefined;
+    } | undefined;
+}, {
+    provider?: "memory" | "postgres" | "supabase" | undefined;
+    url?: string | undefined;
+    connectionString?: string | undefined;
+    supabaseUrl?: string | undefined;
+    supabaseAnonKey?: string | undefined;
+    supabaseServiceRoleKey?: string | undefined;
+    poolSize?: number | undefined;
+    connectionTimeout?: number | undefined;
+    ssl?: boolean | {
+        rejectUnauthorized?: boolean | undefined;
+    } | undefined;
+}>, {
+    provider: "memory" | "postgres" | "supabase";
+    poolSize: number;
+    connectionTimeout: number;
+    url?: string | undefined;
+    connectionString?: string | undefined;
+    supabaseUrl?: string | undefined;
+    supabaseAnonKey?: string | undefined;
+    supabaseServiceRoleKey?: string | undefined;
+    ssl?: boolean | {
+        rejectUnauthorized?: boolean | undefined;
+    } | undefined;
+}, {
+    provider?: "memory" | "postgres" | "supabase" | undefined;
+    url?: string | undefined;
+    connectionString?: string | undefined;
+    supabaseUrl?: string | undefined;
+    supabaseAnonKey?: string | undefined;
+    supabaseServiceRoleKey?: string | undefined;
+    poolSize?: number | undefined;
+    connectionTimeout?: number | undefined;
+    ssl?: boolean | {
+        rejectUnauthorized?: boolean | undefined;
+    } | undefined;
+}>;
+declare const CacheConfigSchema: z.ZodEffects<z.ZodObject<{
+    provider: z.ZodDefault<z.ZodEnum<["memory", "redis", "upstash"]>>;
+    url: z.ZodOptional<z.ZodString>;
+    upstashUrl: z.ZodOptional<z.ZodString>;
+    upstashToken: z.ZodOptional<z.ZodString>;
+    defaultTTL: z.ZodDefault<z.ZodNumber>;
+    keyPrefix: z.ZodDefault<z.ZodString>;
+    maxRetries: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    provider: "memory" | "redis" | "upstash";
+    defaultTTL: number;
+    keyPrefix: string;
+    maxRetries: number;
+    url?: string | undefined;
+    upstashUrl?: string | undefined;
+    upstashToken?: string | undefined;
+}, {
+    provider?: "memory" | "redis" | "upstash" | undefined;
+    url?: string | undefined;
+    upstashUrl?: string | undefined;
+    upstashToken?: string | undefined;
+    defaultTTL?: number | undefined;
+    keyPrefix?: string | undefined;
+    maxRetries?: number | undefined;
+}>, {
+    provider: "memory" | "redis" | "upstash";
+    defaultTTL: number;
+    keyPrefix: string;
+    maxRetries: number;
+    url?: string | undefined;
+    upstashUrl?: string | undefined;
+    upstashToken?: string | undefined;
+}, {
+    provider?: "memory" | "redis" | "upstash" | undefined;
+    url?: string | undefined;
+    upstashUrl?: string | undefined;
+    upstashToken?: string | undefined;
+    defaultTTL?: number | undefined;
+    keyPrefix?: string | undefined;
+    maxRetries?: number | undefined;
+}>;
+declare const StorageConfigSchema: z.ZodEffects<z.ZodObject<{
+    provider: z.ZodDefault<z.ZodEnum<["memory", "s3", "minio", "r2", "supabase"]>>;
+    endpoint: z.ZodOptional<z.ZodString>;
+    region: z.ZodDefault<z.ZodString>;
+    accessKey: z.ZodOptional<z.ZodString>;
+    secretKey: z.ZodOptional<z.ZodString>;
+    bucket: z.ZodOptional<z.ZodString>;
+    publicUrl: z.ZodOptional<z.ZodString>;
+    forcePathStyle: z.ZodDefault<z.ZodBoolean>;
+    signedUrlExpiry: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    provider: "memory" | "supabase" | "s3" | "minio" | "r2";
+    region: string;
+    forcePathStyle: boolean;
+    signedUrlExpiry: number;
+    endpoint?: string | undefined;
+    accessKey?: string | undefined;
+    secretKey?: string | undefined;
+    bucket?: string | undefined;
+    publicUrl?: string | undefined;
+}, {
+    provider?: "memory" | "supabase" | "s3" | "minio" | "r2" | undefined;
+    endpoint?: string | undefined;
+    region?: string | undefined;
+    accessKey?: string | undefined;
+    secretKey?: string | undefined;
+    bucket?: string | undefined;
+    publicUrl?: string | undefined;
+    forcePathStyle?: boolean | undefined;
+    signedUrlExpiry?: number | undefined;
+}>, {
+    provider: "memory" | "supabase" | "s3" | "minio" | "r2";
+    region: string;
+    forcePathStyle: boolean;
+    signedUrlExpiry: number;
+    endpoint?: string | undefined;
+    accessKey?: string | undefined;
+    secretKey?: string | undefined;
+    bucket?: string | undefined;
+    publicUrl?: string | undefined;
+}, {
+    provider?: "memory" | "supabase" | "s3" | "minio" | "r2" | undefined;
+    endpoint?: string | undefined;
+    region?: string | undefined;
+    accessKey?: string | undefined;
+    secretKey?: string | undefined;
+    bucket?: string | undefined;
+    publicUrl?: string | undefined;
+    forcePathStyle?: boolean | undefined;
+    signedUrlExpiry?: number | undefined;
+}>;
+declare const EmailConfigSchema: z.ZodEffects<z.ZodObject<{
+    provider: z.ZodDefault<z.ZodEnum<["memory", "console", "smtp", "resend"]>>;
+    host: z.ZodOptional<z.ZodString>;
+    port: z.ZodOptional<z.ZodNumber>;
+    secure: z.ZodDefault<z.ZodBoolean>;
+    username: z.ZodOptional<z.ZodString>;
+    password: z.ZodOptional<z.ZodString>;
+    apiKey: z.ZodOptional<z.ZodString>;
+    from: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodString]>>;
+    replyTo: z.ZodOptional<z.ZodString>;
+    rateLimitPerSecond: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    provider: "console" | "memory" | "smtp" | "resend";
+    secure: boolean;
+    rateLimitPerSecond: number;
+    host?: string | undefined;
+    port?: number | undefined;
+    username?: string | undefined;
+    password?: string | undefined;
+    apiKey?: string | undefined;
+    from?: string | undefined;
+    replyTo?: string | undefined;
+}, {
+    provider?: "console" | "memory" | "smtp" | "resend" | undefined;
+    host?: string | undefined;
+    port?: number | undefined;
+    secure?: boolean | undefined;
+    username?: string | undefined;
+    password?: string | undefined;
+    apiKey?: string | undefined;
+    from?: string | undefined;
+    replyTo?: string | undefined;
+    rateLimitPerSecond?: number | undefined;
+}>, {
+    provider: "console" | "memory" | "smtp" | "resend";
+    secure: boolean;
+    rateLimitPerSecond: number;
+    host?: string | undefined;
+    port?: number | undefined;
+    username?: string | undefined;
+    password?: string | undefined;
+    apiKey?: string | undefined;
+    from?: string | undefined;
+    replyTo?: string | undefined;
+}, {
+    provider?: "console" | "memory" | "smtp" | "resend" | undefined;
+    host?: string | undefined;
+    port?: number | undefined;
+    secure?: boolean | undefined;
+    username?: string | undefined;
+    password?: string | undefined;
+    apiKey?: string | undefined;
+    from?: string | undefined;
+    replyTo?: string | undefined;
+    rateLimitPerSecond?: number | undefined;
+}>;
+declare const QueueConfigSchema: z.ZodEffects<z.ZodObject<{
+    provider: z.ZodDefault<z.ZodEnum<["memory", "bullmq"]>>;
+    redisUrl: z.ZodOptional<z.ZodString>;
+    queueName: z.ZodDefault<z.ZodString>;
+    concurrency: z.ZodDefault<z.ZodNumber>;
+    maxRetries: z.ZodDefault<z.ZodNumber>;
+    retryDelay: z.ZodDefault<z.ZodNumber>;
+    removeOnComplete: z.ZodDefault<z.ZodBoolean>;
+    removeOnFail: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    provider: "memory" | "bullmq";
+    maxRetries: number;
+    queueName: string;
+    concurrency: number;
+    retryDelay: number;
+    removeOnComplete: boolean;
+    removeOnFail: boolean;
+    redisUrl?: string | undefined;
+}, {
+    provider?: "memory" | "bullmq" | undefined;
+    maxRetries?: number | undefined;
+    redisUrl?: string | undefined;
+    queueName?: string | undefined;
+    concurrency?: number | undefined;
+    retryDelay?: number | undefined;
+    removeOnComplete?: boolean | undefined;
+    removeOnFail?: boolean | undefined;
+}>, {
+    provider: "memory" | "bullmq";
+    maxRetries: number;
+    queueName: string;
+    concurrency: number;
+    retryDelay: number;
+    removeOnComplete: boolean;
+    removeOnFail: boolean;
+    redisUrl?: string | undefined;
+}, {
+    provider?: "memory" | "bullmq" | undefined;
+    maxRetries?: number | undefined;
+    redisUrl?: string | undefined;
+    queueName?: string | undefined;
+    concurrency?: number | undefined;
+    retryDelay?: number | undefined;
+    removeOnComplete?: boolean | undefined;
+    removeOnFail?: boolean | undefined;
+}>;
+declare const RetryConfigSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    maxAttempts: z.ZodDefault<z.ZodNumber>;
+    baseDelay: z.ZodDefault<z.ZodNumber>;
+    maxDelay: z.ZodDefault<z.ZodNumber>;
+    backoffMultiplier: z.ZodDefault<z.ZodNumber>;
+    jitter: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    enabled: boolean;
+    maxAttempts: number;
+    baseDelay: number;
+    maxDelay: number;
+    backoffMultiplier: number;
+    jitter: boolean;
+}, {
+    enabled?: boolean | undefined;
+    maxAttempts?: number | undefined;
+    baseDelay?: number | undefined;
+    maxDelay?: number | undefined;
+    backoffMultiplier?: number | undefined;
+    jitter?: boolean | undefined;
+}>;
+declare const CircuitBreakerConfigSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    failureThreshold: z.ZodDefault<z.ZodNumber>;
+    resetTimeout: z.ZodDefault<z.ZodNumber>;
+    halfOpenRequests: z.ZodDefault<z.ZodNumber>;
+    monitorInterval: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    enabled: boolean;
+    failureThreshold: number;
+    resetTimeout: number;
+    halfOpenRequests: number;
+    monitorInterval: number;
+}, {
+    enabled?: boolean | undefined;
+    failureThreshold?: number | undefined;
+    resetTimeout?: number | undefined;
+    halfOpenRequests?: number | undefined;
+    monitorInterval?: number | undefined;
+}>;
+declare const TimeoutConfigSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    default: z.ZodDefault<z.ZodNumber>;
+    database: z.ZodDefault<z.ZodNumber>;
+    cache: z.ZodDefault<z.ZodNumber>;
+    storage: z.ZodDefault<z.ZodNumber>;
+    email: z.ZodDefault<z.ZodNumber>;
+    queue: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    enabled: boolean;
+    default: number;
+    database: number;
+    cache: number;
+    storage: number;
+    email: number;
+    queue: number;
+}, {
+    enabled?: boolean | undefined;
+    default?: number | undefined;
+    database?: number | undefined;
+    cache?: number | undefined;
+    storage?: number | undefined;
+    email?: number | undefined;
+    queue?: number | undefined;
+}>;
+declare const BulkheadConfigSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    maxConcurrent: z.ZodDefault<z.ZodNumber>;
+    maxQueued: z.ZodDefault<z.ZodNumber>;
+    timeout: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    enabled: boolean;
+    maxConcurrent: number;
+    maxQueued: number;
+    timeout: number;
+}, {
+    enabled?: boolean | undefined;
+    maxConcurrent?: number | undefined;
+    maxQueued?: number | undefined;
+    timeout?: number | undefined;
+}>;
+declare const ResilienceConfigSchema: z.ZodObject<{
+    retry: z.ZodDefault<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        maxAttempts: z.ZodDefault<z.ZodNumber>;
+        baseDelay: z.ZodDefault<z.ZodNumber>;
+        maxDelay: z.ZodDefault<z.ZodNumber>;
+        backoffMultiplier: z.ZodDefault<z.ZodNumber>;
+        jitter: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+        maxAttempts: number;
+        baseDelay: number;
+        maxDelay: number;
+        backoffMultiplier: number;
+        jitter: boolean;
+    }, {
+        enabled?: boolean | undefined;
+        maxAttempts?: number | undefined;
+        baseDelay?: number | undefined;
+        maxDelay?: number | undefined;
+        backoffMultiplier?: number | undefined;
+        jitter?: boolean | undefined;
+    }>>;
+    circuitBreaker: z.ZodDefault<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        failureThreshold: z.ZodDefault<z.ZodNumber>;
+        resetTimeout: z.ZodDefault<z.ZodNumber>;
+        halfOpenRequests: z.ZodDefault<z.ZodNumber>;
+        monitorInterval: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+        failureThreshold: number;
+        resetTimeout: number;
+        halfOpenRequests: number;
+        monitorInterval: number;
+    }, {
+        enabled?: boolean | undefined;
+        failureThreshold?: number | undefined;
+        resetTimeout?: number | undefined;
+        halfOpenRequests?: number | undefined;
+        monitorInterval?: number | undefined;
+    }>>;
+    timeout: z.ZodDefault<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        default: z.ZodDefault<z.ZodNumber>;
+        database: z.ZodDefault<z.ZodNumber>;
+        cache: z.ZodDefault<z.ZodNumber>;
+        storage: z.ZodDefault<z.ZodNumber>;
+        email: z.ZodDefault<z.ZodNumber>;
+        queue: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+        default: number;
+        database: number;
+        cache: number;
+        storage: number;
+        email: number;
+        queue: number;
+    }, {
+        enabled?: boolean | undefined;
+        default?: number | undefined;
+        database?: number | undefined;
+        cache?: number | undefined;
+        storage?: number | undefined;
+        email?: number | undefined;
+        queue?: number | undefined;
+    }>>;
+    bulkhead: z.ZodDefault<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        maxConcurrent: z.ZodDefault<z.ZodNumber>;
+        maxQueued: z.ZodDefault<z.ZodNumber>;
+        timeout: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+        maxConcurrent: number;
+        maxQueued: number;
+        timeout: number;
+    }, {
+        enabled?: boolean | undefined;
+        maxConcurrent?: number | undefined;
+        maxQueued?: number | undefined;
+        timeout?: number | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    timeout: {
+        enabled: boolean;
+        default: number;
+        database: number;
+        cache: number;
+        storage: number;
+        email: number;
+        queue: number;
+    };
+    retry: {
+        enabled: boolean;
+        maxAttempts: number;
+        baseDelay: number;
+        maxDelay: number;
+        backoffMultiplier: number;
+        jitter: boolean;
+    };
+    circuitBreaker: {
+        enabled: boolean;
+        failureThreshold: number;
+        resetTimeout: number;
+        halfOpenRequests: number;
+        monitorInterval: number;
+    };
+    bulkhead: {
+        enabled: boolean;
+        maxConcurrent: number;
+        maxQueued: number;
+        timeout: number;
+    };
+}, {
+    timeout?: {
+        enabled?: boolean | undefined;
+        default?: number | undefined;
+        database?: number | undefined;
+        cache?: number | undefined;
+        storage?: number | undefined;
+        email?: number | undefined;
+        queue?: number | undefined;
+    } | undefined;
+    retry?: {
+        enabled?: boolean | undefined;
+        maxAttempts?: number | undefined;
+        baseDelay?: number | undefined;
+        maxDelay?: number | undefined;
+        backoffMultiplier?: number | undefined;
+        jitter?: boolean | undefined;
+    } | undefined;
+    circuitBreaker?: {
+        enabled?: boolean | undefined;
+        failureThreshold?: number | undefined;
+        resetTimeout?: number | undefined;
+        halfOpenRequests?: number | undefined;
+        monitorInterval?: number | undefined;
+    } | undefined;
+    bulkhead?: {
+        enabled?: boolean | undefined;
+        maxConcurrent?: number | undefined;
+        maxQueued?: number | undefined;
+        timeout?: number | undefined;
+    } | undefined;
+}>;
+declare const LoggingConfigSchema: z.ZodObject<{
+    level: z.ZodDefault<z.ZodEnum<["debug", "info", "warn", "error"]>>;
+    format: z.ZodDefault<z.ZodEnum<["json", "pretty"]>>;
+    includeTimestamp: z.ZodDefault<z.ZodBoolean>;
+    includeCorrelationId: z.ZodDefault<z.ZodBoolean>;
+    redactKeys: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    level: "debug" | "info" | "warn" | "error";
+    format: "json" | "pretty";
+    includeTimestamp: boolean;
+    includeCorrelationId: boolean;
+    redactKeys: string[];
+}, {
+    level?: "debug" | "info" | "warn" | "error" | undefined;
+    format?: "json" | "pretty" | undefined;
+    includeTimestamp?: boolean | undefined;
+    includeCorrelationId?: boolean | undefined;
+    redactKeys?: string[] | undefined;
+}>;
+declare const MetricsConfigSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    prefix: z.ZodDefault<z.ZodString>;
+    defaultTags: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+    flushInterval: z.ZodDefault<z.ZodNumber>;
+    histogramBuckets: z.ZodDefault<z.ZodArray<z.ZodNumber, "many">>;
+}, "strip", z.ZodTypeAny, {
+    enabled: boolean;
+    prefix: string;
+    defaultTags: Record<string, string>;
+    flushInterval: number;
+    histogramBuckets: number[];
+}, {
+    enabled?: boolean | undefined;
+    prefix?: string | undefined;
+    defaultTags?: Record<string, string> | undefined;
+    flushInterval?: number | undefined;
+    histogramBuckets?: number[] | undefined;
+}>;
+declare const TracingConfigSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    provider: z.ZodDefault<z.ZodEnum<["noop", "memory", "otlp"]>>;
+    serviceName: z.ZodOptional<z.ZodString>;
+    serviceVersion: z.ZodOptional<z.ZodString>;
+    environment: z.ZodOptional<z.ZodString>;
+    sampleRate: z.ZodDefault<z.ZodNumber>;
+    propagateContext: z.ZodDefault<z.ZodBoolean>;
+    endpoint: z.ZodOptional<z.ZodString>;
+    exporterType: z.ZodDefault<z.ZodEnum<["otlp-http", "otlp-grpc", "console"]>>;
+}, "strip", z.ZodTypeAny, {
+    provider: "otlp" | "memory" | "noop";
+    enabled: boolean;
+    sampleRate: number;
+    propagateContext: boolean;
+    exporterType: "console" | "otlp-http" | "otlp-grpc";
+    environment?: string | undefined;
+    endpoint?: string | undefined;
+    serviceName?: string | undefined;
+    serviceVersion?: string | undefined;
+}, {
+    environment?: string | undefined;
+    provider?: "otlp" | "memory" | "noop" | undefined;
+    endpoint?: string | undefined;
+    enabled?: boolean | undefined;
+    serviceName?: string | undefined;
+    serviceVersion?: string | undefined;
+    sampleRate?: number | undefined;
+    propagateContext?: boolean | undefined;
+    exporterType?: "console" | "otlp-http" | "otlp-grpc" | undefined;
+}>;
+declare const ObservabilityConfigSchema: z.ZodObject<{
+    logging: z.ZodDefault<z.ZodObject<{
+        level: z.ZodDefault<z.ZodEnum<["debug", "info", "warn", "error"]>>;
+        format: z.ZodDefault<z.ZodEnum<["json", "pretty"]>>;
+        includeTimestamp: z.ZodDefault<z.ZodBoolean>;
+        includeCorrelationId: z.ZodDefault<z.ZodBoolean>;
+        redactKeys: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        level: "debug" | "info" | "warn" | "error";
+        format: "json" | "pretty";
+        includeTimestamp: boolean;
+        includeCorrelationId: boolean;
+        redactKeys: string[];
+    }, {
+        level?: "debug" | "info" | "warn" | "error" | undefined;
+        format?: "json" | "pretty" | undefined;
+        includeTimestamp?: boolean | undefined;
+        includeCorrelationId?: boolean | undefined;
+        redactKeys?: string[] | undefined;
+    }>>;
+    metrics: z.ZodDefault<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        prefix: z.ZodDefault<z.ZodString>;
+        defaultTags: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+        flushInterval: z.ZodDefault<z.ZodNumber>;
+        histogramBuckets: z.ZodDefault<z.ZodArray<z.ZodNumber, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+        prefix: string;
+        defaultTags: Record<string, string>;
+        flushInterval: number;
+        histogramBuckets: number[];
+    }, {
+        enabled?: boolean | undefined;
+        prefix?: string | undefined;
+        defaultTags?: Record<string, string> | undefined;
+        flushInterval?: number | undefined;
+        histogramBuckets?: number[] | undefined;
+    }>>;
+    tracing: z.ZodDefault<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        provider: z.ZodDefault<z.ZodEnum<["noop", "memory", "otlp"]>>;
+        serviceName: z.ZodOptional<z.ZodString>;
+        serviceVersion: z.ZodOptional<z.ZodString>;
+        environment: z.ZodOptional<z.ZodString>;
+        sampleRate: z.ZodDefault<z.ZodNumber>;
+        propagateContext: z.ZodDefault<z.ZodBoolean>;
+        endpoint: z.ZodOptional<z.ZodString>;
+        exporterType: z.ZodDefault<z.ZodEnum<["otlp-http", "otlp-grpc", "console"]>>;
+    }, "strip", z.ZodTypeAny, {
+        provider: "otlp" | "memory" | "noop";
+        enabled: boolean;
+        sampleRate: number;
+        propagateContext: boolean;
+        exporterType: "console" | "otlp-http" | "otlp-grpc";
+        environment?: string | undefined;
+        endpoint?: string | undefined;
+        serviceName?: string | undefined;
+        serviceVersion?: string | undefined;
+    }, {
+        environment?: string | undefined;
+        provider?: "otlp" | "memory" | "noop" | undefined;
+        endpoint?: string | undefined;
+        enabled?: boolean | undefined;
+        serviceName?: string | undefined;
+        serviceVersion?: string | undefined;
+        sampleRate?: number | undefined;
+        propagateContext?: boolean | undefined;
+        exporterType?: "console" | "otlp-http" | "otlp-grpc" | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    logging: {
+        level: "debug" | "info" | "warn" | "error";
+        format: "json" | "pretty";
+        includeTimestamp: boolean;
+        includeCorrelationId: boolean;
+        redactKeys: string[];
+    };
+    metrics: {
+        enabled: boolean;
+        prefix: string;
+        defaultTags: Record<string, string>;
+        flushInterval: number;
+        histogramBuckets: number[];
+    };
+    tracing: {
+        provider: "otlp" | "memory" | "noop";
+        enabled: boolean;
+        sampleRate: number;
+        propagateContext: boolean;
+        exporterType: "console" | "otlp-http" | "otlp-grpc";
+        environment?: string | undefined;
+        endpoint?: string | undefined;
+        serviceName?: string | undefined;
+        serviceVersion?: string | undefined;
+    };
+}, {
+    logging?: {
+        level?: "debug" | "info" | "warn" | "error" | undefined;
+        format?: "json" | "pretty" | undefined;
+        includeTimestamp?: boolean | undefined;
+        includeCorrelationId?: boolean | undefined;
+        redactKeys?: string[] | undefined;
+    } | undefined;
+    metrics?: {
+        enabled?: boolean | undefined;
+        prefix?: string | undefined;
+        defaultTags?: Record<string, string> | undefined;
+        flushInterval?: number | undefined;
+        histogramBuckets?: number[] | undefined;
+    } | undefined;
+    tracing?: {
+        environment?: string | undefined;
+        provider?: "otlp" | "memory" | "noop" | undefined;
+        endpoint?: string | undefined;
+        enabled?: boolean | undefined;
+        serviceName?: string | undefined;
+        serviceVersion?: string | undefined;
+        sampleRate?: number | undefined;
+        propagateContext?: boolean | undefined;
+        exporterType?: "console" | "otlp-http" | "otlp-grpc" | undefined;
+    } | undefined;
+}>;
+declare const MiddlewareConfigSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    logging: z.ZodDefault<z.ZodBoolean>;
+    metrics: z.ZodDefault<z.ZodBoolean>;
+    slowQuery: z.ZodDefault<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        thresholdMs: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+        thresholdMs: number;
+    }, {
+        enabled?: boolean | undefined;
+        thresholdMs?: number | undefined;
+    }>>;
+    cache: z.ZodDefault<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        defaultTTL: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        defaultTTL: number;
+        enabled: boolean;
+    }, {
+        defaultTTL?: number | undefined;
+        enabled?: boolean | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    enabled: boolean;
+    cache: {
+        defaultTTL: number;
+        enabled: boolean;
+    };
+    logging: boolean;
+    metrics: boolean;
+    slowQuery: {
+        enabled: boolean;
+        thresholdMs: number;
+    };
+}, {
+    enabled?: boolean | undefined;
+    cache?: {
+        defaultTTL?: number | undefined;
+        enabled?: boolean | undefined;
+    } | undefined;
+    logging?: boolean | undefined;
+    metrics?: boolean | undefined;
+    slowQuery?: {
+        enabled?: boolean | undefined;
+        thresholdMs?: number | undefined;
+    } | undefined;
+}>;
+declare const PlatformConfigSchema: z.ZodObject<{
+    database: z.ZodDefault<z.ZodEffects<z.ZodObject<{
+        provider: z.ZodDefault<z.ZodEnum<["memory", "postgres", "supabase"]>>;
+        url: z.ZodOptional<z.ZodString>;
+        connectionString: z.ZodOptional<z.ZodString>;
+        supabaseUrl: z.ZodOptional<z.ZodString>;
+        supabaseAnonKey: z.ZodOptional<z.ZodString>;
+        supabaseServiceRoleKey: z.ZodOptional<z.ZodString>;
+        poolSize: z.ZodDefault<z.ZodNumber>;
+        connectionTimeout: z.ZodDefault<z.ZodNumber>;
+        ssl: z.ZodOptional<z.ZodUnion<[z.ZodBoolean, z.ZodObject<{
+            rejectUnauthorized: z.ZodOptional<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            rejectUnauthorized?: boolean | undefined;
+        }, {
+            rejectUnauthorized?: boolean | undefined;
+        }>]>>;
+    }, "strip", z.ZodTypeAny, {
+        provider: "memory" | "postgres" | "supabase";
+        poolSize: number;
+        connectionTimeout: number;
+        url?: string | undefined;
+        connectionString?: string | undefined;
+        supabaseUrl?: string | undefined;
+        supabaseAnonKey?: string | undefined;
+        supabaseServiceRoleKey?: string | undefined;
+        ssl?: boolean | {
+            rejectUnauthorized?: boolean | undefined;
+        } | undefined;
+    }, {
+        provider?: "memory" | "postgres" | "supabase" | undefined;
+        url?: string | undefined;
+        connectionString?: string | undefined;
+        supabaseUrl?: string | undefined;
+        supabaseAnonKey?: string | undefined;
+        supabaseServiceRoleKey?: string | undefined;
+        poolSize?: number | undefined;
+        connectionTimeout?: number | undefined;
+        ssl?: boolean | {
+            rejectUnauthorized?: boolean | undefined;
+        } | undefined;
+    }>, {
+        provider: "memory" | "postgres" | "supabase";
+        poolSize: number;
+        connectionTimeout: number;
+        url?: string | undefined;
+        connectionString?: string | undefined;
+        supabaseUrl?: string | undefined;
+        supabaseAnonKey?: string | undefined;
+        supabaseServiceRoleKey?: string | undefined;
+        ssl?: boolean | {
+            rejectUnauthorized?: boolean | undefined;
+        } | undefined;
+    }, {
+        provider?: "memory" | "postgres" | "supabase" | undefined;
+        url?: string | undefined;
+        connectionString?: string | undefined;
+        supabaseUrl?: string | undefined;
+        supabaseAnonKey?: string | undefined;
+        supabaseServiceRoleKey?: string | undefined;
+        poolSize?: number | undefined;
+        connectionTimeout?: number | undefined;
+        ssl?: boolean | {
+            rejectUnauthorized?: boolean | undefined;
+        } | undefined;
+    }>>;
+    cache: z.ZodDefault<z.ZodEffects<z.ZodObject<{
+        provider: z.ZodDefault<z.ZodEnum<["memory", "redis", "upstash"]>>;
+        url: z.ZodOptional<z.ZodString>;
+        upstashUrl: z.ZodOptional<z.ZodString>;
+        upstashToken: z.ZodOptional<z.ZodString>;
+        defaultTTL: z.ZodDefault<z.ZodNumber>;
+        keyPrefix: z.ZodDefault<z.ZodString>;
+        maxRetries: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        provider: "memory" | "redis" | "upstash";
+        defaultTTL: number;
+        keyPrefix: string;
+        maxRetries: number;
+        url?: string | undefined;
+        upstashUrl?: string | undefined;
+        upstashToken?: string | undefined;
+    }, {
+        provider?: "memory" | "redis" | "upstash" | undefined;
+        url?: string | undefined;
+        upstashUrl?: string | undefined;
+        upstashToken?: string | undefined;
+        defaultTTL?: number | undefined;
+        keyPrefix?: string | undefined;
+        maxRetries?: number | undefined;
+    }>, {
+        provider: "memory" | "redis" | "upstash";
+        defaultTTL: number;
+        keyPrefix: string;
+        maxRetries: number;
+        url?: string | undefined;
+        upstashUrl?: string | undefined;
+        upstashToken?: string | undefined;
+    }, {
+        provider?: "memory" | "redis" | "upstash" | undefined;
+        url?: string | undefined;
+        upstashUrl?: string | undefined;
+        upstashToken?: string | undefined;
+        defaultTTL?: number | undefined;
+        keyPrefix?: string | undefined;
+        maxRetries?: number | undefined;
+    }>>;
+    storage: z.ZodDefault<z.ZodEffects<z.ZodObject<{
+        provider: z.ZodDefault<z.ZodEnum<["memory", "s3", "minio", "r2", "supabase"]>>;
+        endpoint: z.ZodOptional<z.ZodString>;
+        region: z.ZodDefault<z.ZodString>;
+        accessKey: z.ZodOptional<z.ZodString>;
+        secretKey: z.ZodOptional<z.ZodString>;
+        bucket: z.ZodOptional<z.ZodString>;
+        publicUrl: z.ZodOptional<z.ZodString>;
+        forcePathStyle: z.ZodDefault<z.ZodBoolean>;
+        signedUrlExpiry: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        provider: "memory" | "supabase" | "s3" | "minio" | "r2";
+        region: string;
+        forcePathStyle: boolean;
+        signedUrlExpiry: number;
+        endpoint?: string | undefined;
+        accessKey?: string | undefined;
+        secretKey?: string | undefined;
+        bucket?: string | undefined;
+        publicUrl?: string | undefined;
+    }, {
+        provider?: "memory" | "supabase" | "s3" | "minio" | "r2" | undefined;
+        endpoint?: string | undefined;
+        region?: string | undefined;
+        accessKey?: string | undefined;
+        secretKey?: string | undefined;
+        bucket?: string | undefined;
+        publicUrl?: string | undefined;
+        forcePathStyle?: boolean | undefined;
+        signedUrlExpiry?: number | undefined;
+    }>, {
+        provider: "memory" | "supabase" | "s3" | "minio" | "r2";
+        region: string;
+        forcePathStyle: boolean;
+        signedUrlExpiry: number;
+        endpoint?: string | undefined;
+        accessKey?: string | undefined;
+        secretKey?: string | undefined;
+        bucket?: string | undefined;
+        publicUrl?: string | undefined;
+    }, {
+        provider?: "memory" | "supabase" | "s3" | "minio" | "r2" | undefined;
+        endpoint?: string | undefined;
+        region?: string | undefined;
+        accessKey?: string | undefined;
+        secretKey?: string | undefined;
+        bucket?: string | undefined;
+        publicUrl?: string | undefined;
+        forcePathStyle?: boolean | undefined;
+        signedUrlExpiry?: number | undefined;
+    }>>;
+    email: z.ZodDefault<z.ZodEffects<z.ZodObject<{
+        provider: z.ZodDefault<z.ZodEnum<["memory", "console", "smtp", "resend"]>>;
+        host: z.ZodOptional<z.ZodString>;
+        port: z.ZodOptional<z.ZodNumber>;
+        secure: z.ZodDefault<z.ZodBoolean>;
+        username: z.ZodOptional<z.ZodString>;
+        password: z.ZodOptional<z.ZodString>;
+        apiKey: z.ZodOptional<z.ZodString>;
+        from: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodString]>>;
+        replyTo: z.ZodOptional<z.ZodString>;
+        rateLimitPerSecond: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        provider: "console" | "memory" | "smtp" | "resend";
+        secure: boolean;
+        rateLimitPerSecond: number;
+        host?: string | undefined;
+        port?: number | undefined;
+        username?: string | undefined;
+        password?: string | undefined;
+        apiKey?: string | undefined;
+        from?: string | undefined;
+        replyTo?: string | undefined;
+    }, {
+        provider?: "console" | "memory" | "smtp" | "resend" | undefined;
+        host?: string | undefined;
+        port?: number | undefined;
+        secure?: boolean | undefined;
+        username?: string | undefined;
+        password?: string | undefined;
+        apiKey?: string | undefined;
+        from?: string | undefined;
+        replyTo?: string | undefined;
+        rateLimitPerSecond?: number | undefined;
+    }>, {
+        provider: "console" | "memory" | "smtp" | "resend";
+        secure: boolean;
+        rateLimitPerSecond: number;
+        host?: string | undefined;
+        port?: number | undefined;
+        username?: string | undefined;
+        password?: string | undefined;
+        apiKey?: string | undefined;
+        from?: string | undefined;
+        replyTo?: string | undefined;
+    }, {
+        provider?: "console" | "memory" | "smtp" | "resend" | undefined;
+        host?: string | undefined;
+        port?: number | undefined;
+        secure?: boolean | undefined;
+        username?: string | undefined;
+        password?: string | undefined;
+        apiKey?: string | undefined;
+        from?: string | undefined;
+        replyTo?: string | undefined;
+        rateLimitPerSecond?: number | undefined;
+    }>>;
+    queue: z.ZodDefault<z.ZodEffects<z.ZodObject<{
+        provider: z.ZodDefault<z.ZodEnum<["memory", "bullmq"]>>;
+        redisUrl: z.ZodOptional<z.ZodString>;
+        queueName: z.ZodDefault<z.ZodString>;
+        concurrency: z.ZodDefault<z.ZodNumber>;
+        maxRetries: z.ZodDefault<z.ZodNumber>;
+        retryDelay: z.ZodDefault<z.ZodNumber>;
+        removeOnComplete: z.ZodDefault<z.ZodBoolean>;
+        removeOnFail: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        provider: "memory" | "bullmq";
+        maxRetries: number;
+        queueName: string;
+        concurrency: number;
+        retryDelay: number;
+        removeOnComplete: boolean;
+        removeOnFail: boolean;
+        redisUrl?: string | undefined;
+    }, {
+        provider?: "memory" | "bullmq" | undefined;
+        maxRetries?: number | undefined;
+        redisUrl?: string | undefined;
+        queueName?: string | undefined;
+        concurrency?: number | undefined;
+        retryDelay?: number | undefined;
+        removeOnComplete?: boolean | undefined;
+        removeOnFail?: boolean | undefined;
+    }>, {
+        provider: "memory" | "bullmq";
+        maxRetries: number;
+        queueName: string;
+        concurrency: number;
+        retryDelay: number;
+        removeOnComplete: boolean;
+        removeOnFail: boolean;
+        redisUrl?: string | undefined;
+    }, {
+        provider?: "memory" | "bullmq" | undefined;
+        maxRetries?: number | undefined;
+        redisUrl?: string | undefined;
+        queueName?: string | undefined;
+        concurrency?: number | undefined;
+        retryDelay?: number | undefined;
+        removeOnComplete?: boolean | undefined;
+        removeOnFail?: boolean | undefined;
+    }>>;
+    resilience: z.ZodDefault<z.ZodObject<{
+        retry: z.ZodDefault<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            maxAttempts: z.ZodDefault<z.ZodNumber>;
+            baseDelay: z.ZodDefault<z.ZodNumber>;
+            maxDelay: z.ZodDefault<z.ZodNumber>;
+            backoffMultiplier: z.ZodDefault<z.ZodNumber>;
+            jitter: z.ZodDefault<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            enabled: boolean;
+            maxAttempts: number;
+            baseDelay: number;
+            maxDelay: number;
+            backoffMultiplier: number;
+            jitter: boolean;
+        }, {
+            enabled?: boolean | undefined;
+            maxAttempts?: number | undefined;
+            baseDelay?: number | undefined;
+            maxDelay?: number | undefined;
+            backoffMultiplier?: number | undefined;
+            jitter?: boolean | undefined;
+        }>>;
+        circuitBreaker: z.ZodDefault<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            failureThreshold: z.ZodDefault<z.ZodNumber>;
+            resetTimeout: z.ZodDefault<z.ZodNumber>;
+            halfOpenRequests: z.ZodDefault<z.ZodNumber>;
+            monitorInterval: z.ZodDefault<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            enabled: boolean;
+            failureThreshold: number;
+            resetTimeout: number;
+            halfOpenRequests: number;
+            monitorInterval: number;
+        }, {
+            enabled?: boolean | undefined;
+            failureThreshold?: number | undefined;
+            resetTimeout?: number | undefined;
+            halfOpenRequests?: number | undefined;
+            monitorInterval?: number | undefined;
+        }>>;
+        timeout: z.ZodDefault<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            default: z.ZodDefault<z.ZodNumber>;
+            database: z.ZodDefault<z.ZodNumber>;
+            cache: z.ZodDefault<z.ZodNumber>;
+            storage: z.ZodDefault<z.ZodNumber>;
+            email: z.ZodDefault<z.ZodNumber>;
+            queue: z.ZodDefault<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            enabled: boolean;
+            default: number;
+            database: number;
+            cache: number;
+            storage: number;
+            email: number;
+            queue: number;
+        }, {
+            enabled?: boolean | undefined;
+            default?: number | undefined;
+            database?: number | undefined;
+            cache?: number | undefined;
+            storage?: number | undefined;
+            email?: number | undefined;
+            queue?: number | undefined;
+        }>>;
+        bulkhead: z.ZodDefault<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            maxConcurrent: z.ZodDefault<z.ZodNumber>;
+            maxQueued: z.ZodDefault<z.ZodNumber>;
+            timeout: z.ZodDefault<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            enabled: boolean;
+            maxConcurrent: number;
+            maxQueued: number;
+            timeout: number;
+        }, {
+            enabled?: boolean | undefined;
+            maxConcurrent?: number | undefined;
+            maxQueued?: number | undefined;
+            timeout?: number | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        timeout: {
+            enabled: boolean;
+            default: number;
+            database: number;
+            cache: number;
+            storage: number;
+            email: number;
+            queue: number;
+        };
+        retry: {
+            enabled: boolean;
+            maxAttempts: number;
+            baseDelay: number;
+            maxDelay: number;
+            backoffMultiplier: number;
+            jitter: boolean;
+        };
+        circuitBreaker: {
+            enabled: boolean;
+            failureThreshold: number;
+            resetTimeout: number;
+            halfOpenRequests: number;
+            monitorInterval: number;
+        };
+        bulkhead: {
+            enabled: boolean;
+            maxConcurrent: number;
+            maxQueued: number;
+            timeout: number;
+        };
+    }, {
+        timeout?: {
+            enabled?: boolean | undefined;
+            default?: number | undefined;
+            database?: number | undefined;
+            cache?: number | undefined;
+            storage?: number | undefined;
+            email?: number | undefined;
+            queue?: number | undefined;
+        } | undefined;
+        retry?: {
+            enabled?: boolean | undefined;
+            maxAttempts?: number | undefined;
+            baseDelay?: number | undefined;
+            maxDelay?: number | undefined;
+            backoffMultiplier?: number | undefined;
+            jitter?: boolean | undefined;
+        } | undefined;
+        circuitBreaker?: {
+            enabled?: boolean | undefined;
+            failureThreshold?: number | undefined;
+            resetTimeout?: number | undefined;
+            halfOpenRequests?: number | undefined;
+            monitorInterval?: number | undefined;
+        } | undefined;
+        bulkhead?: {
+            enabled?: boolean | undefined;
+            maxConcurrent?: number | undefined;
+            maxQueued?: number | undefined;
+            timeout?: number | undefined;
+        } | undefined;
+    }>>;
+    observability: z.ZodDefault<z.ZodObject<{
+        logging: z.ZodDefault<z.ZodObject<{
+            level: z.ZodDefault<z.ZodEnum<["debug", "info", "warn", "error"]>>;
+            format: z.ZodDefault<z.ZodEnum<["json", "pretty"]>>;
+            includeTimestamp: z.ZodDefault<z.ZodBoolean>;
+            includeCorrelationId: z.ZodDefault<z.ZodBoolean>;
+            redactKeys: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            level: "debug" | "info" | "warn" | "error";
+            format: "json" | "pretty";
+            includeTimestamp: boolean;
+            includeCorrelationId: boolean;
+            redactKeys: string[];
+        }, {
+            level?: "debug" | "info" | "warn" | "error" | undefined;
+            format?: "json" | "pretty" | undefined;
+            includeTimestamp?: boolean | undefined;
+            includeCorrelationId?: boolean | undefined;
+            redactKeys?: string[] | undefined;
+        }>>;
+        metrics: z.ZodDefault<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            prefix: z.ZodDefault<z.ZodString>;
+            defaultTags: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+            flushInterval: z.ZodDefault<z.ZodNumber>;
+            histogramBuckets: z.ZodDefault<z.ZodArray<z.ZodNumber, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            enabled: boolean;
+            prefix: string;
+            defaultTags: Record<string, string>;
+            flushInterval: number;
+            histogramBuckets: number[];
+        }, {
+            enabled?: boolean | undefined;
+            prefix?: string | undefined;
+            defaultTags?: Record<string, string> | undefined;
+            flushInterval?: number | undefined;
+            histogramBuckets?: number[] | undefined;
+        }>>;
+        tracing: z.ZodDefault<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            provider: z.ZodDefault<z.ZodEnum<["noop", "memory", "otlp"]>>;
+            serviceName: z.ZodOptional<z.ZodString>;
+            serviceVersion: z.ZodOptional<z.ZodString>;
+            environment: z.ZodOptional<z.ZodString>;
+            sampleRate: z.ZodDefault<z.ZodNumber>;
+            propagateContext: z.ZodDefault<z.ZodBoolean>;
+            endpoint: z.ZodOptional<z.ZodString>;
+            exporterType: z.ZodDefault<z.ZodEnum<["otlp-http", "otlp-grpc", "console"]>>;
+        }, "strip", z.ZodTypeAny, {
+            provider: "otlp" | "memory" | "noop";
+            enabled: boolean;
+            sampleRate: number;
+            propagateContext: boolean;
+            exporterType: "console" | "otlp-http" | "otlp-grpc";
+            environment?: string | undefined;
+            endpoint?: string | undefined;
+            serviceName?: string | undefined;
+            serviceVersion?: string | undefined;
+        }, {
+            environment?: string | undefined;
+            provider?: "otlp" | "memory" | "noop" | undefined;
+            endpoint?: string | undefined;
+            enabled?: boolean | undefined;
+            serviceName?: string | undefined;
+            serviceVersion?: string | undefined;
+            sampleRate?: number | undefined;
+            propagateContext?: boolean | undefined;
+            exporterType?: "console" | "otlp-http" | "otlp-grpc" | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        logging: {
+            level: "debug" | "info" | "warn" | "error";
+            format: "json" | "pretty";
+            includeTimestamp: boolean;
+            includeCorrelationId: boolean;
+            redactKeys: string[];
+        };
+        metrics: {
+            enabled: boolean;
+            prefix: string;
+            defaultTags: Record<string, string>;
+            flushInterval: number;
+            histogramBuckets: number[];
+        };
+        tracing: {
+            provider: "otlp" | "memory" | "noop";
+            enabled: boolean;
+            sampleRate: number;
+            propagateContext: boolean;
+            exporterType: "console" | "otlp-http" | "otlp-grpc";
+            environment?: string | undefined;
+            endpoint?: string | undefined;
+            serviceName?: string | undefined;
+            serviceVersion?: string | undefined;
+        };
+    }, {
+        logging?: {
+            level?: "debug" | "info" | "warn" | "error" | undefined;
+            format?: "json" | "pretty" | undefined;
+            includeTimestamp?: boolean | undefined;
+            includeCorrelationId?: boolean | undefined;
+            redactKeys?: string[] | undefined;
+        } | undefined;
+        metrics?: {
+            enabled?: boolean | undefined;
+            prefix?: string | undefined;
+            defaultTags?: Record<string, string> | undefined;
+            flushInterval?: number | undefined;
+            histogramBuckets?: number[] | undefined;
+        } | undefined;
+        tracing?: {
+            environment?: string | undefined;
+            provider?: "otlp" | "memory" | "noop" | undefined;
+            endpoint?: string | undefined;
+            enabled?: boolean | undefined;
+            serviceName?: string | undefined;
+            serviceVersion?: string | undefined;
+            sampleRate?: number | undefined;
+            propagateContext?: boolean | undefined;
+            exporterType?: "console" | "otlp-http" | "otlp-grpc" | undefined;
+        } | undefined;
+    }>>;
+    middleware: z.ZodDefault<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        logging: z.ZodDefault<z.ZodBoolean>;
+        metrics: z.ZodDefault<z.ZodBoolean>;
+        slowQuery: z.ZodDefault<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            thresholdMs: z.ZodDefault<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            enabled: boolean;
+            thresholdMs: number;
+        }, {
+            enabled?: boolean | undefined;
+            thresholdMs?: number | undefined;
+        }>>;
+        cache: z.ZodDefault<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            defaultTTL: z.ZodDefault<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            defaultTTL: number;
+            enabled: boolean;
+        }, {
+            defaultTTL?: number | undefined;
+            enabled?: boolean | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+        cache: {
+            defaultTTL: number;
+            enabled: boolean;
+        };
+        logging: boolean;
+        metrics: boolean;
+        slowQuery: {
+            enabled: boolean;
+            thresholdMs: number;
+        };
+    }, {
+        enabled?: boolean | undefined;
+        cache?: {
+            defaultTTL?: number | undefined;
+            enabled?: boolean | undefined;
+        } | undefined;
+        logging?: boolean | undefined;
+        metrics?: boolean | undefined;
+        slowQuery?: {
+            enabled?: boolean | undefined;
+            thresholdMs?: number | undefined;
+        } | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    database: {
+        provider: "memory" | "postgres" | "supabase";
+        poolSize: number;
+        connectionTimeout: number;
+        url?: string | undefined;
+        connectionString?: string | undefined;
+        supabaseUrl?: string | undefined;
+        supabaseAnonKey?: string | undefined;
+        supabaseServiceRoleKey?: string | undefined;
+        ssl?: boolean | {
+            rejectUnauthorized?: boolean | undefined;
+        } | undefined;
+    };
+    cache: {
+        provider: "memory" | "redis" | "upstash";
+        defaultTTL: number;
+        keyPrefix: string;
+        maxRetries: number;
+        url?: string | undefined;
+        upstashUrl?: string | undefined;
+        upstashToken?: string | undefined;
+    };
+    storage: {
+        provider: "memory" | "supabase" | "s3" | "minio" | "r2";
+        region: string;
+        forcePathStyle: boolean;
+        signedUrlExpiry: number;
+        endpoint?: string | undefined;
+        accessKey?: string | undefined;
+        secretKey?: string | undefined;
+        bucket?: string | undefined;
+        publicUrl?: string | undefined;
+    };
+    email: {
+        provider: "console" | "memory" | "smtp" | "resend";
+        secure: boolean;
+        rateLimitPerSecond: number;
+        host?: string | undefined;
+        port?: number | undefined;
+        username?: string | undefined;
+        password?: string | undefined;
+        apiKey?: string | undefined;
+        from?: string | undefined;
+        replyTo?: string | undefined;
+    };
+    queue: {
+        provider: "memory" | "bullmq";
+        maxRetries: number;
+        queueName: string;
+        concurrency: number;
+        retryDelay: number;
+        removeOnComplete: boolean;
+        removeOnFail: boolean;
+        redisUrl?: string | undefined;
+    };
+    resilience: {
+        timeout: {
+            enabled: boolean;
+            default: number;
+            database: number;
+            cache: number;
+            storage: number;
+            email: number;
+            queue: number;
+        };
+        retry: {
+            enabled: boolean;
+            maxAttempts: number;
+            baseDelay: number;
+            maxDelay: number;
+            backoffMultiplier: number;
+            jitter: boolean;
+        };
+        circuitBreaker: {
+            enabled: boolean;
+            failureThreshold: number;
+            resetTimeout: number;
+            halfOpenRequests: number;
+            monitorInterval: number;
+        };
+        bulkhead: {
+            enabled: boolean;
+            maxConcurrent: number;
+            maxQueued: number;
+            timeout: number;
+        };
+    };
+    observability: {
+        logging: {
+            level: "debug" | "info" | "warn" | "error";
+            format: "json" | "pretty";
+            includeTimestamp: boolean;
+            includeCorrelationId: boolean;
+            redactKeys: string[];
+        };
+        metrics: {
+            enabled: boolean;
+            prefix: string;
+            defaultTags: Record<string, string>;
+            flushInterval: number;
+            histogramBuckets: number[];
+        };
+        tracing: {
+            provider: "otlp" | "memory" | "noop";
+            enabled: boolean;
+            sampleRate: number;
+            propagateContext: boolean;
+            exporterType: "console" | "otlp-http" | "otlp-grpc";
+            environment?: string | undefined;
+            endpoint?: string | undefined;
+            serviceName?: string | undefined;
+            serviceVersion?: string | undefined;
+        };
+    };
+    middleware: {
+        enabled: boolean;
+        cache: {
+            defaultTTL: number;
+            enabled: boolean;
+        };
+        logging: boolean;
+        metrics: boolean;
+        slowQuery: {
+            enabled: boolean;
+            thresholdMs: number;
+        };
+    };
+}, {
+    database?: {
+        provider?: "memory" | "postgres" | "supabase" | undefined;
+        url?: string | undefined;
+        connectionString?: string | undefined;
+        supabaseUrl?: string | undefined;
+        supabaseAnonKey?: string | undefined;
+        supabaseServiceRoleKey?: string | undefined;
+        poolSize?: number | undefined;
+        connectionTimeout?: number | undefined;
+        ssl?: boolean | {
+            rejectUnauthorized?: boolean | undefined;
+        } | undefined;
+    } | undefined;
+    cache?: {
+        provider?: "memory" | "redis" | "upstash" | undefined;
+        url?: string | undefined;
+        upstashUrl?: string | undefined;
+        upstashToken?: string | undefined;
+        defaultTTL?: number | undefined;
+        keyPrefix?: string | undefined;
+        maxRetries?: number | undefined;
+    } | undefined;
+    storage?: {
+        provider?: "memory" | "supabase" | "s3" | "minio" | "r2" | undefined;
+        endpoint?: string | undefined;
+        region?: string | undefined;
+        accessKey?: string | undefined;
+        secretKey?: string | undefined;
+        bucket?: string | undefined;
+        publicUrl?: string | undefined;
+        forcePathStyle?: boolean | undefined;
+        signedUrlExpiry?: number | undefined;
+    } | undefined;
+    email?: {
+        provider?: "console" | "memory" | "smtp" | "resend" | undefined;
+        host?: string | undefined;
+        port?: number | undefined;
+        secure?: boolean | undefined;
+        username?: string | undefined;
+        password?: string | undefined;
+        apiKey?: string | undefined;
+        from?: string | undefined;
+        replyTo?: string | undefined;
+        rateLimitPerSecond?: number | undefined;
+    } | undefined;
+    queue?: {
+        provider?: "memory" | "bullmq" | undefined;
+        maxRetries?: number | undefined;
+        redisUrl?: string | undefined;
+        queueName?: string | undefined;
+        concurrency?: number | undefined;
+        retryDelay?: number | undefined;
+        removeOnComplete?: boolean | undefined;
+        removeOnFail?: boolean | undefined;
+    } | undefined;
+    resilience?: {
+        timeout?: {
+            enabled?: boolean | undefined;
+            default?: number | undefined;
+            database?: number | undefined;
+            cache?: number | undefined;
+            storage?: number | undefined;
+            email?: number | undefined;
+            queue?: number | undefined;
+        } | undefined;
+        retry?: {
+            enabled?: boolean | undefined;
+            maxAttempts?: number | undefined;
+            baseDelay?: number | undefined;
+            maxDelay?: number | undefined;
+            backoffMultiplier?: number | undefined;
+            jitter?: boolean | undefined;
+        } | undefined;
+        circuitBreaker?: {
+            enabled?: boolean | undefined;
+            failureThreshold?: number | undefined;
+            resetTimeout?: number | undefined;
+            halfOpenRequests?: number | undefined;
+            monitorInterval?: number | undefined;
+        } | undefined;
+        bulkhead?: {
+            enabled?: boolean | undefined;
+            maxConcurrent?: number | undefined;
+            maxQueued?: number | undefined;
+            timeout?: number | undefined;
+        } | undefined;
+    } | undefined;
+    observability?: {
+        logging?: {
+            level?: "debug" | "info" | "warn" | "error" | undefined;
+            format?: "json" | "pretty" | undefined;
+            includeTimestamp?: boolean | undefined;
+            includeCorrelationId?: boolean | undefined;
+            redactKeys?: string[] | undefined;
+        } | undefined;
+        metrics?: {
+            enabled?: boolean | undefined;
+            prefix?: string | undefined;
+            defaultTags?: Record<string, string> | undefined;
+            flushInterval?: number | undefined;
+            histogramBuckets?: number[] | undefined;
+        } | undefined;
+        tracing?: {
+            environment?: string | undefined;
+            provider?: "otlp" | "memory" | "noop" | undefined;
+            endpoint?: string | undefined;
+            enabled?: boolean | undefined;
+            serviceName?: string | undefined;
+            serviceVersion?: string | undefined;
+            sampleRate?: number | undefined;
+            propagateContext?: boolean | undefined;
+            exporterType?: "console" | "otlp-http" | "otlp-grpc" | undefined;
+        } | undefined;
+    } | undefined;
+    middleware?: {
+        enabled?: boolean | undefined;
+        cache?: {
+            defaultTTL?: number | undefined;
+            enabled?: boolean | undefined;
+        } | undefined;
+        logging?: boolean | undefined;
+        metrics?: boolean | undefined;
+        slowQuery?: {
+            enabled?: boolean | undefined;
+            thresholdMs?: number | undefined;
+        } | undefined;
+    } | undefined;
+}>;
+type PlatformConfig = z.infer<typeof PlatformConfigSchema>;
+type DatabaseConfig = z.infer<typeof DatabaseConfigSchema>;
+type CacheConfig = z.infer<typeof CacheConfigSchema>;
+type StorageConfig = z.infer<typeof StorageConfigSchema>;
+type EmailConfig = z.infer<typeof EmailConfigSchema>;
+type QueueConfig = z.infer<typeof QueueConfigSchema>;
+type ResilienceConfig = z.infer<typeof ResilienceConfigSchema>;
+type ObservabilityConfig = z.infer<typeof ObservabilityConfigSchema>;
+type MiddlewareConfig = z.infer<typeof MiddlewareConfigSchema>;
+/**
+ * Load configuration from environment variables
+ */
+declare function loadConfig(): PlatformConfig;
+/**
+ * Validate configuration object
+ * @throws ZodError if validation fails
+ */
+declare function validateConfig(config: unknown): PlatformConfig;
+/**
+ * Safely validate configuration, returning errors instead of throwing
+ */
+declare function safeValidateConfig(config: unknown): {
+    success: boolean;
+    data?: PlatformConfig;
+    errors?: z.ZodError;
+};
+/**
+ * Get configuration with defaults applied
+ */
+declare function getDefaultConfig(): PlatformConfig;
+
+/**
+ * Platform Factory
+ * Create a platform instance with configured adapters
+ */
+
+/**
+ * Create a platform instance (async version)
+ */
+declare function createPlatformAsync(config?: Partial<PlatformConfig>): Promise<IPlatform>;
+/**
+ * Create a platform instance (sync version - uses memory adapters only)
+ * For production adapters, use createPlatformAsync
+ */
+declare function createPlatform(config?: Partial<PlatformConfig>): IPlatform;
+
+/**
+ * Memory Database Adapter
+ * In-memory implementation for testing
+ */
+
+declare class MemoryDatabase implements IDatabase {
+    private tables;
+    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>;
+    /**
+     * Clear all data (for testing)
+     */
+    clear(): void;
+    /**
+     * Get table data (for testing)
+     */
+    getTable<T = unknown>(tableName: string): T[];
+}
+
+/**
+ * Memory Cache Adapter
+ * In-memory implementation for testing
+ */
+
+declare class MemoryCache implements ICache {
+    private store;
+    private subscriptions;
+    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>;
+    /**
+     * Clear all cached data (for testing)
+     */
+    clear(): void;
+    /**
+     * Get number of cached items (for testing)
+     */
+    get size(): number;
+}
+
+declare class MemoryStorage implements IStorage {
+    private files;
+    upload(key: string, data: Buffer | Blob | ReadableStream, options?: UploadOptions): Promise<{
+        url: string;
+    }>;
+    download(key: string): Promise<Buffer<ArrayBufferLike>>;
+    getSignedUrl(key: string): Promise<string>;
+    delete(key: string): Promise<void>;
+    deleteMany(keys: string[]): Promise<void>;
+    list(prefix?: string): Promise<StorageFile[]>;
+    exists(key: string): Promise<boolean>;
+    getMetadata(key: string): Promise<null>;
+    healthCheck(): Promise<boolean>;
+    /**
+     * Clear all files (for testing)
+     */
+    clear(): void;
+    /**
+     * Get number of stored files (for testing)
+     */
+    get size(): number;
+}
+
+declare class MemoryEmail implements IEmail {
+    private sentEmails;
+    send(message: EmailMessage): Promise<EmailResult>;
+    sendBatch(messages: EmailMessage[]): Promise<EmailResult[]>;
+    healthCheck(): Promise<boolean>;
+    getSentEmails(): EmailMessage[];
+    /**
+     * Clear sent emails (for testing)
+     */
+    clear(): void;
+    /**
+     * Get number of sent emails (for testing)
+     */
+    get size(): number;
+}
+
+declare class MemoryQueue<T = unknown> implements IQueue<T> {
+    private jobs;
+    private handlers;
+    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;
+    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>;
+    /**
+     * Clear all jobs (for testing)
+     */
+    clear(): void;
+    /**
+     * Get all jobs (for testing)
+     */
+    getJobs(): Job<T>[];
+    /**
+     * Get pending jobs (for testing)
+     */
+    getPendingJobs(): Job<T>[];
+    /**
+     * Get number of jobs (for testing)
+     */
+    get size(): number;
+}
+
+/**
+ * Console Email Adapter
+ * Development implementation that logs emails to console instead of sending
+ */
+
+declare class ConsoleEmail implements IEmail {
+    private sentEmails;
+    send(message: EmailMessage): Promise<EmailResult>;
+    sendBatch(messages: EmailMessage[]): Promise<EmailResult[]>;
+    healthCheck(): Promise<boolean>;
+    /**
+     * Get all sent emails (for testing)
+     */
+    getSentEmails(): EmailMessage[];
+    /**
+     * Clear sent emails (for testing)
+     */
+    clearSentEmails(): void;
+    private formatAddress;
+    private formatAddresses;
+}
+
+export { type SpanContext as $, type LoggerConfig as A, type MetricTags as B, ConsoleEmail as C, type Secret as D, EnvSecrets as E, type SecretMetadata as F, type GetSecretOptions as G, type HistogramStats as H, type IPlatform as I, type Job as J, type SetSecretOptions as K, type LogLevel as L, MemoryDatabase as M, NoopLogger as N, type RotationResult as O, type PlatformHealthStatus as P, type QueryResult as Q, type RotateSecretOptions as R, type StorageFile as S, type TimingStats as T, type UploadOptions as U, createPlatformAsync as V, createScopedMetrics as W, MemoryTracing as X, NoopTracing as Y, type ITracing as Z, type ISpan as _, MemoryCache as a, type SpanOptions as a0, type SpanStatus as a1, type SpanKind as a2, type TracingConfig as a3, type EmailAddress as a4, type EmailAttachment as a5, type SpanStatusCode as a6, type SpanEvent as a7, DatabaseProviderSchema as a8, CacheProviderSchema as a9, type QueueConfig as aA, type ResilienceConfig as aB, type ObservabilityConfig as aC, type MiddlewareConfig as aD, loadConfig as aE, validateConfig as aF, safeValidateConfig as aG, getDefaultConfig as aH, StorageProviderSchema as aa, EmailProviderSchema as ab, QueueProviderSchema as ac, TracingProviderSchema as ad, LogLevelSchema as ae, DatabaseConfigSchema as af, CacheConfigSchema as ag, StorageConfigSchema as ah, EmailConfigSchema as ai, QueueConfigSchema as aj, RetryConfigSchema as ak, CircuitBreakerConfigSchema as al, TimeoutConfigSchema as am, BulkheadConfigSchema as an, ResilienceConfigSchema as ao, LoggingConfigSchema as ap, MetricsConfigSchema as aq, TracingConfigSchema as ar, ObservabilityConfigSchema as as, MiddlewareConfigSchema as at, PlatformConfigSchema as au, type PlatformConfig as av, type DatabaseConfig as aw, type CacheConfig as ax, type StorageConfig as ay, type EmailConfig as az, MemoryStorage as b, MemoryEmail as c, MemoryQueue as d, type IDatabase as e, MemorySecrets as f, createPlatform as g, ConsoleLogger as h, MemoryMetrics as i, NoopMetrics as j, type IQueryBuilder as k, type ICache as l, type IStorage as m, type IEmail as n, type IQueue as o, type ILogger as p, type IMetrics as q, type ISecrets as r, type JobOptions as s, type EmailMessage as t, type MetricsSummary as u, type EmailResult as v, type ICacheOptions as w, type JobResult as x, type LogMeta as y, type LogEntry as z };