@digilogiclabs/platform-core 1.0.0 → 1.1.0

package/dist/index.d.mts

@@ -1,5 +1,5 @@
-import { p as ILogger, q as IMetrics, I as IPlatform, P as PlatformHealthStatus, u as MetricsSummary, e as IDatabase, k as IQueryBuilder, Q as QueryResult, l as ICache, m as IStorage, U as UploadOptions, S as StorageFile, n as IEmail, t as EmailMessage, v as EmailResult, o as IQueue, s as JobOptions, J as Job } from './ConsoleEmail-XeUBAnwc.mjs';
-export { an as BulkheadConfigSchema, ax as CacheConfig, ag as CacheConfigSchema, a9 as CacheProviderSchema, al as CircuitBreakerConfigSchema, C as ConsoleEmail, h as ConsoleLogger, aw as DatabaseConfig, af as DatabaseConfigSchema, a8 as DatabaseProviderSchema, a4 as EmailAddress, a5 as EmailAttachment, az as EmailConfig, ai as EmailConfigSchema, ab as EmailProviderSchema, E as EnvSecrets, G as GetSecretOptions, H as HistogramStats, w as ICacheOptions, r as ISecrets, _ as ISpan, Z as ITracing, x as JobResult, z as LogEntry, L as LogLevel, ae as LogLevelSchema, y as LogMeta, A as LoggerConfig, ap as LoggingConfigSchema, a as MemoryCache, M as MemoryDatabase, c as MemoryEmail, i as MemoryMetrics, d as MemoryQueue, f as MemorySecrets, b as MemoryStorage, X as MemoryTracing, B as MetricTags, aq as MetricsConfigSchema, aD as MiddlewareConfig, at as MiddlewareConfigSchema, N as NoopLogger, j as NoopMetrics, Y as NoopTracing, aC as ObservabilityConfig, as as ObservabilityConfigSchema, av as PlatformConfig, au as PlatformConfigSchema, aA as QueueConfig, aj as QueueConfigSchema, ac as QueueProviderSchema, aB as ResilienceConfig, ao as ResilienceConfigSchema, ak as RetryConfigSchema, R as RotateSecretOptions, O as RotationResult, D as Secret, F as SecretMetadata, K as SetSecretOptions, $ as SpanContext, a7 as SpanEvent, a2 as SpanKind, a0 as SpanOptions, a1 as SpanStatus, a6 as SpanStatusCode, ay as StorageConfig, ah as StorageConfigSchema, aa as StorageProviderSchema, am as TimeoutConfigSchema, T as TimingStats, a3 as TracingConfig, ar as TracingConfigSchema, ad as TracingProviderSchema, g as createPlatform, V as createPlatformAsync, W as createScopedMetrics, aH as getDefaultConfig, aE as loadConfig, aG as safeValidateConfig, aF as validateConfig } from './ConsoleEmail-XeUBAnwc.mjs';
+import { p as ILogger, q as IMetrics, I as IPlatform, P as PlatformHealthStatus, u as MetricsSummary, e as IDatabase, k as IQueryBuilder, Q as QueryResult, l as ICache, m as IStorage, U as UploadOptions, S as StorageFile, n as IEmail, t as EmailMessage, v as EmailResult, o as IQueue, s as JobOptions, J as Job, R as RepeatOptions, w as JobState, x as JobEventType, y as JobEventHandler } from './ConsoleEmail-Drr30nct.mjs';
+export { G as BackoffOptions, ax as BulkheadConfigSchema, aH as CacheConfig, aq as CacheConfigSchema, aj as CacheProviderSchema, av as CircuitBreakerConfigSchema, C as ConsoleEmail, h as ConsoleLogger, aG as DatabaseConfig, ap as DatabaseConfigSchema, ai as DatabaseProviderSchema, ac as EmailAddress, ad as EmailAttachment, aJ as EmailConfig, as as EmailConfigSchema, al as EmailProviderSchema, E as EnvSecrets, Z as GetSecretOptions, V as HistogramStats, z as ICacheOptions, r as ISecrets, a6 as ISpan, a5 as ITracing, B as JobContext, D as JobEvent, A as JobResult, K as LogEntry, L as LogLevel, ao as LogLevelSchema, H as LogMeta, O as LoggerConfig, az as LoggingConfigSchema, a as MemoryCache, M as MemoryDatabase, c as MemoryEmail, i as MemoryMetrics, d as MemoryQueue, f as MemorySecrets, b as MemoryStorage, a3 as MemoryTracing, T as MetricTags, aA as MetricsConfigSchema, aN as MiddlewareConfig, aD as MiddlewareConfigSchema, N as NoopLogger, j as NoopMetrics, a4 as NoopTracing, aM as ObservabilityConfig, aC as ObservabilityConfigSchema, aF as PlatformConfig, aE as PlatformConfigSchema, aK as QueueConfig, at as QueueConfigSchema, am as QueueProviderSchema, F as QueueStats, aL as ResilienceConfig, ay as ResilienceConfigSchema, au as RetryConfigSchema, $ as RotateSecretOptions, a0 as RotationResult, X as Secret, Y as SecretMetadata, _ as SetSecretOptions, a7 as SpanContext, ah as SpanEvent, aa as SpanKind, a8 as SpanOptions, a9 as SpanStatus, ag as SpanStatusCode, aI as StorageConfig, ar as StorageConfigSchema, ak as StorageProviderSchema, aw as TimeoutConfigSchema, W as TimingStats, ab as TracingConfig, aB as TracingConfigSchema, an as TracingProviderSchema, ae as calculateBackoff, g as createPlatform, a1 as createPlatformAsync, a2 as createScopedMetrics, af as generateJobId, aR as getDefaultConfig, aO as loadConfig, aQ as safeValidateConfig, aP as validateConfig } from './ConsoleEmail-Drr30nct.mjs';
 export { i as IMigrationDatabase, I as IMigrator, a as Migration, b as MigrationRecord, e as MigrationResult, f as MigrationStatus, M as Migrator, h as MigratorConfig, S as SQL, c as createMigration, d as defineMigration, g as generateVersion, s as sqlMigration } from './index-C_2W7Byw.mjs';
 import { SupabaseClient } from '@supabase/supabase-js';
 import { Pool } from 'pg';
@@ -83,6 +83,1687 @@ declare function toHealthCheckResult(healthy: boolean, latencyMs: number, messag
  */
 declare function timedHealthCheck<T>(fn: () => Promise<T>, successCheck?: (result: T) => boolean): Promise<HealthCheckResult>;
 
+/**
+ * Error Reporter Interface
+ *
+ * Provides a vendor-agnostic way to report and track errors.
+ * Self-hosted by default with optional external integrations.
+ *
+ * Design Principles:
+ * - Self-hostable: Console, File, Memory adapters included
+ * - No cloud lock-in: External services (Sentry, GlitchTip) are optional
+ * - Correlation-aware: Integrates with CorrelationContext
+ * - Zero external costs: Works without any external service
+ */
+interface ErrorContext {
+    /** Unique error ID */
+    errorId?: string;
+    /** Trace ID for distributed tracing */
+    traceId?: string;
+    /** Correlation ID for request/job tracking */
+    correlationId?: string;
+    /** Request ID */
+    requestId?: string;
+    /** User ID if authenticated */
+    userId?: string;
+    /** Tenant ID for multi-tenant apps */
+    tenantId?: string;
+    /** Operation/endpoint that failed */
+    operation?: string;
+    /** Environment (dev, staging, production) */
+    environment?: string;
+    /** Service/component name */
+    service?: string;
+    /** Release/version */
+    release?: string;
+    /** Additional tags for filtering */
+    tags?: Record<string, string>;
+    /** Extra contextual data */
+    extra?: Record<string, unknown>;
+}
+interface ErrorReport {
+    /** Unique report ID */
+    id: string;
+    /** Error message */
+    message: string;
+    /** Error name/type */
+    name: string;
+    /** Stack trace */
+    stack?: string;
+    /** Context at time of error */
+    context: ErrorContext;
+    /** Severity level */
+    level: ErrorLevel;
+    /** Timestamp */
+    timestamp: number;
+    /** Whether error was handled */
+    handled: boolean;
+    /** Fingerprint for grouping similar errors */
+    fingerprint?: string[];
+    /** Breadcrumbs/trail leading to error */
+    breadcrumbs?: Breadcrumb[];
+}
+type ErrorLevel = 'fatal' | 'error' | 'warning' | 'info' | 'debug';
+interface Breadcrumb {
+    /** Category (http, navigation, user, etc.) */
+    category: string;
+    /** Breadcrumb message */
+    message: string;
+    /** Severity level */
+    level?: ErrorLevel;
+    /** Timestamp */
+    timestamp: number;
+    /** Additional data */
+    data?: Record<string, unknown>;
+}
+interface CaptureOptions {
+    /** Override error level */
+    level?: ErrorLevel;
+    /** Additional context */
+    context?: Partial<ErrorContext>;
+    /** Custom fingerprint for grouping */
+    fingerprint?: string[];
+    /** Mark as handled/unhandled */
+    handled?: boolean;
+    /** Additional tags */
+    tags?: Record<string, string>;
+    /** Extra data */
+    extra?: Record<string, unknown>;
+}
+interface ErrorReporterConfig {
+    /** Service/application name */
+    serviceName: string;
+    /** Environment */
+    environment?: string;
+    /** Release version */
+    release?: string;
+    /** Default tags */
+    defaultTags?: Record<string, string>;
+    /** Maximum breadcrumbs to keep */
+    maxBreadcrumbs?: number;
+    /** Whether to capture unhandled errors */
+    captureUnhandled?: boolean;
+    /** Sample rate (0.0 to 1.0) */
+    sampleRate?: number;
+    /** Filter errors before reporting */
+    beforeSend?: (report: ErrorReport) => ErrorReport | null;
+}
+interface IErrorReporter {
+    /**
+     * Capture and report an error
+     */
+    captureError(error: Error, options?: CaptureOptions): string;
+    /**
+     * Capture a message (non-error event)
+     */
+    captureMessage(message: string, options?: CaptureOptions): string;
+    /**
+     * Add a breadcrumb to the trail
+     */
+    addBreadcrumb(breadcrumb: Omit<Breadcrumb, 'timestamp'>): void;
+    /**
+     * Set user context for future errors
+     */
+    setUser(user: {
+        id?: string;
+        email?: string;
+        username?: string;
+    } | null): void;
+    /**
+     * Set extra context for future errors
+     */
+    setContext(name: string, context: Record<string, unknown> | null): void;
+    /**
+     * Set a tag for future errors
+     */
+    setTag(key: string, value: string): void;
+    /**
+     * Get recent error reports (for self-hosted review)
+     */
+    getReports(options?: {
+        limit?: number;
+        level?: ErrorLevel;
+    }): ErrorReport[];
+    /**
+     * Clear stored reports
+     */
+    clearReports(): void;
+    /**
+     * Flush pending reports (for async reporters)
+     */
+    flush(timeout?: number): Promise<boolean>;
+    /**
+     * Close the reporter
+     */
+    close(): Promise<void>;
+}
+/**
+ * Generate unique error ID
+ */
+declare function generateErrorId(): string;
+/**
+ * Generate fingerprint from error
+ */
+declare function generateFingerprint(error: Error): string[];
+/**
+ * Create error report from Error object
+ */
+declare function createErrorReport(error: Error, context: ErrorContext, options?: CaptureOptions): ErrorReport;
+
+/**
+ * Audit Log Interface
+ *
+ * Provides immutable, compliance-ready audit trail logging.
+ * Self-hosted, no external dependencies.
+ *
+ * Features:
+ * - Immutable event logging (append-only)
+ * - Correlation with trace/request context
+ * - Query and filtering capabilities
+ * - Retention policy support
+ * - Tamper detection via checksums
+ */
+/**
+ * Categories of audit events
+ */
+type AuditCategory = 'authentication' | 'authorization' | 'data_access' | 'data_mutation' | 'admin_action' | 'security' | 'system' | 'billing' | 'integration' | 'custom';
+/**
+ * Outcome of the audited action
+ */
+type AuditOutcome = 'success' | 'failure' | 'denied' | 'error';
+/**
+ * Actor who performed the action
+ */
+interface AuditActor {
+    /** Actor type */
+    type: 'user' | 'service' | 'system' | 'anonymous';
+    /** Actor ID (user ID, service name, etc.) */
+    id?: string;
+    /** Display name */
+    name?: string;
+    /** Email if applicable */
+    email?: string;
+    /** IP address */
+    ip?: string;
+    /** User agent */
+    userAgent?: string;
+    /** Session ID */
+    sessionId?: string;
+}
+/**
+ * Target of the audited action
+ */
+interface AuditTarget {
+    /** Target type (e.g., 'user', 'document', 'setting') */
+    type: string;
+    /** Target ID */
+    id?: string;
+    /** Human-readable name */
+    name?: string;
+    /** Additional target attributes */
+    attributes?: Record<string, unknown>;
+}
+/**
+ * Audit event structure
+ */
+interface AuditEvent {
+    /** Unique event ID (generated if not provided) */
+    id?: string;
+    /** Event timestamp (ISO 8601) */
+    timestamp?: string;
+    /** Event category */
+    category: AuditCategory;
+    /** Action performed (e.g., 'user.login', 'document.delete') */
+    action: string;
+    /** Action outcome */
+    outcome: AuditOutcome;
+    /** Actor who performed the action */
+    actor: AuditActor;
+    /** Target of the action */
+    target?: AuditTarget;
+    /** Additional event data */
+    data?: Record<string, unknown>;
+    /** Changes made (for mutations) */
+    changes?: {
+        before?: Record<string, unknown>;
+        after?: Record<string, unknown>;
+    };
+    /** Error details if outcome is 'error' or 'failure' */
+    error?: {
+        code?: string;
+        message?: string;
+        stack?: string;
+    };
+    /** Correlation context */
+    context?: {
+        traceId?: string;
+        correlationId?: string;
+        requestId?: string;
+        tenantId?: string;
+        environment?: string;
+        service?: string;
+    };
+    /** Event checksum for tamper detection */
+    checksum?: string;
+}
+/**
+ * Stored audit event (includes all generated fields)
+ */
+interface StoredAuditEvent extends Required<Pick<AuditEvent, 'id' | 'timestamp'>> {
+    id: string;
+    timestamp: string;
+    category: AuditCategory;
+    action: string;
+    outcome: AuditOutcome;
+    actor: AuditActor;
+    target?: AuditTarget;
+    data?: Record<string, unknown>;
+    changes?: {
+        before?: Record<string, unknown>;
+        after?: Record<string, unknown>;
+    };
+    error?: {
+        code?: string;
+        message?: string;
+        stack?: string;
+    };
+    context?: {
+        traceId?: string;
+        correlationId?: string;
+        requestId?: string;
+        tenantId?: string;
+        environment?: string;
+        service?: string;
+    };
+    checksum: string;
+    /** Sequence number for ordering */
+    sequence: number;
+}
+/**
+ * Query filter for audit events
+ */
+interface AuditQuery {
+    /** Filter by category */
+    category?: AuditCategory | AuditCategory[];
+    /** Filter by action (supports wildcards: 'user.*') */
+    action?: string | string[];
+    /** Filter by outcome */
+    outcome?: AuditOutcome | AuditOutcome[];
+    /** Filter by actor ID */
+    actorId?: string;
+    /** Filter by actor type */
+    actorType?: AuditActor['type'];
+    /** Filter by target type */
+    targetType?: string;
+    /** Filter by target ID */
+    targetId?: string;
+    /** Filter by tenant ID */
+    tenantId?: string;
+    /** Filter by trace ID */
+    traceId?: string;
+    /** Filter by correlation ID */
+    correlationId?: string;
+    /** Start time (inclusive) */
+    from?: Date | string;
+    /** End time (inclusive) */
+    to?: Date | string;
+    /** Search in data fields (JSON path queries) */
+    dataQuery?: Record<string, unknown>;
+    /** Pagination: offset */
+    offset?: number;
+    /** Pagination: limit (default 100, max 1000) */
+    limit?: number;
+    /** Sort order */
+    orderBy?: 'timestamp' | 'sequence';
+    /** Sort direction */
+    order?: 'asc' | 'desc';
+}
+/**
+ * Query result with pagination info
+ */
+interface AuditQueryResult {
+    /** Matching events */
+    events: StoredAuditEvent[];
+    /** Total count (for pagination) */
+    total: number;
+    /** Has more results */
+    hasMore: boolean;
+    /** Query execution time (ms) */
+    executionTime: number;
+}
+/**
+ * Retention policy configuration
+ */
+interface AuditRetentionPolicy {
+    /** Days to retain events (0 = forever) */
+    retentionDays: number;
+    /** Categories exempt from retention policy */
+    exemptCategories?: AuditCategory[];
+    /** Archive before deletion */
+    archiveBeforeDelete?: boolean;
+}
+/**
+ * Audit log statistics
+ */
+interface AuditStats {
+    /** Total events */
+    total: number;
+    /** Events by category */
+    byCategory: Record<AuditCategory, number>;
+    /** Events by outcome */
+    byOutcome: Record<AuditOutcome, number>;
+    /** Oldest event timestamp */
+    oldestEvent?: string;
+    /** Newest event timestamp */
+    newestEvent?: string;
+    /** Storage size in bytes (if available) */
+    storageBytes?: number;
+}
+/**
+ * Configuration for audit log
+ */
+interface AuditLogConfig {
+    /** Service name for context */
+    serviceName: string;
+    /** Environment (development, staging, production) */
+    environment?: string;
+    /** Retention policy */
+    retention?: AuditRetentionPolicy;
+    /** Enable checksum verification */
+    enableChecksums?: boolean;
+    /** Custom ID generator */
+    idGenerator?: () => string;
+    /** Automatically include correlation context */
+    autoCorrelation?: boolean;
+}
+/**
+ * Audit Log Interface
+ *
+ * Provides immutable, queryable audit trail for compliance and security.
+ */
+interface IAuditLog {
+    /**
+     * Log an audit event
+     * @param event - The audit event to log
+     * @returns The stored event with generated fields
+     */
+    log(event: AuditEvent): Promise<StoredAuditEvent>;
+    /**
+     * Log multiple events atomically
+     * @param events - Events to log
+     * @returns Stored events
+     */
+    logBatch(events: AuditEvent[]): Promise<StoredAuditEvent[]>;
+    /**
+     * Query audit events
+     * @param query - Query filters
+     * @returns Query result with events and pagination info
+     */
+    query(query: AuditQuery): Promise<AuditQueryResult>;
+    /**
+     * Get a single event by ID
+     * @param id - Event ID
+     * @returns The event or null if not found
+     */
+    getEvent(id: string): Promise<StoredAuditEvent | null>;
+    /**
+     * Verify event integrity (checksum validation)
+     * @param id - Event ID
+     * @returns True if event is valid, false if tampered
+     */
+    verifyIntegrity(id: string): Promise<boolean>;
+    /**
+     * Get audit statistics
+     * @returns Statistics about the audit log
+     */
+    getStats(): Promise<AuditStats>;
+    /**
+     * Apply retention policy (delete old events)
+     * @param policy - Retention policy to apply (uses config if not provided)
+     * @returns Number of events deleted
+     */
+    applyRetention(policy?: AuditRetentionPolicy): Promise<number>;
+    /**
+     * Export events for archival
+     * @param query - Filter events to export
+     * @returns Events in exportable format
+     */
+    export(query: AuditQuery): Promise<StoredAuditEvent[]>;
+    /**
+     * Health check
+     * @returns True if audit log is operational
+     */
+    healthCheck(): Promise<boolean>;
+    /**
+     * Close connections and cleanup
+     */
+    close(): Promise<void>;
+}
+/**
+ * Generate a unique audit event ID
+ */
+declare function generateAuditId(): string;
+/**
+ * Generate checksum for audit event (SHA-256 hash of canonical JSON)
+ */
+declare function generateChecksum(event: Omit<AuditEvent, 'checksum'>): string;
+/**
+ * Verify if an action matches a pattern (supports wildcards)
+ * @example matchAction('user.login', 'user.*') // true
+ * @example matchAction('user.login', 'user.login') // true
+ * @example matchAction('user.login', 'admin.*') // false
+ */
+declare function matchAction(action: string, pattern: string): boolean;
+/**
+ * Create a standardized audit event for common actions
+ */
+declare const AuditEvents: {
+    /** User authentication events */
+    auth: {
+        login: (actor: AuditActor, outcome: AuditOutcome, data?: Record<string, unknown>) => AuditEvent;
+        logout: (actor: AuditActor) => AuditEvent;
+        tokenRefresh: (actor: AuditActor, outcome: AuditOutcome) => AuditEvent;
+        passwordChange: (actor: AuditActor, outcome: AuditOutcome) => AuditEvent;
+        mfaEnabled: (actor: AuditActor) => AuditEvent;
+    };
+    /** Data access events */
+    data: {
+        read: (actor: AuditActor, target: AuditTarget, outcome?: AuditOutcome) => AuditEvent;
+        create: (actor: AuditActor, target: AuditTarget, data?: Record<string, unknown>) => AuditEvent;
+        update: (actor: AuditActor, target: AuditTarget, before?: Record<string, unknown>, after?: Record<string, unknown>) => AuditEvent;
+        delete: (actor: AuditActor, target: AuditTarget, data?: Record<string, unknown>) => AuditEvent;
+    };
+    /** Admin actions */
+    admin: {
+        settingChange: (actor: AuditActor, setting: string, before: unknown, after: unknown) => AuditEvent;
+        userSuspend: (actor: AuditActor, targetUserId: string, reason?: string) => AuditEvent;
+    };
+    /** Security events */
+    security: {
+        accessDenied: (actor: AuditActor, resource: string, reason?: string) => AuditEvent;
+        rateLimited: (actor: AuditActor, endpoint: string) => AuditEvent;
+        suspiciousActivity: (actor: AuditActor, description: string, data?: Record<string, unknown>) => AuditEvent;
+    };
+    /** Billing events */
+    billing: {
+        subscriptionCreated: (actor: AuditActor, subscriptionId: string, plan: string) => AuditEvent;
+        paymentProcessed: (actor: AuditActor, paymentId: string, amount: number, currency: string) => AuditEvent;
+        paymentFailed: (actor: AuditActor, paymentId: string, reason: string) => AuditEvent;
+    };
+};
+
+/**
+ * Scheduler Interface
+ *
+ * Job scheduling abstraction for cron-based and one-time scheduled tasks.
+ * Built on top of IQueue for execution, providing:
+ * - Cron-based recurring jobs
+ * - One-time scheduled jobs
+ * - Job management (pause, resume, cancel)
+ * - Schedule status and history
+ *
+ * Self-hosted, no external dependencies beyond IQueue.
+ */
+/**
+ * Cron expression type (standard 5-field or 6-field with seconds)
+ * @example '0 * * * *' - Every hour
+ * @example '0 9 * * 1-5' - 9 AM on weekdays
+ * @example '0 0 1 * *' - First day of every month
+ */
+type CronExpression = string;
+/**
+ * Schedule state
+ */
+type ScheduleState = 'active' | 'paused' | 'completed' | 'cancelled';
+/**
+ * Scheduled job definition
+ */
+interface ScheduledJob<T = unknown> {
+    /** Unique schedule ID */
+    id: string;
+    /** Schedule name (for display/identification) */
+    name: string;
+    /** Job description */
+    description?: string;
+    /** Cron expression for recurring jobs */
+    cron?: CronExpression;
+    /** Specific run time for one-time jobs (ISO 8601) */
+    runAt?: string;
+    /** Timezone for cron interpretation (default: UTC) */
+    timezone?: string;
+    /** Job data to pass to handler */
+    data: T;
+    /** Schedule state */
+    state: ScheduleState;
+    /** Creation timestamp */
+    createdAt: string;
+    /** Last modification timestamp */
+    updatedAt: string;
+    /** Next scheduled run time (ISO 8601) */
+    nextRun?: string;
+    /** Last run time (ISO 8601) */
+    lastRun?: string;
+    /** Last run result */
+    lastResult?: 'success' | 'failure';
+    /** Last run error message */
+    lastError?: string;
+    /** Total run count */
+    runCount: number;
+    /** Total failure count */
+    failureCount: number;
+    /** Maximum run count (0 = unlimited) */
+    maxRuns?: number;
+    /** Tags for organization */
+    tags?: string[];
+    /** Metadata */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Schedule creation options
+ */
+interface CreateScheduleOptions<T = unknown> {
+    /** Unique ID (generated if not provided) */
+    id?: string;
+    /** Schedule name */
+    name: string;
+    /** Description */
+    description?: string;
+    /** Cron expression (for recurring) */
+    cron?: CronExpression;
+    /** Run at specific time (for one-time) */
+    runAt?: Date | string;
+    /** Timezone (default: UTC) */
+    timezone?: string;
+    /** Job data */
+    data: T;
+    /** Maximum runs (0 = unlimited, default for recurring) */
+    maxRuns?: number;
+    /** Tags */
+    tags?: string[];
+    /** Metadata */
+    metadata?: Record<string, unknown>;
+    /** Start in paused state */
+    paused?: boolean;
+}
+/**
+ * Schedule update options
+ */
+interface UpdateScheduleOptions<T = unknown> {
+    /** Update cron expression */
+    cron?: CronExpression;
+    /** Update run at time */
+    runAt?: Date | string;
+    /** Update timezone */
+    timezone?: string;
+    /** Update job data */
+    data?: T;
+    /** Update max runs */
+    maxRuns?: number;
+    /** Update tags */
+    tags?: string[];
+    /** Update metadata */
+    metadata?: Record<string, unknown>;
+    /** Update description */
+    description?: string;
+}
+/**
+ * Schedule query options
+ */
+interface ScheduleQuery {
+    /** Filter by state */
+    state?: ScheduleState | ScheduleState[];
+    /** Filter by tags (any match) */
+    tags?: string[];
+    /** Filter by name pattern (supports wildcards) */
+    name?: string;
+    /** Include schedules with next run before this time */
+    nextRunBefore?: Date | string;
+    /** Include schedules with next run after this time */
+    nextRunAfter?: Date | string;
+    /** Pagination: offset */
+    offset?: number;
+    /** Pagination: limit */
+    limit?: number;
+}
+/**
+ * Schedule execution history entry
+ */
+interface ScheduleExecution {
+    /** Execution ID */
+    id: string;
+    /** Schedule ID */
+    scheduleId: string;
+    /** Start time */
+    startedAt: string;
+    /** End time */
+    completedAt?: string;
+    /** Duration in ms */
+    duration?: number;
+    /** Result */
+    result: 'success' | 'failure' | 'running';
+    /** Error message */
+    error?: string;
+    /** Job ID (from queue) */
+    jobId?: string;
+}
+/**
+ * Scheduler statistics
+ */
+interface SchedulerStats {
+    /** Total schedules */
+    total: number;
+    /** Active schedules */
+    active: number;
+    /** Paused schedules */
+    paused: number;
+    /** Completed schedules */
+    completed: number;
+    /** Cancelled schedules */
+    cancelled: number;
+    /** Executions in last 24 hours */
+    executionsLast24h: number;
+    /** Failures in last 24 hours */
+    failuresLast24h: number;
+    /** Next scheduled execution */
+    nextExecution?: string;
+}
+/**
+ * Job handler function
+ */
+type ScheduleHandler<T = unknown> = (job: ScheduledJob<T>, context: ScheduleContext) => Promise<void>;
+/**
+ * Context passed to schedule handler
+ */
+interface ScheduleContext {
+    /** Execution ID */
+    executionId: string;
+    /** Schedule ID */
+    scheduleId: string;
+    /** Scheduled run time */
+    scheduledAt: string;
+    /** Actual run time */
+    startedAt: string;
+    /** Report progress */
+    progress: (percent: number) => void;
+    /** Log message */
+    log: (message: string, level?: 'info' | 'warn' | 'error') => void;
+}
+/**
+ * Scheduler configuration
+ */
+interface SchedulerConfig {
+    /** Default timezone for schedules */
+    defaultTimezone?: string;
+    /** Default max retries for failed jobs */
+    defaultRetries?: number;
+    /** Check interval for upcoming jobs (ms, default 60000) */
+    checkInterval?: number;
+    /** How far ahead to look for jobs (ms, default 300000) */
+    lookAheadWindow?: number;
+    /** Execution history retention (days, default 30) */
+    historyRetentionDays?: number;
+    /** Maximum concurrent executions */
+    maxConcurrency?: number;
+}
+/**
+ * Scheduler Interface
+ *
+ * Provides job scheduling on top of queue infrastructure.
+ */
+interface IScheduler {
+    /**
+     * Create a new schedule
+     */
+    create<T>(options: CreateScheduleOptions<T>): Promise<ScheduledJob<T>>;
+    /**
+     * Get a schedule by ID
+     */
+    get<T>(id: string): Promise<ScheduledJob<T> | null>;
+    /**
+     * Update an existing schedule
+     */
+    update<T>(id: string, options: UpdateScheduleOptions<T>): Promise<ScheduledJob<T>>;
+    /**
+     * Delete a schedule
+     */
+    delete(id: string): Promise<void>;
+    /**
+     * Pause a schedule (stop future executions)
+     */
+    pause(id: string): Promise<void>;
+    /**
+     * Resume a paused schedule
+     */
+    resume(id: string): Promise<void>;
+    /**
+     * Trigger immediate execution of a schedule
+     */
+    trigger(id: string): Promise<string>;
+    /**
+     * List schedules with optional filters
+     */
+    list<T>(query?: ScheduleQuery): Promise<ScheduledJob<T>[]>;
+    /**
+     * Get execution history for a schedule
+     */
+    getHistory(scheduleId: string, limit?: number): Promise<ScheduleExecution[]>;
+    /**
+     * Register a handler for schedules
+     */
+    handle<T>(name: string, handler: ScheduleHandler<T>): void;
+    /**
+     * Start the scheduler (begin processing)
+     */
+    start(): Promise<void>;
+    /**
+     * Stop the scheduler (stop processing)
+     */
+    stop(): Promise<void>;
+    /**
+     * Get scheduler statistics
+     */
+    getStats(): Promise<SchedulerStats>;
+    /**
+     * Health check
+     */
+    healthCheck(): Promise<boolean>;
+    /**
+     * Close and cleanup
+     */
+    close(): Promise<void>;
+}
+/**
+ * Generate schedule ID
+ */
+declare function generateScheduleId(): string;
+/**
+ * Parse cron expression and get next run time
+ * Simple implementation for common patterns
+ */
+declare function getNextCronRun(cron: CronExpression, after?: Date, timezone?: string): Date | null;
+/**
+ * Check if a cron expression is valid
+ */
+declare function isValidCron(cron: CronExpression): boolean;
+/**
+ * Common cron expressions
+ */
+declare const CronPresets: {
+    /** Every minute */
+    readonly everyMinute: "* * * * *";
+    /** Every 5 minutes */
+    readonly every5Minutes: "*/5 * * * *";
+    /** Every 15 minutes */
+    readonly every15Minutes: "*/15 * * * *";
+    /** Every 30 minutes */
+    readonly every30Minutes: "*/30 * * * *";
+    /** Every hour */
+    readonly hourly: "0 * * * *";
+    /** Every day at midnight */
+    readonly daily: "0 0 * * *";
+    /** Every day at 9 AM */
+    readonly dailyAt9AM: "0 9 * * *";
+    /** Every Monday at 9 AM */
+    readonly weeklyMonday: "0 9 * * 1";
+    /** First day of month at midnight */
+    readonly monthly: "0 0 1 * *";
+    /** Every weekday at 9 AM */
+    readonly weekdays: "0 9 * * 1-5";
+    /** Every weekend at 10 AM */
+    readonly weekends: "0 10 * * 0,6";
+};
+/**
+ * Describe a cron expression in human-readable format
+ */
+declare function describeCron(cron: CronExpression): string;
+
+/**
+ * Webhook Interface
+ *
+ * Platform abstraction for webhook management.
+ * Self-hosted, no vendor lock-in.
+ *
+ * Supports both:
+ * - Outbound webhooks (sending events to external systems)
+ * - Inbound webhooks (receiving events from external systems)
+ *
+ * Features:
+ * - Signature verification (HMAC-SHA256, etc.)
+ * - Automatic retries with exponential backoff
+ * - Event filtering
+ * - Delivery tracking and history
+ */
+/**
+ * Webhook state
+ */
+type WebhookState = 'active' | 'paused' | 'disabled' | 'failed';
+/**
+ * Delivery status
+ */
+type DeliveryStatus = 'pending' | 'success' | 'failed' | 'skipped';
+/**
+ * Signature algorithm
+ */
+type SignatureAlgorithm = 'sha256' | 'sha512' | 'sha1';
+/**
+ * Registered webhook endpoint
+ */
+interface WebhookEndpoint {
+    /** Unique identifier */
+    id: string;
+    /** Human-readable name */
+    name: string;
+    /** Description */
+    description?: string;
+    /** Target URL for delivery */
+    url: string;
+    /** Secret for signature verification */
+    secret: string;
+    /** Signature algorithm */
+    signatureAlgorithm: SignatureAlgorithm;
+    /** Header name for signature */
+    signatureHeader: string;
+    /** Events this webhook subscribes to (glob patterns supported) */
+    events: string[];
+    /** Current state */
+    state: WebhookState;
+    /** Custom headers to include */
+    headers?: Record<string, string>;
+    /** Metadata */
+    metadata?: Record<string, unknown>;
+    /** Tags for organization */
+    tags?: string[];
+    /** Created timestamp */
+    createdAt: string;
+    /** Last updated timestamp */
+    updatedAt: string;
+    /** Last delivery attempt */
+    lastDeliveryAt?: string;
+    /** Last successful delivery */
+    lastSuccessAt?: string;
+    /** Consecutive failures */
+    failureCount: number;
+    /** Total deliveries */
+    totalDeliveries: number;
+    /** Successful deliveries */
+    successfulDeliveries: number;
+}
+/**
+ * Webhook event to send
+ */
+interface WebhookEvent<T = unknown> {
+    /** Event type (e.g., 'user.created', 'order.completed') */
+    type: string;
+    /** Event payload */
+    payload: T;
+    /** Optional event ID (auto-generated if not provided) */
+    id?: string;
+    /** Timestamp (ISO 8601, auto-generated if not provided) */
+    timestamp?: string;
+    /** Correlation ID for tracing */
+    correlationId?: string;
+    /** Source of the event */
+    source?: string;
+    /** Metadata */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Delivery attempt record
+ */
+interface DeliveryAttempt {
+    /** Attempt ID */
+    id: string;
+    /** Webhook endpoint ID */
+    endpointId: string;
+    /** Event ID */
+    eventId: string;
+    /** Event type */
+    eventType: string;
+    /** Attempt number (1-based) */
+    attemptNumber: number;
+    /** Status */
+    status: DeliveryStatus;
+    /** HTTP status code */
+    statusCode?: number;
+    /** Response body (truncated) */
+    responseBody?: string;
+    /** Response headers */
+    responseHeaders?: Record<string, string>;
+    /** Request duration in ms */
+    duration?: number;
+    /** Error message if failed */
+    error?: string;
+    /** Timestamp */
+    timestamp: string;
+    /** Next retry timestamp (if scheduled) */
+    nextRetryAt?: string;
+}
+/**
+ * Delivery record
+ */
+interface WebhookDelivery {
+    /** Unique delivery ID */
+    id: string;
+    /** Webhook endpoint ID */
+    endpointId: string;
+    /** Event ID */
+    eventId: string;
+    /** Event type */
+    eventType: string;
+    /** Event payload (JSON string) */
+    payload: string;
+    /** Final status */
+    status: DeliveryStatus;
+    /** Total attempts */
+    attempts: number;
+    /** All attempt records */
+    attemptHistory: DeliveryAttempt[];
+    /** Created timestamp */
+    createdAt: string;
+    /** Completed timestamp */
+    completedAt?: string;
+}
+/**
+ * Options for creating a webhook endpoint
+ */
+interface CreateWebhookOptions {
+    /** Optional custom ID */
+    id?: string;
+    /** Human-readable name */
+    name: string;
+    /** Description */
+    description?: string;
+    /** Target URL */
+    url: string;
+    /** Secret for signatures (auto-generated if not provided) */
+    secret?: string;
+    /** Signature algorithm (default: sha256) */
+    signatureAlgorithm?: SignatureAlgorithm;
+    /** Signature header name (default: X-Webhook-Signature) */
+    signatureHeader?: string;
+    /** Events to subscribe to */
+    events: string[];
+    /** Custom headers */
+    headers?: Record<string, string>;
+    /** Metadata */
+    metadata?: Record<string, unknown>;
+    /** Tags */
+    tags?: string[];
+    /** Start as paused */
+    paused?: boolean;
+}
+/**
+ * Options for updating a webhook endpoint
+ */
+interface UpdateWebhookOptions {
+    /** Name */
+    name?: string;
+    /** Description */
+    description?: string;
+    /** URL */
+    url?: string;
+    /** Rotate secret */
+    rotateSecret?: boolean;
+    /** Events */
+    events?: string[];
+    /** Headers */
+    headers?: Record<string, string>;
+    /** Metadata */
+    metadata?: Record<string, unknown>;
+    /** Tags */
+    tags?: string[];
+}
+/**
+ * Query options for webhooks
+ */
+interface WebhookQuery {
+    /** Filter by state */
+    state?: WebhookState | WebhookState[];
+    /** Filter by events (match any) */
+    events?: string[];
+    /** Filter by tags (match any) */
+    tags?: string[];
+    /** Filter by name pattern */
+    name?: string;
+    /** Pagination offset */
+    offset?: number;
+    /** Pagination limit */
+    limit?: number;
+}
+/**
+ * Query options for deliveries
+ */
+interface DeliveryQuery {
+    /** Filter by endpoint ID */
+    endpointId?: string;
+    /** Filter by event type */
+    eventType?: string;
+    /** Filter by status */
+    status?: DeliveryStatus | DeliveryStatus[];
+    /** Filter by date range - from */
+    from?: Date | string;
+    /** Filter by date range - to */
+    to?: Date | string;
+    /** Pagination offset */
+    offset?: number;
+    /** Pagination limit */
+    limit?: number;
+}
+/**
+ * Webhook statistics
+ */
+interface WebhookStats {
+    /** Total endpoints */
+    totalEndpoints: number;
+    /** Active endpoints */
+    activeEndpoints: number;
+    /** Paused endpoints */
+    pausedEndpoints: number;
+    /** Failed endpoints (in failure state) */
+    failedEndpoints: number;
+    /** Deliveries in last 24h */
+    deliveriesLast24h: number;
+    /** Successful deliveries in last 24h */
+    successLast24h: number;
+    /** Failed deliveries in last 24h */
+    failuresLast24h: number;
+    /** Average delivery time in ms */
+    avgDeliveryTime: number;
+}
+/**
+ * Inbound webhook verification result
+ */
+interface VerificationResult {
+    /** Whether signature is valid */
+    valid: boolean;
+    /** Parsed payload if valid */
+    payload?: unknown;
+    /** Error message if invalid */
+    error?: string;
+}
+/**
+ * Inbound webhook handler context
+ */
+interface InboundWebhookContext {
+    /** Raw body */
+    rawBody: string | Buffer;
+    /** Signature header value */
+    signature: string;
+    /** Request headers */
+    headers: Record<string, string>;
+    /** Request method */
+    method: string;
+    /** Request path */
+    path: string;
+    /** Query params */
+    query?: Record<string, string>;
+    /** Timestamp header if present */
+    timestamp?: string;
+}
+/**
+ * Inbound webhook configuration
+ */
+interface InboundWebhookConfig {
+    /** Webhook name/identifier */
+    name: string;
+    /** Secret for verification */
+    secret: string;
+    /** Signature algorithm */
+    signatureAlgorithm?: SignatureAlgorithm;
+    /** Signature header name */
+    signatureHeader?: string;
+    /** Timestamp header name (for replay prevention) */
+    timestampHeader?: string;
+    /** Max age for timestamp validation (seconds) */
+    timestampTolerance?: number;
+}
+/**
+ * Webhook configuration
+ */
+interface WebhookConfig {
+    /** Max retry attempts */
+    maxRetries?: number;
+    /** Initial retry delay in ms */
+    retryDelayMs?: number;
+    /** Max retry delay in ms */
+    maxRetryDelayMs?: number;
+    /** Backoff multiplier */
+    backoffMultiplier?: number;
+    /** Request timeout in ms */
+    timeoutMs?: number;
+    /** Max concurrent deliveries */
+    maxConcurrent?: number;
+    /** Failure threshold before disabling webhook */
+    failureThreshold?: number;
+    /** Delivery history retention in days */
+    historyRetentionDays?: number;
+    /** User agent header */
+    userAgent?: string;
+}
+/**
+ * Webhook manager interface
+ */
+interface IWebhook {
+    /**
+     * Create a new webhook endpoint
+     */
+    create(options: CreateWebhookOptions): Promise<WebhookEndpoint>;
+    /**
+     * Get a webhook endpoint by ID
+     */
+    get(id: string): Promise<WebhookEndpoint | null>;
+    /**
+     * Update a webhook endpoint
+     */
+    update(id: string, options: UpdateWebhookOptions): Promise<WebhookEndpoint>;
+    /**
+     * Delete a webhook endpoint
+     */
+    delete(id: string): Promise<void>;
+    /**
+     * List webhook endpoints
+     */
+    list(query?: WebhookQuery): Promise<WebhookEndpoint[]>;
+    /**
+     * Pause a webhook endpoint
+     */
+    pause(id: string): Promise<void>;
+    /**
+     * Resume a paused webhook endpoint
+     */
+    resume(id: string): Promise<void>;
+    /**
+     * Test a webhook endpoint with a test payload
+     */
+    test(id: string): Promise<DeliveryAttempt>;
+    /**
+     * Dispatch an event to all matching webhooks
+     * Returns number of deliveries queued
+     */
+    dispatch<T>(event: WebhookEvent<T>): Promise<string[]>;
+    /**
+     * Dispatch to a specific endpoint
+     */
+    dispatchTo<T>(endpointId: string, event: WebhookEvent<T>): Promise<string>;
+    /**
+     * Retry a failed delivery
+     */
+    retry(deliveryId: string): Promise<DeliveryAttempt>;
+    /**
+     * Get a delivery by ID
+     */
+    getDelivery(id: string): Promise<WebhookDelivery | null>;
+    /**
+     * List deliveries
+     */
+    listDeliveries(query?: DeliveryQuery): Promise<WebhookDelivery[]>;
+    /**
+     * Get delivery attempts for a delivery
+     */
+    getAttempts(deliveryId: string): Promise<DeliveryAttempt[]>;
+    /**
+     * Register an inbound webhook configuration
+     */
+    registerInbound(config: InboundWebhookConfig): void;
+    /**
+     * Verify an incoming webhook request
+     */
+    verify(name: string, context: InboundWebhookContext): VerificationResult;
+    /**
+     * Get webhook statistics
+     */
+    getStats(): Promise<WebhookStats>;
+    /**
+     * Health check
+     */
+    healthCheck(): Promise<boolean>;
+    /**
+     * Close and cleanup resources
+     */
+    close(): Promise<void>;
+}
+/**
+ * Generate a webhook ID
+ */
+declare function generateWebhookId(): string;
+/**
+ * Generate a delivery ID
+ */
+declare function generateDeliveryId(): string;
+/**
+ * Generate an event ID
+ */
+declare function generateEventId(): string;
+/**
+ * Generate a webhook secret
+ */
+declare function generateWebhookSecret(length?: number): string;
+/**
+ * Check if event type matches a pattern
+ * Supports wildcards: *, **
+ * - * matches single segment: 'user.*' matches 'user.created' but not 'user.profile.updated'
+ * - ** matches all segments: 'user.**' matches 'user.created' and 'user.profile.updated'
+ */
+declare function matchEventType(eventType: string, pattern: string): boolean;
+/**
+ * Calculate next retry delay with exponential backoff
+ */
+declare function calculateRetryDelay(attempt: number, initialDelay?: number, maxDelay?: number, // 1 hour
+multiplier?: number): number;
+/**
+ * Common event type patterns
+ */
+declare const WebhookEventTypes: {
+    readonly USER_CREATED: "user.created";
+    readonly USER_UPDATED: "user.updated";
+    readonly USER_DELETED: "user.deleted";
+    readonly USER_LOGIN: "user.login";
+    readonly USER_LOGOUT: "user.logout";
+    readonly SUBSCRIPTION_CREATED: "subscription.created";
+    readonly SUBSCRIPTION_UPDATED: "subscription.updated";
+    readonly SUBSCRIPTION_CANCELLED: "subscription.cancelled";
+    readonly SUBSCRIPTION_RENEWED: "subscription.renewed";
+    readonly PAYMENT_SUCCEEDED: "payment.succeeded";
+    readonly PAYMENT_FAILED: "payment.failed";
+    readonly PAYMENT_REFUNDED: "payment.refunded";
+    readonly INVOICE_CREATED: "invoice.created";
+    readonly INVOICE_PAID: "invoice.paid";
+    readonly INVOICE_FAILED: "invoice.failed";
+    readonly ORDER_CREATED: "order.created";
+    readonly ORDER_UPDATED: "order.updated";
+    readonly ORDER_COMPLETED: "order.completed";
+    readonly ORDER_CANCELLED: "order.cancelled";
+    readonly ALL: "**";
+    readonly ALL_USER: "user.**";
+    readonly ALL_PAYMENT: "payment.**";
+    readonly ALL_SUBSCRIPTION: "subscription.**";
+    readonly ALL_ORDER: "order.**";
+};
+
+/**
+ * Notification Interface
+ *
+ * Multi-channel notification system with self-hosted options.
+ * Supports in-app, email, push, and SMS notifications.
+ *
+ * Channels:
+ * - in_app: Stored in database, fetched by clients
+ * - email: Uses IEmail adapter
+ * - push: Web Push Protocol (no external service)
+ * - sms: Via SMTP gateway or direct carrier API
+ *
+ * Design Principles:
+ * - Self-hosted by default
+ * - No vendor lock-in
+ * - Multi-channel delivery
+ * - User preferences respected
+ */
+/**
+ * Notification channels
+ */
+type NotificationChannel = 'in_app' | 'email' | 'push' | 'sms';
+/**
+ * Notification priority
+ */
+type NotificationPriority = 'low' | 'normal' | 'high' | 'urgent';
+/**
+ * Notification status
+ */
+type NotificationStatus = 'pending' | 'sent' | 'delivered' | 'read' | 'failed';
+/**
+ * Notification category for filtering and preferences
+ */
+type NotificationCategory = 'system' | 'security' | 'account' | 'billing' | 'marketing' | 'social' | 'updates' | 'alerts' | string;
+/**
+ * Notification template data
+ */
+interface NotificationData {
+    /** Notification title */
+    title: string;
+    /** Notification body/message */
+    body: string;
+    /** Category for filtering */
+    category?: NotificationCategory;
+    /** Priority level */
+    priority?: NotificationPriority;
+    /** URL to link to */
+    url?: string;
+    /** Icon URL */
+    icon?: string;
+    /** Image URL for rich notifications */
+    image?: string;
+    /** Action buttons */
+    actions?: NotificationAction[];
+    /** Custom data payload */
+    data?: Record<string, unknown>;
+    /** Time to live in seconds (default: 86400 = 24 hours) */
+    ttl?: number;
+    /** Collapse key for grouping */
+    collapseKey?: string;
+    /** Sound to play */
+    sound?: string;
+    /** Badge count */
+    badge?: number;
+    /** Tags for filtering */
+    tags?: string[];
+}
+/**
+ * Action button for notifications
+ */
+interface NotificationAction {
+    /** Action identifier */
+    action: string;
+    /** Display title */
+    title: string;
+    /** Icon URL */
+    icon?: string;
+    /** URL to open */
+    url?: string;
+}
+/**
+ * Target for notification delivery
+ */
+interface NotificationTarget {
+    /** User ID */
+    userId?: string;
+    /** User email */
+    email?: string;
+    /** Phone number for SMS */
+    phone?: string;
+    /** Push subscription for web push */
+    pushSubscription?: PushSubscription;
+    /** Device token for mobile push */
+    deviceToken?: string;
+    /** Custom data */
+    data?: Record<string, unknown>;
+}
+/**
+ * Web Push subscription (standard format)
+ */
+interface PushSubscription {
+    /** Push endpoint URL */
+    endpoint: string;
+    /** Expiration time */
+    expirationTime?: number | null;
+    /** Keys for encryption */
+    keys: {
+        /** P-256 key */
+        p256dh: string;
+        /** Auth secret */
+        auth: string;
+    };
+}
+/**
+ * Stored notification record
+ */
+interface StoredNotification {
+    /** Unique notification ID */
+    id: string;
+    /** User ID */
+    userId: string;
+    /** Notification data */
+    data: NotificationData;
+    /** Channels sent to */
+    channels: NotificationChannel[];
+    /** Status per channel */
+    status: Partial<Record<NotificationChannel, NotificationStatus>>;
+    /** Created timestamp */
+    createdAt: string;
+    /** Read timestamp */
+    readAt?: string;
+    /** Metadata */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Options for sending notifications
+ */
+interface SendNotificationOptions {
+    /** Target user/device */
+    target: NotificationTarget;
+    /** Notification data */
+    notification: NotificationData;
+    /** Channels to send to (default: based on user preferences) */
+    channels?: NotificationChannel[];
+    /** Override user preferences */
+    force?: boolean;
+    /** Schedule for later delivery */
+    scheduledFor?: Date | string;
+    /** Idempotency key */
+    idempotencyKey?: string;
+}
+/**
+ * Options for batch notifications
+ */
+interface BatchNotificationOptions {
+    /** Target users */
+    targets: NotificationTarget[];
+    /** Notification data */
+    notification: NotificationData;
+    /** Channels to send to */
+    channels?: NotificationChannel[];
+    /** Max concurrent sends */
+    concurrency?: number;
+}
+/**
+ * User notification preferences
+ */
+interface NotificationPreferences {
+    /** User ID */
+    userId: string;
+    /** Enabled channels */
+    enabledChannels: NotificationChannel[];
+    /** Per-category preferences */
+    categories: Partial<Record<NotificationCategory, {
+        enabled: boolean;
+        channels: NotificationChannel[];
+    }>>;
+    /** Quiet hours (no notifications) */
+    quietHours?: {
+        enabled: boolean;
+        start: string;
+        end: string;
+        timezone: string;
+    };
+    /** Email preferences */
+    email?: {
+        digest: boolean;
+        digestFrequency: 'daily' | 'weekly' | 'never';
+    };
+}
+/**
+ * Query options for notifications
+ */
+interface NotificationQuery {
+    /** Filter by user ID */
+    userId?: string;
+    /** Filter by category */
+    category?: NotificationCategory | NotificationCategory[];
+    /** Filter by status */
+    status?: NotificationStatus | NotificationStatus[];
+    /** Filter by read status */
+    unreadOnly?: boolean;
+    /** Filter by date range */
+    from?: Date | string;
+    to?: Date | string;
+    /** Pagination */
+    offset?: number;
+    limit?: number;
+}
+/**
+ * Notification result
+ */
+interface NotificationResult {
+    /** Notification ID */
+    id: string;
+    /** Success per channel */
+    results: Partial<Record<NotificationChannel, {
+        success: boolean;
+        messageId?: string;
+        error?: string;
+    }>>;
+}
+/**
+ * Notification statistics
+ */
+interface NotificationStats {
+    /** Total notifications sent */
+    totalSent: number;
+    /** Per channel stats */
+    byChannel: Partial<Record<NotificationChannel, {
+        sent: number;
+        delivered: number;
+        read: number;
+        failed: number;
+    }>>;
+    /** Per category stats */
+    byCategory: Partial<Record<NotificationCategory, number>>;
+    /** Unread count */
+    unreadCount: number;
+}
+/**
+ * Notification configuration
+ */
+interface NotificationConfig {
+    /** Default channels */
+    defaultChannels?: NotificationChannel[];
+    /** Default TTL in seconds */
+    defaultTtl?: number;
+    /** Web Push VAPID keys */
+    vapidKeys?: {
+        publicKey: string;
+        privateKey: string;
+        subject: string;
+    };
+    /** SMS gateway configuration */
+    smsGateway?: {
+        type: 'smtp' | 'twilio' | 'custom';
+        config: Record<string, unknown>;
+    };
+    /** Batch size for bulk sends */
+    batchSize?: number;
+    /** Rate limits per channel */
+    rateLimits?: Partial<Record<NotificationChannel, {
+        perSecond?: number;
+        perMinute?: number;
+        perHour?: number;
+    }>>;
+}
+/**
+ * Notification service interface
+ */
+interface INotification {
+    /**
+     * Send a notification to a user
+     */
+    send(options: SendNotificationOptions): Promise<NotificationResult>;
+    /**
+     * Send notifications to multiple users
+     */
+    sendBatch(options: BatchNotificationOptions): Promise<NotificationResult[]>;
+    /**
+     * Send to a topic/segment (all subscribed users)
+     */
+    sendToTopic(topic: string, notification: NotificationData): Promise<number>;
+    /**
+     * Get notifications for a user
+     */
+    getForUser(userId: string, query?: NotificationQuery): Promise<StoredNotification[]>;
+    /**
+     * Get unread count for a user
+     */
+    getUnreadCount(userId: string, category?: NotificationCategory): Promise<number>;
+    /**
+     * Mark notification as read
+     */
+    markAsRead(notificationId: string): Promise<void>;
+    /**
+     * Mark all notifications as read for a user
+     */
+    markAllAsRead(userId: string, category?: NotificationCategory): Promise<number>;
+    /**
+     * Delete a notification
+     */
+    delete(notificationId: string): Promise<void>;
+    /**
+     * Delete all notifications for a user
+     */
+    deleteAllForUser(userId: string): Promise<number>;
+    /**
+     * Register a push subscription
+     */
+    registerPushSubscription(userId: string, subscription: PushSubscription): Promise<void>;
+    /**
+     * Remove a push subscription
+     */
+    removePushSubscription(userId: string, endpoint: string): Promise<void>;
+    /**
+     * Get push subscriptions for a user
+     */
+    getPushSubscriptions(userId: string): Promise<PushSubscription[]>;
+    /**
+     * Get user notification preferences
+     */
+    getPreferences(userId: string): Promise<NotificationPreferences>;
+    /**
+     * Update user notification preferences
+     */
+    updatePreferences(userId: string, preferences: Partial<NotificationPreferences>): Promise<void>;
+    /**
+     * Subscribe user to a topic
+     */
+    subscribeToTopic(userId: string, topic: string): Promise<void>;
+    /**
+     * Unsubscribe user from a topic
+     */
+    unsubscribeFromTopic(userId: string, topic: string): Promise<void>;
+    /**
+     * Get user's subscribed topics
+     */
+    getUserTopics(userId: string): Promise<string[]>;
+    /**
+     * Get notification statistics
+     */
+    getStats(options?: {
+        userId?: string;
+        period?: 'day' | 'week' | 'month';
+    }): Promise<NotificationStats>;
+    /**
+     * Health check
+     */
+    healthCheck(): Promise<boolean>;
+    /**
+     * Close and cleanup
+     */
+    close(): Promise<void>;
+}
+/**
+ * Generate notification ID
+ */
+declare function generateNotificationId(): string;
+/**
+ * Check if notification is within quiet hours
+ */
+declare function isInQuietHours(preferences: NotificationPreferences): boolean;
+/**
+ * Default preferences factory
+ */
+declare function createDefaultPreferences(userId: string): NotificationPreferences;
+/**
+ * Filter channels based on user preferences
+ */
+declare function filterChannelsByPreferences(requestedChannels: NotificationChannel[], preferences: NotificationPreferences, category?: NotificationCategory, force?: boolean): NotificationChannel[];
+/**
+ * Common notification templates
+ */
+declare const NotificationTemplates: {
+    readonly welcome: (name: string) => NotificationData;
+    readonly passwordChanged: () => NotificationData;
+    readonly newLogin: (location?: string) => NotificationData;
+    readonly paymentSucceeded: (amount: string) => NotificationData;
+    readonly paymentFailed: (reason?: string) => NotificationData;
+    readonly subscriptionExpiring: (daysLeft: number) => NotificationData;
+};
+
 /**
  * Middleware System for Platform Core
  *
@@ -392,6 +2073,171 @@ declare const RateLimitPresets: {
     };
 };
 
+/**
+ * Correlation Context using AsyncLocalStorage
+ *
+ * Provides automatic propagation of trace/correlation IDs and request context
+ * across async operations without explicit passing.
+ *
+ * Design Principles:
+ * - Zero external dependencies (uses Node.js built-in AsyncLocalStorage)
+ * - Self-hosted compatible
+ * - Integrates with logging, metrics, and tracing
+ */
+interface CorrelationData {
+    /** Unique trace ID for distributed tracing */
+    traceId?: string;
+    /** Span ID for current operation */
+    spanId?: string;
+    /** Request ID for HTTP requests */
+    requestId?: string;
+    /** Correlation ID for job/event processing */
+    correlationId?: string;
+    /** User ID if authenticated */
+    userId?: string;
+    /** Tenant ID for multi-tenant applications */
+    tenantId?: string;
+    /** Session ID */
+    sessionId?: string;
+    /** Custom metadata */
+    metadata?: Record<string, unknown>;
+    /** Operation name (for logging) */
+    operation?: string;
+    /** Start time of the context */
+    startTime?: number;
+}
+/**
+ * Singleton correlation context using AsyncLocalStorage
+ */
+declare class CorrelationContextManager {
+    private storage;
+    private idGenerator;
+    constructor();
+    /**
+     * Set custom ID generator
+     */
+    setIdGenerator(generator: () => string): void;
+    /**
+     * Generate a new ID
+     */
+    generateId(): string;
+    /**
+     * Run a function with correlation context
+     */
+    run<T>(data: CorrelationData, fn: () => T): T;
+    /**
+     * Run an async function with correlation context
+     */
+    runAsync<T>(data: CorrelationData, fn: () => Promise<T>): Promise<T>;
+    /**
+     * Get current correlation data
+     */
+    get(): CorrelationData | undefined;
+    /**
+     * Get current correlation data or empty object
+     */
+    getOrEmpty(): CorrelationData;
+    /**
+     * Get trace ID from current context
+     */
+    getTraceId(): string | undefined;
+    /**
+     * Get correlation ID from current context
+     */
+    getCorrelationId(): string | undefined;
+    /**
+     * Get request ID from current context
+     */
+    getRequestId(): string | undefined;
+    /**
+     * Get user ID from current context
+     */
+    getUserId(): string | undefined;
+    /**
+     * Get tenant ID from current context
+     */
+    getTenantId(): string | undefined;
+    /**
+     * Check if we're in a correlation context
+     */
+    isInContext(): boolean;
+    /**
+     * Update current context (merge data)
+     * Note: This doesn't actually update the store, but returns merged data
+     * for use in nested contexts
+     */
+    extend(data: Partial<CorrelationData>): CorrelationData;
+    /**
+     * Run a nested context with extended data
+     */
+    runNested<T>(data: Partial<CorrelationData>, fn: () => T): T;
+    /**
+     * Run a nested async context with extended data
+     */
+    runNestedAsync<T>(data: Partial<CorrelationData>, fn: () => Promise<T>): Promise<T>;
+    /**
+     * Get context as log metadata (for structured logging)
+     */
+    getLogMeta(): Record<string, unknown>;
+    /**
+     * Get context as HTTP headers (for propagation)
+     */
+    getHeaders(): Record<string, string>;
+    /**
+     * Parse context from HTTP headers
+     */
+    parseHeaders(headers: Record<string, string | string[] | undefined>): CorrelationData;
+    /**
+     * Get elapsed time since context start (ms)
+     */
+    getElapsed(): number;
+    /**
+     * Create a child span context
+     */
+    createChildSpan(operation: string): CorrelationData;
+}
+/**
+ * Global correlation context instance
+ */
+declare const correlationContext: CorrelationContextManager;
+declare const runWithContext: <T>(data: CorrelationData, fn: () => T) => T;
+declare const runWithContextAsync: <T>(data: CorrelationData, fn: () => Promise<T>) => Promise<T>;
+declare const getContext: () => CorrelationData | undefined;
+declare const getTraceId: () => string | undefined;
+declare const getCorrelationId: () => string | undefined;
+declare const getRequestId: () => string | undefined;
+declare const getUserId: () => string | undefined;
+declare const getTenantId: () => string | undefined;
+declare const getLogMeta: () => Record<string, unknown>;
+declare const isInContext: () => boolean;
+/**
+ * Create correlation context from incoming HTTP request
+ */
+declare function createRequestContext(headers: Record<string, string | string[] | undefined>, options?: {
+    generateTraceId?: boolean;
+    generateRequestId?: boolean;
+    operation?: string;
+    userId?: string;
+    tenantId?: string;
+}): CorrelationData;
+/**
+ * Create correlation context for queue job processing
+ */
+declare function createJobContext(job: {
+    id: string;
+    name: string;
+    correlationId?: string;
+    metadata?: Record<string, unknown>;
+}): CorrelationData;
+/**
+ * Decorator to wrap a function with correlation context
+ */
+declare function withCorrelation<TArgs extends unknown[], TReturn>(fn: (...args: TArgs) => TReturn, getContext: (...args: TArgs) => CorrelationData): (...args: TArgs) => TReturn;
+/**
+ * Decorator to wrap an async function with correlation context
+ */
+declare function withCorrelationAsync<TArgs extends unknown[], TReturn>(fn: (...args: TArgs) => Promise<TReturn>, getContext: (...args: TArgs) => CorrelationData): (...args: TArgs) => Promise<TReturn>;
+
 /**
  * Hooks System for Platform Core
  *
@@ -1532,6 +3378,252 @@ declare function createObservabilityServer(healthEndpoints: HealthEndpoints, met
     port: number;
 }>;
 
+/**
+ * Memory Error Reporter
+ *
+ * Self-hosted error reporting with in-memory storage.
+ * Perfect for development, testing, and self-hosted production.
+ *
+ * Features:
+ * - No external dependencies
+ * - Automatic correlation context integration
+ * - Configurable retention and sampling
+ * - Query/filter error reports
+ */
+
+interface MemoryErrorReporterConfig extends ErrorReporterConfig {
+    /** Maximum reports to keep in memory */
+    maxReports?: number;
+    /** Log errors to console */
+    logToConsole?: boolean;
+    /** Console log level threshold */
+    consoleLogLevel?: ErrorLevel;
+}
+declare class MemoryErrorReporter implements IErrorReporter {
+    private reports;
+    private breadcrumbs;
+    private userContext;
+    private contexts;
+    private tags;
+    private config;
+    constructor(config: MemoryErrorReporterConfig);
+    captureError(error: Error, options?: CaptureOptions): string;
+    captureMessage(message: string, options?: CaptureOptions): string;
+    addBreadcrumb(breadcrumb: Omit<Breadcrumb, 'timestamp'>): void;
+    setUser(user: {
+        id?: string;
+        email?: string;
+        username?: string;
+    } | null): void;
+    setContext(name: string, context: Record<string, unknown> | null): void;
+    setTag(key: string, value: string): void;
+    getReports(options?: {
+        limit?: number;
+        level?: ErrorLevel;
+    }): ErrorReport[];
+    clearReports(): void;
+    flush(_timeout?: number): Promise<boolean>;
+    close(): Promise<void>;
+    /**
+     * Get reports by fingerprint (for grouping analysis)
+     */
+    getReportsByFingerprint(): Map<string, ErrorReport[]>;
+    /**
+     * Get error statistics
+     */
+    getStats(): {
+        total: number;
+        byLevel: Record<ErrorLevel, number>;
+        uniqueErrors: number;
+    };
+    /**
+     * Find reports matching criteria
+     */
+    findReports(predicate: (report: ErrorReport) => boolean): ErrorReport[];
+    /**
+     * Get the most recent report
+     */
+    getLastReport(): ErrorReport | undefined;
+    private buildContext;
+    private createReport;
+    private storeReport;
+    private logToConsole;
+}
+
+/**
+ * Memory Audit Log Implementation
+ *
+ * In-memory audit log for testing and development.
+ * Full IAuditLog compliance with query support.
+ */
+
+interface MemoryAuditLogConfig extends AuditLogConfig {
+    /** Maximum events to store (default 10000) */
+    maxEvents?: number;
+}
+declare class MemoryAuditLog implements IAuditLog {
+    private events;
+    private sequence;
+    private config;
+    constructor(config: MemoryAuditLogConfig);
+    log(event: AuditEvent): Promise<StoredAuditEvent>;
+    logBatch(events: AuditEvent[]): Promise<StoredAuditEvent[]>;
+    query(query: AuditQuery): Promise<AuditQueryResult>;
+    getEvent(id: string): Promise<StoredAuditEvent | null>;
+    verifyIntegrity(id: string): Promise<boolean>;
+    getStats(): Promise<AuditStats>;
+    applyRetention(policy?: AuditRetentionPolicy): Promise<number>;
+    export(query: AuditQuery): Promise<StoredAuditEvent[]>;
+    healthCheck(): Promise<boolean>;
+    close(): Promise<void>;
+    /**
+     * Get all events (for testing)
+     */
+    getAll(): StoredAuditEvent[];
+    /**
+     * Clear all events (for testing)
+     */
+    clear(): void;
+    /**
+     * Get event count (for testing)
+     */
+    get count(): number;
+    /**
+     * Find events by action (for testing)
+     */
+    findByAction(action: string): StoredAuditEvent[];
+    /**
+     * Find events by actor ID (for testing)
+     */
+    findByActor(actorId: string): StoredAuditEvent[];
+    private createStoredEvent;
+    private applyFilters;
+    private enforceMaxEvents;
+}
+
+/**
+ * Memory Webhook Implementation
+ *
+ * In-memory webhook manager for testing.
+ * Simulates HTTP delivery without actual network calls.
+ */
+
+interface MemoryWebhookConfig extends WebhookConfig {
+    /** Simulate failures for testing */
+    failureRate?: number;
+    /** Simulated response delay in ms */
+    simulatedDelay?: number;
+}
+declare class MemoryWebhook implements IWebhook {
+    private endpoints;
+    private deliveries;
+    private inboundConfigs;
+    private config;
+    private dispatchedEvents;
+    constructor(config?: MemoryWebhookConfig);
+    create(options: CreateWebhookOptions): Promise<WebhookEndpoint>;
+    get(id: string): Promise<WebhookEndpoint | null>;
+    update(id: string, options: UpdateWebhookOptions): Promise<WebhookEndpoint>;
+    delete(id: string): Promise<void>;
+    list(query?: WebhookQuery): Promise<WebhookEndpoint[]>;
+    pause(id: string): Promise<void>;
+    resume(id: string): Promise<void>;
+    test(id: string): Promise<DeliveryAttempt>;
+    dispatch<T>(event: WebhookEvent<T>): Promise<string[]>;
+    dispatchTo<T>(endpointId: string, event: WebhookEvent<T>): Promise<string>;
+    retry(deliveryId: string): Promise<DeliveryAttempt>;
+    getDelivery(id: string): Promise<WebhookDelivery | null>;
+    listDeliveries(query?: DeliveryQuery): Promise<WebhookDelivery[]>;
+    getAttempts(deliveryId: string): Promise<DeliveryAttempt[]>;
+    registerInbound(config: InboundWebhookConfig): void;
+    verify(name: string, context: InboundWebhookContext): VerificationResult;
+    getStats(): Promise<WebhookStats>;
+    healthCheck(): Promise<boolean>;
+    close(): Promise<void>;
+    /**
+     * Get all dispatched events (for testing)
+     */
+    getDispatchedEvents(): Array<{
+        endpoint: WebhookEndpoint;
+        event: WebhookEvent;
+    }>;
+    /**
+     * Clear dispatched events (for testing)
+     */
+    clearDispatchedEvents(): void;
+    /**
+     * Get all deliveries (for testing)
+     */
+    getAllDeliveries(): WebhookDelivery[];
+    private executeWithRetries;
+    private executeDelivery;
+    private updateEndpointStats;
+    private computeSignature;
+}
+
+/**
+ * Memory Notification Implementation
+ *
+ * In-memory notification service for testing.
+ * Stores notifications, subscriptions, and preferences in memory.
+ */
+
+interface MemoryNotificationConfig extends NotificationConfig {
+    /** Service name */
+    serviceName?: string;
+}
+declare class MemoryNotification implements INotification {
+    private notifications;
+    private pushSubscriptions;
+    private preferences;
+    private topics;
+    private userTopics;
+    private config;
+    private sentNotifications;
+    constructor(config?: MemoryNotificationConfig);
+    send(options: SendNotificationOptions): Promise<NotificationResult>;
+    sendBatch(options: BatchNotificationOptions): Promise<NotificationResult[]>;
+    sendToTopic(topic: string, notification: NotificationData): Promise<number>;
+    private storeInAppNotification;
+    getForUser(userId: string, query?: NotificationQuery): Promise<StoredNotification[]>;
+    getUnreadCount(userId: string, category?: NotificationCategory): Promise<number>;
+    markAsRead(notificationId: string): Promise<void>;
+    markAllAsRead(userId: string, category?: NotificationCategory): Promise<number>;
+    delete(notificationId: string): Promise<void>;
+    deleteAllForUser(userId: string): Promise<number>;
+    registerPushSubscription(userId: string, subscription: PushSubscription): Promise<void>;
+    removePushSubscription(userId: string, endpoint: string): Promise<void>;
+    getPushSubscriptions(userId: string): Promise<PushSubscription[]>;
+    getPreferences(userId: string): Promise<NotificationPreferences>;
+    updatePreferences(userId: string, preferences: Partial<NotificationPreferences>): Promise<void>;
+    subscribeToTopic(userId: string, topic: string): Promise<void>;
+    unsubscribeFromTopic(userId: string, topic: string): Promise<void>;
+    getUserTopics(userId: string): Promise<string[]>;
+    getStats(options?: {
+        userId?: string;
+        period?: 'day' | 'week' | 'month';
+    }): Promise<NotificationStats>;
+    healthCheck(): Promise<boolean>;
+    close(): Promise<void>;
+    /**
+     * Get all sent notifications (for testing)
+     */
+    getSentNotifications(): Array<{
+        target: NotificationTarget;
+        notification: NotificationData;
+        channels: NotificationChannel[];
+        result: NotificationResult;
+    }>;
+    /**
+     * Clear sent notifications (for testing)
+     */
+    clearSentNotifications(): void;
+    /**
+     * Get all stored notifications (for testing)
+     */
+    getAllNotifications(): StoredNotification[];
+}
+
 /**
  * Supabase Database Adapter
  * Production implementation using Supabase as the database provider
@@ -1984,7 +4076,17 @@ declare class SmtpEmail implements IEmail {
 
 /**
  * BullMQ Queue Adapter
- * Production queue implementation using BullMQ (Redis-backed)
+ *
+ * Production queue implementation using BullMQ (Redis-backed).
+ * Self-hosted, no cloud lock-in - only requires Redis.
+ *
+ * Features:
+ * - Retry with exponential backoff
+ * - Cron/recurring jobs
+ * - Job events
+ * - Dead letter queue (failed jobs)
+ * - Concurrency control
+ * - Progress tracking
  */
 
 interface BullMQConfig {
@@ -2002,6 +4104,8 @@ interface BullMQConfig {
     queueName: string;
     /** Default job options */
     defaultJobOptions?: JobOptions;
+    /** Default worker concurrency */
+    concurrency?: number;
 }
 /**
  * BullMQ Queue Adapter
@@ -2012,6 +4116,7 @@ declare class BullMQQueue<T = unknown> implements IQueue<T> {
     private worker;
     private config;
     private initialized;
+    private eventHandlers;
     constructor(config: BullMQConfig);
     /**
      * Initialize the queue (called lazily on first use)
@@ -2024,8 +4129,12 @@ declare class BullMQQueue<T = unknown> implements IQueue<T> {
         data: T;
         options?: JobOptions;
     }>): Promise<Job<T>[]>;
-    process(handler: (job: Job<T>) => Promise<unknown>): void;
+    process(handler: (job: Job<T>) => Promise<unknown>, options?: {
+        concurrency?: number;
+    }): void;
     private startWorker;
+    private emitEvent;
+    private emitEventById;
     getJob(id: string): Promise<Job<T> | null>;
     removeJob(id: string): Promise<void>;
     pause(): Promise<void>;
@@ -2039,7 +4148,327 @@ declare class BullMQQueue<T = unknown> implements IQueue<T> {
     }>;
     healthCheck(): Promise<boolean>;
     close(): Promise<void>;
+    addRecurring(name: string, data: T, repeat: RepeatOptions, options?: Omit<JobOptions, 'repeat'>): Promise<Job<T>>;
+    getJobs(state: JobState | JobState[], start?: number, end?: number): Promise<Job<T>[]>;
+    getFailedJobs(start?: number, end?: number): Promise<Job<T>[]>;
+    retryJob(id: string): Promise<void>;
+    replayAllFailed(): Promise<number>;
+    updateProgress(id: string, progress: number): Promise<void>;
+    clean(grace: number, limit: number, state: JobState): Promise<string[]>;
+    obliterate(options?: {
+        force?: boolean;
+    }): Promise<void>;
+    on(event: JobEventType, handler: JobEventHandler<T>): void;
+    off(event: JobEventType, handler: JobEventHandler<T>): void;
+    getName(): string;
     private mapJob;
+    private getJobState;
+}
+
+/**
+ * Database Audit Log Implementation
+ *
+ * Production-ready audit log using IDatabase abstraction.
+ * Self-hosted, no vendor lock-in.
+ *
+ * Requires a table with this schema:
+ *
+ * CREATE TABLE audit_logs (
+ *   id VARCHAR(255) PRIMARY KEY,
+ *   sequence BIGSERIAL,
+ *   timestamp TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+ *   category VARCHAR(50) NOT NULL,
+ *   action VARCHAR(255) NOT NULL,
+ *   outcome VARCHAR(20) NOT NULL,
+ *   actor JSONB NOT NULL,
+ *   target JSONB,
+ *   data JSONB,
+ *   changes JSONB,
+ *   error JSONB,
+ *   context JSONB,
+ *   checksum VARCHAR(255),
+ *   created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+ * );
+ *
+ * CREATE INDEX idx_audit_logs_timestamp ON audit_logs(timestamp DESC);
+ * CREATE INDEX idx_audit_logs_category ON audit_logs(category);
+ * CREATE INDEX idx_audit_logs_action ON audit_logs(action);
+ * CREATE INDEX idx_audit_logs_actor_id ON audit_logs((actor->>'id'));
+ * CREATE INDEX idx_audit_logs_tenant_id ON audit_logs((context->>'tenantId'));
+ */
+
+interface DatabaseAuditLogConfig extends AuditLogConfig {
+    /** Database instance */
+    database: IDatabase;
+    /** Table name (default: 'audit_logs') */
+    tableName?: string;
+    /** Batch size for bulk operations */
+    batchSize?: number;
+}
+declare class DatabaseAuditLog implements IAuditLog {
+    private db;
+    private tableName;
+    private config;
+    private sequence;
+    constructor(config: DatabaseAuditLogConfig);
+    log(event: AuditEvent): Promise<StoredAuditEvent>;
+    logBatch(events: AuditEvent[]): Promise<StoredAuditEvent[]>;
+    query(query: AuditQuery): Promise<AuditQueryResult>;
+    getEvent(id: string): Promise<StoredAuditEvent | null>;
+    verifyIntegrity(id: string): Promise<boolean>;
+    getStats(): Promise<AuditStats>;
+    applyRetention(policy?: AuditRetentionPolicy): Promise<number>;
+    export(query: AuditQuery): Promise<StoredAuditEvent[]>;
+    healthCheck(): Promise<boolean>;
+    close(): Promise<void>;
+    /**
+     * SQL to create the audit_logs table (PostgreSQL)
+     */
+    static getCreateTableSQL(tableName?: string): string;
+    private prepareEvent;
+    private rowToEvent;
+}
+
+/**
+ * Database Error Reporter Implementation
+ *
+ * Self-hosted error reporting using database storage.
+ * No external service dependencies, full data ownership.
+ *
+ * Features:
+ * - Error capture and storage
+ * - Stack trace parsing
+ * - Breadcrumb trail
+ * - User context
+ * - Error grouping by fingerprint
+ * - Retention policy
+ */
+
+interface DatabaseErrorReporterConfig extends ErrorReporterConfig {
+    /** Database instance */
+    database: IDatabase;
+    /** Table name for errors (default: 'error_reports') */
+    errorsTable?: string;
+    /** Table name for breadcrumbs (default: 'error_breadcrumbs') */
+    breadcrumbsTable?: string;
+    /** Max stack trace length to store */
+    maxStackTraceLength?: number;
+    /** Retention period in days */
+    retentionDays?: number;
+}
+declare class DatabaseErrorReporter implements IErrorReporter {
+    private db;
+    private errorsTable;
+    private breadcrumbsTable;
+    private maxStackTraceLength;
+    private retentionDays;
+    private breadcrumbs;
+    private reports;
+    private context;
+    private tags;
+    private userContext;
+    private maxBreadcrumbs;
+    private sampleRate;
+    private beforeSend?;
+    private writeQueue;
+    constructor(config: DatabaseErrorReporterConfig);
+    captureError(error: Error, options?: CaptureOptions): string;
+    captureMessage(message: string, options?: CaptureOptions): string;
+    addBreadcrumb(breadcrumb: Omit<Breadcrumb, 'timestamp'>): void;
+    setUser(user: {
+        id?: string;
+        email?: string;
+        username?: string;
+    } | null): void;
+    setContext(name: string, context: Record<string, unknown> | null): void;
+    setTag(key: string, value: string): void;
+    getReports(options?: {
+        limit?: number;
+        level?: ErrorLevel;
+    }): ErrorReport[];
+    clearReports(): void;
+    flush(timeout?: number): Promise<boolean>;
+    close(): Promise<void>;
+    /**
+     * Load reports from database
+     */
+    loadReports(options?: {
+        level?: ErrorLevel;
+        from?: Date | number;
+        to?: Date | number;
+        limit?: number;
+        offset?: number;
+    }): Promise<ErrorReport[]>;
+    /**
+     * Clean up old errors based on retention policy
+     */
+    cleanup(): Promise<number>;
+    /**
+     * Get error statistics
+     */
+    getStats(periodMs?: number): Promise<{
+        total: number;
+        byLevel: Record<ErrorLevel, number>;
+        recentErrors: number;
+    }>;
+    /**
+     * SQL to create error reporter tables (PostgreSQL)
+     */
+    static getCreateTableSQL(errorsTable?: string, breadcrumbsTable?: string): string;
+    private queueWrite;
+    private writeReportToDb;
+    private loadBreadcrumbs;
+    private rowToReport;
+}
+
+/**
+ * Queue-based Scheduler Implementation
+ *
+ * Scheduler built on top of IQueue for job execution.
+ * Self-hosted, uses database for persistence.
+ *
+ * Features:
+ * - Cron-based recurring jobs
+ * - One-time scheduled jobs
+ * - Automatic next-run calculation
+ * - Execution history tracking
+ * - Correlation context integration
+ */
+
+interface QueueSchedulerConfig extends SchedulerConfig {
+    /** Queue instance for job execution */
+    queue: IQueue;
+    /** Database for persistence (optional, uses memory if not provided) */
+    database?: IDatabase;
+    /** Table name for schedules (default: 'scheduled_jobs') */
+    schedulesTable?: string;
+    /** Table name for execution history (default: 'schedule_executions') */
+    executionsTable?: string;
+    /** Service name for correlation */
+    serviceName?: string;
+}
+declare class QueueScheduler implements IScheduler {
+    private queue;
+    private db?;
+    private schedulesTable;
+    private executionsTable;
+    private config;
+    private handlers;
+    private checkTimer?;
+    private running;
+    private memorySchedules;
+    private memoryExecutions;
+    constructor(config: QueueSchedulerConfig);
+    create<T>(options: CreateScheduleOptions<T>): Promise<ScheduledJob<T>>;
+    get<T>(id: string): Promise<ScheduledJob<T> | null>;
+    update<T>(id: string, options: UpdateScheduleOptions<T>): Promise<ScheduledJob<T>>;
+    delete(id: string): Promise<void>;
+    pause(id: string): Promise<void>;
+    resume(id: string): Promise<void>;
+    trigger(id: string): Promise<string>;
+    list<T>(query?: ScheduleQuery): Promise<ScheduledJob<T>[]>;
+    getHistory(scheduleId: string, limit?: number): Promise<ScheduleExecution[]>;
+    handle<T>(name: string, handler: ScheduleHandler<T>): void;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    getStats(): Promise<SchedulerStats>;
+    healthCheck(): Promise<boolean>;
+    close(): Promise<void>;
+    /**
+     * SQL to create scheduler tables (PostgreSQL)
+     */
+    static getCreateTableSQL(schedulesTable?: string, executionsTable?: string): string;
+    private saveSchedule;
+    private loadSchedule;
+    private loadAllSchedules;
+    private scheduleToRow;
+    private rowToSchedule;
+    private rowToExecution;
+    private checkUpcomingJobs;
+    private executeSchedule;
+    private processScheduledJob;
+    private updateScheduleAfterTrigger;
+    private updateScheduleResult;
+    private saveExecution;
+    private completeExecution;
+}
+
+/**
+ * HTTP Webhook Implementation
+ *
+ * Production webhook manager using native fetch.
+ * Self-hosted, uses database for persistence.
+ *
+ * Features:
+ * - HMAC signature verification
+ * - Automatic retries with exponential backoff
+ * - Event filtering with glob patterns
+ * - Delivery tracking and history
+ * - Queue-based async delivery (optional)
+ */
+
+interface HttpWebhookConfig extends WebhookConfig {
+    /** Database for persistence (optional, uses memory if not provided) */
+    database?: IDatabase;
+    /** Queue for async delivery (optional, uses sync if not provided) */
+    queue?: IQueue;
+    /** Table name for endpoints (default: 'webhook_endpoints') */
+    endpointsTable?: string;
+    /** Table name for deliveries (default: 'webhook_deliveries') */
+    deliveriesTable?: string;
+    /** Table name for attempts (default: 'webhook_attempts') */
+    attemptsTable?: string;
+    /** Service name for correlation */
+    serviceName?: string;
+}
+declare class HttpWebhook implements IWebhook {
+    private db?;
+    private queue?;
+    private endpointsTable;
+    private deliveriesTable;
+    private attemptsTable;
+    private config;
+    private inboundConfigs;
+    private memoryEndpoints;
+    private memoryDeliveries;
+    constructor(config?: HttpWebhookConfig);
+    create(options: CreateWebhookOptions): Promise<WebhookEndpoint>;
+    get(id: string): Promise<WebhookEndpoint | null>;
+    update(id: string, options: UpdateWebhookOptions): Promise<WebhookEndpoint>;
+    delete(id: string): Promise<void>;
+    list(query?: WebhookQuery): Promise<WebhookEndpoint[]>;
+    pause(id: string): Promise<void>;
+    resume(id: string): Promise<void>;
+    test(id: string): Promise<DeliveryAttempt>;
+    dispatch<T>(event: WebhookEvent<T>): Promise<string[]>;
+    dispatchTo<T>(endpointId: string, event: WebhookEvent<T>): Promise<string>;
+    retry(deliveryId: string): Promise<DeliveryAttempt>;
+    getDelivery(id: string): Promise<WebhookDelivery | null>;
+    listDeliveries(query?: DeliveryQuery): Promise<WebhookDelivery[]>;
+    getAttempts(deliveryId: string): Promise<DeliveryAttempt[]>;
+    registerInbound(config: InboundWebhookConfig): void;
+    verify(name: string, context: InboundWebhookContext): VerificationResult;
+    getStats(): Promise<WebhookStats>;
+    healthCheck(): Promise<boolean>;
+    close(): Promise<void>;
+    /**
+     * SQL to create webhook tables (PostgreSQL)
+     */
+    static getCreateTableSQL(endpointsTable?: string, deliveriesTable?: string, attemptsTable?: string): string;
+    private saveEndpoint;
+    private loadEndpoint;
+    private loadAllEndpoints;
+    private saveDelivery;
+    private saveAttempt;
+    private executeWithRetries;
+    private executeDelivery;
+    private updateEndpointStats;
+    private computeSignature;
+    private endpointToRow;
+    private rowToEndpoint;
+    private deliveryToRow;
+    private rowToDelivery;
+    private rowToAttempt;
 }
 
-export { Bulkhead, type BulkheadOptions, BulkheadRegistry, BulkheadRejectedError, type BulkheadStats, type BullMQConfig, BullMQQueue, CircuitBreaker, type CircuitBreakerOptions, CircuitBreakerRegistry, type CircuitBreakerStats, CircuitOpenError, type CircuitState, DEFAULT_BULKHEAD_OPTIONS, DEFAULT_CIRCUIT_BREAKER_OPTIONS, DEFAULT_RETRY_OPTIONS, DefaultTimeouts, type DeleteHookContext, type DetailedHealthResponse, type EmailHookContext, EmailMessage, EmailResult, type ErrorHookContext, type FallbackOptions, type FallbackResult, FallbackStrategies, type HealthCheckResult, type HealthEndpoints, type HealthEndpointsOptions, type HealthStatus, type HookRegistry, ICache, IDatabase, IEmail, type IHealth, type IHealthCheckable, ILogger, IMetrics, IPlatform, IQueryBuilder, IQueue, IStorage, type InsertHookContext, Job, type JobHookContext, JobOptions, type LivenessResponse, MemoryRateLimiterStorage, type MetricsEndpoint, type MetricsEndpointOptions, MetricsSummary, type Middleware, type MiddlewareChain, type MiddlewareChainOptions, type MiddlewareContext, type PlatformHealthResult, PlatformHealthStatus, type PlatformHooks, type PostgresConfig, PostgresDatabase, type QueryHookContext, QueryResult, type RateLimitAlgorithm, RateLimitError, type RateLimitInfo, type RateLimitOptions, RateLimitPresets, type RateLimiterStorage, type ReadinessResponse, RedisCache, type RedisConfig, ResendEmail, RetryConfigs, type RetryOptions, RetryPredicates, type RetryResult, S3Storage, type ServiceHealth, type SlidingWindowRateLimitOptions, type SmtpConfig, SmtpEmail, type StartupResponse, StorageFile, SupabaseDatabase, SupabaseStorage, type SupabaseStorageConfig, TimeoutError, type TimeoutOptions, type TokenBucketOptions, type UpdateHookContext, type UploadHookContext, UploadOptions, UpstashCache, composeHookRegistries, createBulkhead, createCacheMiddleware, createCachedFallback, createCircuitBreaker, createExpressHealthHandlers, createExpressMetricsHandler, createHealthEndpoints, createHealthServer, createHookRegistry, createIpKeyGenerator, createLoggingMiddleware, createMetricsEndpoint, createMetricsMiddleware, createMetricsServer, createMiddlewareChain, createMiddlewareContext, createObservabilityServer, createRateLimitMiddleware, createRequestIdMiddleware, createSlowQueryMiddleware, createTenantMiddleware, createTimeoutMiddleware, createUserKeyGenerator, raceTimeout, retryable, timedHealthCheck, toHealthCheckResult, withFallback, withFallbackChain, withFallbackResult, withRetry, withRetryResult, withTimeout, withTimeoutWrapper };
+export { type AuditActor, type AuditCategory, type AuditEvent, AuditEvents, type AuditLogConfig, type AuditOutcome, type AuditQuery, type AuditQueryResult, type AuditRetentionPolicy, type AuditStats, type AuditTarget, type BatchNotificationOptions, type Breadcrumb, Bulkhead, type BulkheadOptions, BulkheadRegistry, BulkheadRejectedError, type BulkheadStats, type BullMQConfig, BullMQQueue, type CaptureOptions, CircuitBreaker, type CircuitBreakerOptions, CircuitBreakerRegistry, type CircuitBreakerStats, CircuitOpenError, type CircuitState, type CorrelationData, type CreateScheduleOptions, type CreateWebhookOptions, type CronExpression, CronPresets, DEFAULT_BULKHEAD_OPTIONS, DEFAULT_CIRCUIT_BREAKER_OPTIONS, DEFAULT_RETRY_OPTIONS, DatabaseAuditLog, type DatabaseAuditLogConfig, DatabaseErrorReporter, type DatabaseErrorReporterConfig, DefaultTimeouts, type DeleteHookContext, type DeliveryAttempt, type DeliveryQuery, type DeliveryStatus, type DetailedHealthResponse, type EmailHookContext, EmailMessage, EmailResult, type ErrorContext, type ErrorHookContext, type ErrorLevel, type ErrorReport, type ErrorReporterConfig, type FallbackOptions, type FallbackResult, FallbackStrategies, type HealthCheckResult, type HealthEndpoints, type HealthEndpointsOptions, type HealthStatus, type HookRegistry, HttpWebhook, type HttpWebhookConfig, type IAuditLog, ICache, IDatabase, IEmail, type IErrorReporter, type IHealth, type IHealthCheckable, ILogger, IMetrics, type INotification, IPlatform, IQueryBuilder, IQueue, type IScheduler, IStorage, type IWebhook, type InboundWebhookConfig, type InboundWebhookContext, type InsertHookContext, Job, JobEventHandler, JobEventType, type JobHookContext, JobOptions, JobState, type LivenessResponse, MemoryAuditLog, type MemoryAuditLogConfig, MemoryErrorReporter, type MemoryErrorReporterConfig, MemoryNotification, type MemoryNotificationConfig, MemoryRateLimiterStorage, MemoryWebhook, type MemoryWebhookConfig, type MetricsEndpoint, type MetricsEndpointOptions, MetricsSummary, type Middleware, type MiddlewareChain, type MiddlewareChainOptions, type MiddlewareContext, type NotificationAction, type NotificationCategory, type NotificationChannel, type NotificationConfig, type NotificationData, type NotificationPreferences, type NotificationPriority, type NotificationQuery, type NotificationResult, type NotificationStats, type NotificationStatus, type NotificationTarget, NotificationTemplates, type PlatformHealthResult, PlatformHealthStatus, type PlatformHooks, type PostgresConfig, PostgresDatabase, type PushSubscription, type QueryHookContext, QueryResult, QueueScheduler, type QueueSchedulerConfig, type RateLimitAlgorithm, RateLimitError, type RateLimitInfo, type RateLimitOptions, RateLimitPresets, type RateLimiterStorage, type ReadinessResponse, RedisCache, type RedisConfig, RepeatOptions, ResendEmail, RetryConfigs, type RetryOptions, RetryPredicates, type RetryResult, S3Storage, type ScheduleContext, type ScheduleExecution, type ScheduleHandler, type ScheduleQuery, type ScheduleState, type ScheduledJob, type SchedulerConfig, type SchedulerStats, type SendNotificationOptions, type ServiceHealth, type SignatureAlgorithm, type SlidingWindowRateLimitOptions, type SmtpConfig, SmtpEmail, type StartupResponse, StorageFile, type StoredAuditEvent, type StoredNotification, SupabaseDatabase, SupabaseStorage, type SupabaseStorageConfig, TimeoutError, type TimeoutOptions, type TokenBucketOptions, type UpdateHookContext, type UpdateScheduleOptions, type UpdateWebhookOptions, type UploadHookContext, UploadOptions, UpstashCache, type VerificationResult, type WebhookConfig, type WebhookDelivery, type WebhookEndpoint, type WebhookEvent, WebhookEventTypes, type WebhookQuery, type WebhookState, type WebhookStats, calculateRetryDelay, composeHookRegistries, correlationContext, createBulkhead, createCacheMiddleware, createCachedFallback, createCircuitBreaker, createDefaultPreferences, createErrorReport, createExpressHealthHandlers, createExpressMetricsHandler, createHealthEndpoints, createHealthServer, createHookRegistry, createIpKeyGenerator, createJobContext, createLoggingMiddleware, createMetricsEndpoint, createMetricsMiddleware, createMetricsServer, createMiddlewareChain, createMiddlewareContext, createObservabilityServer, createRateLimitMiddleware, createRequestContext, createRequestIdMiddleware, createSlowQueryMiddleware, createTenantMiddleware, createTimeoutMiddleware, createUserKeyGenerator, describeCron, filterChannelsByPreferences, generateAuditId, generateChecksum, generateDeliveryId, generateErrorId, generateEventId, generateFingerprint, generateNotificationId, generateScheduleId, generateWebhookId, generateWebhookSecret, getContext, getCorrelationId, getLogMeta, getNextCronRun, getRequestId, getTenantId, getTraceId, getUserId, isInContext, isInQuietHours, isValidCron, matchAction, matchEventType, raceTimeout, retryable, runWithContext, runWithContextAsync, timedHealthCheck, toHealthCheckResult, withCorrelation, withCorrelationAsync, withFallback, withFallbackChain, withFallbackResult, withRetry, withRetryResult, withTimeout, withTimeoutWrapper };