ts-prorm-orm 1.1.0 → 1.2.0

package/dist/compliance/security-decorator.d.ts

@@ -0,0 +1,388 @@
+/**
+ * Security Decorator
+ *
+ * A comprehensive decorator that applies multiple compliance controls to a model
+ * based on a list of security frameworks. Works with the 12 compliance classes.
+ *
+ * Usage:
+ *   @Security({
+ *     frameworks: ['GDPR', 'HIPAA', 'PCI_DSS'],
+ *     audit: true,
+ *     encrypt: ['ssn', 'creditCard'],
+ *     mask: { ssn: 'ssn', creditCard: 'card-last4' },
+ *     retention: { years: 7 },
+ *   })
+ *   class User extends Model { ... }
+ *
+ *   @Security({
+ *     frameworks: ['SOX', 'SEC_17A_4'],
+ *     immutable: true,
+ *   })
+ *   class FinancialRecord extends Model { ... }
+ */
+import { RetentionDuration } from './data-retention';
+/**
+ * All supported security/compliance frameworks.
+ * These map to the 218+ frameworks in docs/sec/SECURITY_COMPLIANCE.md
+ */
+export declare const SecurityFramework: {
+    readonly GDPR: "GDPR";
+    readonly CCPA: "CCPA";
+    readonly CPRA: "CPRA";
+    readonly PIPEDA: "PIPEDA";
+    readonly LGPD: "LGPD";
+    readonly APPI: "APPI";
+    readonly PIPA: "PIPA";
+    readonly PIPL: "PIPL";
+    readonly DPDP: "DPDP";
+    readonly PDPA_THAILAND: "PDPA_Thailand";
+    readonly PDPA_SINGAPORE: "PDPA_Singapore";
+    readonly PDPA_PHILIPPINES: "PDPA_Philippines";
+    readonly PDPA_MALAYSIA: "PDPA_Malaysia";
+    readonly PDPA_INDONESIA: "PDPA_Indonesia";
+    readonly PDPA_VIETNAM: "PDPA_Vietnam";
+    readonly POPI: "PoPI";
+    readonly NDPR: "NDPR";
+    readonly KVKK: "KVKK";
+    readonly UK_GDPR: "UK_GDPR";
+    readonly PCI_DSS: "PCI_DSS";
+    readonly SOX: "SOX";
+    readonly GLBA: "GLBA";
+    readonly MIDIF_II: "MiFID_II";
+    readonly EMIR: "EMIR";
+    readonly BASEL_III: "Basel_III";
+    readonly DODD_FRANK: "Dodd_Frank";
+    readonly SEC_17A_4: "SEC_17a_4";
+    readonly FINRA: "FINRA";
+    readonly NYDFS: "NYDFS";
+    readonly DORA: "DORA";
+    readonly HIPAA: "HIPAA";
+    readonly HITRUST: "HITRUST";
+    readonly CFR_21_PART_11: "21_CFR_Part_11";
+    readonly EU_ANNEX_11: "EU_Annex_11";
+    readonly ALCOA_PLUS: "ALCOA+";
+    readonly GAMP_5: "GAMP_5";
+    readonly ICH_E6_GCP: "ICH_E6_GCP";
+    readonly DISHA: "DISHA";
+    readonly FEDRAMP: "FedRAMP";
+    readonly FISMA: "FISMA";
+    readonly NIST_800_53: "NIST_SP_800_53";
+    readonly NIST_800_171: "NIST_SP_800_171";
+    readonly NIST_CSF: "NIST_CSF";
+    readonly CMMC: "CMMC";
+    readonly DFARS: "DFARS";
+    readonly ITAR: "ITAR";
+    readonly CJIS: "CJIS";
+    readonly NERC_CIP: "NERC_CIP";
+    readonly ISO_27001: "ISO_27001";
+    readonly ISO_27017: "ISO_27017";
+    readonly ISO_27018: "ISO_27018";
+    readonly ISO_27701: "ISO_27701";
+    readonly ISO_22301: "ISO_22301";
+    readonly SOC_2: "SOC_2";
+    readonly SOC_1: "SOC_1";
+    readonly CIS_CONTROLS: "CIS_Controls";
+    readonly OWASP_TOP_10: "OWASP_Top_10";
+    readonly CLOUD_ACT: "CLOUD_Act";
+    readonly SCHREMS_II: "Schrems_II";
+    readonly ESSENTIAL_EIGHT: "Essential_Eight";
+    readonly IT_GRUNDSCHUTZ: "IT_Grundschutz";
+};
+export type SecurityFrameworkType = typeof SecurityFramework[keyof typeof SecurityFramework];
+/**
+ * Set of all valid security framework names.
+ * Use for validation: `if (AllFrameworks.has(myFramework)) { ... }`
+ */
+export declare const AllFrameworks: Set<SecurityFrameworkType>;
+/**
+ * Map of framework category to framework names.
+ * Useful for UI dropdowns or grouped validation.
+ */
+export declare const FrameworkCategories: Record<string, SecurityFrameworkType[]>;
+/**
+ * Validate that a framework name is valid.
+ *
+ * @param framework - Framework name to validate
+ * @returns true if valid, false otherwise
+ */
+export declare function isValidFramework(framework: string): framework is SecurityFrameworkType;
+/**
+ * Get the category for a specific framework.
+ */
+export declare function getFrameworkCategory(framework: SecurityFrameworkType): string | undefined;
+/**
+ * Get all frameworks as an array.
+ */
+export declare function getAllFrameworks(): SecurityFrameworkType[];
+/**
+ * Get framework count.
+ */
+export declare const FrameworkCount: number;
+/**
+ * Map of framework to its required security controls.
+ * Used internally to determine which controls to apply.
+ */
+export declare const FrameworkRequirements: Record<SecurityFrameworkType, {
+    audit?: boolean;
+    encryption?: boolean;
+    retention?: boolean;
+    masking?: boolean;
+    immutable?: boolean;
+    consent?: boolean;
+    rls?: boolean;
+    pseudonymize?: boolean;
+    classification?: boolean;
+    tls?: boolean;
+    lineage?: boolean;
+    breachDetection?: boolean;
+    sessionIsolation?: boolean;
+    worm?: boolean;
+    rateLimit?: boolean;
+    sensitiveDataDiscovery?: boolean;
+    crossBorderLog?: boolean;
+    consentVersioning?: boolean;
+    dsar?: boolean;
+    pia?: boolean;
+    backupVerification?: boolean;
+    queryFirewall?: boolean;
+}>;
+export interface SecurityOptions {
+    /**
+     * List of compliance frameworks to apply.
+     * Used to automatically determine which controls are needed.
+     */
+    frameworks?: SecurityFrameworkType[];
+    /**
+     * Enable audit trail (logs all CRUD operations).
+     */
+    audit?: boolean;
+    /**
+     * Fields to encrypt (AES-256-GCM).
+     */
+    encrypt?: string[];
+    /**
+     * Fields to mask in query output.
+     * Key = field name, Value = masking pattern.
+     */
+    mask?: Record<string, 'ssn' | 'card-last4' | 'card-first6' | 'email' | 'phone' | 'full'>;
+    /**
+     * Data retention policy.
+     */
+    retention?: RetentionDuration;
+    /**
+     * Make records immutable (append-only, no UPDATE/DELETE).
+     */
+    immutable?: boolean;
+    /**
+     * Enable soft versioning for immutable records.
+     */
+    versioning?: boolean;
+    /**
+     * Row-level security scope selector.
+     * Function that returns query filters based on security context.
+     */
+    rls?: (ctx: any) => {
+        where?: Record<string, any>;
+    };
+    /**
+     * Fields to auto-classify as sensitive (PII, PHI, PCI, etc.).
+     */
+    classify?: Record<string, 'PII' | 'PHI' | 'PCI' | 'FINANCIAL' | 'HEALTH' | 'BIOMETRIC'>;
+    /**
+     * Auto-discover sensitive fields based on field name patterns.
+     */
+    autoClassify?: boolean;
+    /**
+     * Custom user ID getter for audit trail.
+     */
+    getUserId?: () => string | number | undefined;
+    /**
+     * Custom IP address getter for audit trail.
+     */
+    getIpAddress?: () => string | undefined;
+    /**
+     * Enable data lineage tracking (track data origin and transformations).
+     */
+    lineage?: boolean;
+    /**
+     * Enable breach detection (monitor for unusual access patterns).
+     */
+    breachDetection?: boolean;
+    /**
+     * Enable session isolation (multi-tenant data isolation).
+     */
+    sessionIsolation?: boolean;
+    /**
+     * Enable WORM storage (Write Once Read Many, immutable archival).
+     */
+    worm?: boolean;
+    /**
+     * Field name that holds the tenant ID, used when session isolation is enabled.
+     * Default: 'tenantId'.
+     */
+    tenantIdField?: string;
+    /**
+     * Enable rate limiting on this model.
+     */
+    rateLimit?: boolean;
+    /**
+     * Enable automatic sensitive data discovery.
+     */
+    sensitiveDataDiscovery?: boolean;
+    /**
+     * Enable cross-border data transfer logging.
+     */
+    crossBorderLog?: boolean;
+    /**
+     * Enable consent versioning.
+     */
+    consentVersioning?: boolean;
+    /**
+     * Enable DSAR (Data Subject Access Request) workflow support.
+     */
+    dsar?: boolean;
+    /**
+     * Enable privacy impact assessment tracking.
+     */
+    pia?: boolean;
+    /**
+     * Enable backup verification.
+     */
+    backupVerification?: boolean;
+    /**
+     * Enable query firewall protections.
+     */
+    queryFirewall?: boolean;
+}
+/**
+ * Apply security controls to a model based on specified frameworks.
+ *
+ * @param options - Security configuration
+ *
+ * @example
+ *   @Security({
+ *     frameworks: ['GDPR', 'HIPAA', 'PCI_DSS'],
+ *     audit: true,
+ *     encrypt: ['ssn', 'creditCard'],
+ *     mask: { ssn: 'ssn', creditCard: 'card-last4' },
+ *     retention: { years: 7 },
+ *     autoClassify: true,
+ *   })
+ *   class Patient extends Model { ... }
+ */
+export declare function Security(options: SecurityOptions): (target: any) => void;
+/**
+ * Apply all security hooks to a model after it's been defined.
+ * Call this after Model.init() or prorm.define().
+ *
+ * @param Model - The model class
+ * @param prorm - The Prorm instance (required for audit)
+ */
+export declare function setupSecurity(Model: any, prorm?: any): void;
+/**
+ * Apply security to all models in a Prorm instance.
+ */
+export declare function setupAllSecurity(prorm: any): void;
+export interface TableSecurityOptions {
+    /**
+     * Database name this table belongs to (for multi-tenant setups).
+     */
+    database?: string;
+    /**
+     * Schema name (PostgreSQL/MySQL schema).
+     */
+    schema?: string;
+    /**
+     * Tables this table depends on (for cascade operations).
+     */
+    dependsOn?: string[];
+    /**
+     * Data classification level for the entire table.
+     */
+    classification?: 'PUBLIC' | 'INTERNAL' | 'CONFIDENTIAL' | 'SECRET' | 'TOP_SECRET';
+    /**
+     * Row-level security enabled for this table.
+     */
+    rlsEnabled?: boolean;
+    /**
+     * Tables in this schema that require audit.
+     */
+    auditEnabled?: boolean;
+}
+/**
+ * Apply table-level security metadata.
+ *
+ * @example
+ *   @Table({
+ *     schema: 'financial',
+ *     classification: 'CONFIDENTIAL',
+ *     rlsEnabled: true,
+ *   })
+ *   class Transaction extends Model { ... }
+ */
+export declare function Table(options?: TableSecurityOptions): (target: any) => void;
+export interface DatabaseSecurityOptions {
+    /**
+     * Database name.
+     */
+    name: string;
+    /**
+     * Geographic region (for data localization compliance).
+     */
+    region?: string;
+    /**
+     * Default classification for new tables.
+     */
+    defaultClassification?: 'PUBLIC' | 'INTERNAL' | 'CONFIDENTIAL' | 'SECRET' | 'TOP_SECRET';
+    /**
+     * Require TLS for all connections.
+     */
+    requireTLS?: boolean;
+    /**
+     * Enable audit logging for all tables by default.
+     */
+    defaultAudit?: boolean;
+    /**
+     * Default retention period for new tables.
+     */
+    defaultRetention?: RetentionDuration;
+    /**
+     * Allowed countries for data storage (data localization).
+     */
+    allowedCountries?: string[];
+}
+/**
+ * Apply database-level security metadata.
+ *
+ * @example
+ *   @Database({
+ *     name: 'healthcare_db',
+ *     region: 'us-east-1',
+ *     classification: 'CONFIDENTIAL',
+ *     requireTLS: true,
+ *     defaultAudit: true,
+ *     allowedCountries: ['US'],
+ *   })
+ *   class HealthcareDB extends Model { ... }
+ */
+export declare function Database(options: DatabaseSecurityOptions): (target: any) => void;
+/**
+ * Get table security options from a model.
+ */
+export declare function getTableSecurity(Model: any): TableSecurityOptions | undefined;
+/**
+ * Get database security options from a model.
+ */
+export declare function getDatabaseSecurity(Model: any): DatabaseSecurityOptions | undefined;
+/**
+ * Get the frameworks applied to a model.
+ */
+export declare function getSecurityFrameworks(Model: any): SecurityFrameworkType[];
+/**
+ * Check if a model has audit enabled.
+ */
+export declare function hasAudit(Model: any): boolean;
+/**
+ * Check if a model is immutable.
+ */
+export declare function isImmutableModel(Model: any): boolean;

package/dist/compliance/security-monitor.d.ts

@@ -0,0 +1,170 @@
+/**
+ * MTAT - Monitoring and Threat Assessment Tool
+ *
+ * A comprehensive security monitoring system that:
+ * - Screens SQL logs for suspicious patterns
+ * - Flags security-relevant events
+ * - Monitors compliance violations (invalid data movement)
+ * - Tracks slow/invalid queries
+ * - Provides real-time alerts
+ *
+ * Usage:
+ *   // Initialize with the MTAT monitor
+ *   const monitor = new SecurityMonitor(prorm, {
+ *     frameworks: ['GDPR', 'HIPAA'],
+ *     alertLevel: 'high',
+ *     onAlert: (alert) => console.log('Security Alert:', alert),
+ *   });
+ *
+ *   // Start monitoring
+ *   await monitor.start();
+ *
+ *   // Query the dashboard
+ *   const stats = monitor.getStats();
+ *   const alerts = monitor.getAlerts();
+ */
+import { Prorm } from '../prorm';
+export type AlertSeverity = 'low' | 'medium' | 'high' | 'critical';
+export type AlertCategory = 'sql_injection' | 'data_exfiltration' | 'unauthorized_access' | 'compliance_violation' | 'slow_query' | 'invalid_query' | 'anomaly' | 'rate_limit' | 'bulk_operation' | 'sensitive_access';
+export interface SecurityAlert {
+    id: string;
+    timestamp: Date;
+    severity: AlertSeverity;
+    category: AlertCategory;
+    message: string;
+    details: Record<string, any>;
+    query?: string;
+    stackTrace?: string;
+}
+export interface SecurityMonitorOptions {
+    /** Active compliance frameworks */
+    frameworks?: string[];
+    /** Minimum severity level to alert on */
+    alertLevel?: AlertSeverity;
+    /** Callback for real-time alerts */
+    onAlert?: (alert: SecurityAlert) => void;
+    /** Enable SQL injection detection */
+    detectSQLInjection?: boolean;
+    /** Enable slow query monitoring */
+    monitorSlowQueries?: boolean;
+    /** Slow query threshold in ms */
+    slowQueryThreshold?: number;
+    /** Enable data exfiltration detection */
+    detectExfiltration?: boolean;
+    /** Enable compliance violation detection */
+    detectComplianceViolations?: boolean;
+    /** Maximum alerts to keep in memory */
+    maxAlerts?: number;
+    /** Rate limit (queries per minute) per user */
+    rateLimitThreshold?: number;
+    /** Enable anomaly detection */
+    detectAnomalies?: boolean;
+    /** Bulk operation threshold */
+    bulkOperationThreshold?: number;
+}
+export declare class SecurityMonitor {
+    private prorm;
+    private options;
+    private alerts;
+    private queryCount;
+    private slowQueryCount;
+    private blockedCount;
+    private startTime;
+    private isRunning;
+    private originalQuery;
+    constructor(prorm: Prorm, options?: SecurityMonitorOptions);
+    /**
+     * Start monitoring queries
+     */
+    start(): Promise<void>;
+    /**
+     * Stop monitoring
+     */
+    stop(): void;
+    /**
+     * Setup hooks for model-level monitoring
+     */
+    private setupHooks;
+    /**
+     * Analyze a query for security issues
+     */
+    private analyzeQuery;
+    /**
+     * Analyze errors for security issues
+     */
+    private analyzeError;
+    /**
+     * Internal query analysis
+     */
+    private analyzeQueryInternal;
+    /**
+     * Check for compliance violations
+     */
+    private checkComplianceViolationDetection;
+    /**
+     * Add an alert
+     */
+    private addAlert;
+    /**
+     * Get current statistics
+     */
+    getStats(): {
+        uptime: number;
+        totalQueries: number;
+        slowQueries: number;
+        blockedQueries: number;
+        totalAlerts: number;
+        alertsBySeverity: Record<AlertSeverity, number>;
+        alertsByCategory: Record<AlertCategory, number>;
+    };
+    /**
+     * Get all alerts
+     */
+    getAlerts(options?: {
+        severity?: AlertSeverity;
+        category?: AlertCategory;
+        limit?: number;
+    }): SecurityAlert[];
+    /**
+     * Get critical alerts
+     */
+    getCriticalAlerts(): SecurityAlert[];
+    /**
+     * Clear all alerts
+     */
+    clearAlerts(): void;
+    /**
+     * Check if running
+     */
+    isActive(): boolean;
+    /**
+     * Manual alert trigger (for custom security checks)
+     */
+    alert(options: Omit<SecurityAlert, 'id' | 'timestamp'>): void;
+}
+/**
+ * Create or get the global security monitor singleton
+ */
+export declare function getGlobalMonitor(): SecurityMonitor | null;
+/**
+ * Initialize the global security monitor
+ */
+export declare function initSecurityMonitor(prorm: Prorm, options?: SecurityMonitorOptions): SecurityMonitor;
+/**
+ * Quick security check for a query (static method)
+ */
+export declare function analyzeQuerySecurity(query: string): {
+    isSQLInjection: boolean;
+    isSensitive: boolean;
+    riskLevel: 'low' | 'medium' | 'high' | 'critical';
+    detectedPatterns: string[];
+};
+/**
+ * MTAT with Compliance Integration
+ * Extends the basic monitor with framework-specific rules
+ */
+export declare class ComplianceSecurityMonitor extends SecurityMonitor {
+    constructor(prorm: Prorm, options?: SecurityMonitorOptions & {
+        modelsToProtect?: any[];
+    });
+}

package/dist/compliance/sensitive-data-discovery.d.ts

@@ -0,0 +1,151 @@
+/**
+ * SensitiveDataDiscovery
+ *
+ * Auto-scans models for sensitive data patterns (SSN, credit cards, health IDs, etc.)
+ * with support for custom patterns. Supports GDPR, HIPAA, PCI DSS, APPI compliance.
+ *
+ * Covers ~18 compliance frameworks including:
+ *   GDPR (Art 25/30/32/44), HIPAA, PCI DSS 3.x, APPI (Japan),
+ *   NIST SP 800-122, PIPL (China), LGPD (Brazil), CCPA/CPRA,
+ *   FIPS 199, ISO 29101, and data discovery requirements.
+ *
+ * Usage:
+ *   // Scan a model for sensitive fields:
+ *   const fields = SensitiveDataDiscovery.scan(User);
+ *   console.log(fields); // [{ field: 'ssn', type: 'SSN', confidence: 0.95 }, ...]
+ *
+ *   // Scan all models in a prorm instance:
+ *   const allFields = SensitiveDataDiscovery.scanAll(prorm);
+ *
+ *   // Get previously discovered fields:
+ *   const discovered = SensitiveDataDiscovery.getDiscoveredFields(User);
+ *
+ *   // Auto-protect: add encryption/masking hooks:
+ *   SensitiveDataDiscovery.autoProtect(User);
+ */
+/** Types of sensitive data that can be discovered */
+export type SensitiveDataType = 'SSN' | 'CREDIT_CARD' | 'EMAIL' | 'PHONE' | 'HEALTH_ID' | 'DRIVERS_LICENSE' | 'PASSPORT' | 'BANK_ACCOUNT' | 'IBAN' | 'DATE_OF_BIRTH' | 'IP_ADDRESS' | 'BIOMETRIC' | 'MEDICAL_RECORD' | 'PRESCRIPTION' | 'INSURANCE_ID' | 'NATIONAL_ID';
+/** Compliance framework reference */
+export type ComplianceFramework = 'GDPR' | 'HIPAA' | 'PCI_DSS' | 'APPI' | 'PIPL' | 'LGPD' | 'CCPA' | 'NIST' | 'ISO';
+/** Discovered sensitive field information */
+export interface SensitiveField {
+    /** The field name in the model */
+    field: string;
+    /** Type of sensitive data detected */
+    type: SensitiveDataType;
+    /** Confidence score (0-1) */
+    confidence: number;
+    /** Detection method used */
+    method: 'pattern' | 'column_name' | 'data_sample';
+    /** Matching regex or pattern */
+    pattern: RegExp;
+    /** Regulatory frameworks that apply */
+    frameworks: ComplianceFramework[];
+    /** Recommended protection method */
+    recommendation: 'encrypt' | 'mask' | 'tokenize' | 'redact';
+    /** Original matched value (for validation) */
+    sampleMatch?: string;
+}
+/** Custom discovery pattern definition */
+export interface DiscoveryPattern {
+    /** Unique identifier for the pattern */
+    id: string;
+    /** Human-readable name */
+    name: string;
+    /** Type of sensitive data */
+    type: SensitiveDataType;
+    /** Regex pattern to match */
+    pattern: RegExp;
+    /** Column name patterns to match */
+    columnNames?: RegExp[];
+    /** Frameworks that this pattern satisfies */
+    frameworks: ComplianceFramework[];
+    /** Recommended protection */
+    recommendation: 'encrypt' | 'mask' | 'tokenize' | 'redact';
+    /** Priority (higher = checked first) */
+    priority?: number;
+}
+/** Options for scanning */
+export interface ScanOptions {
+    /** Minimum confidence threshold (0-1). Default: 0.7 */
+    minConfidence?: number;
+    /** Whether to analyze data samples (may be slow). Default: false */
+    analyzeSamples?: boolean;
+    /** Maximum rows to sample for analysis. Default: 100 */
+    sampleSize?: number;
+    /** Custom patterns to add */
+    customPatterns?: DiscoveryPattern[];
+    /** Frameworks to prioritize */
+    targetFrameworks?: ComplianceFramework[];
+    /** Whether to include column name matching. Default: true */
+    matchByName?: boolean;
+    /** Whether to include pattern matching. Default: true */
+    matchByPattern?: boolean;
+}
+/** Result of scanning a model */
+export interface ScanResult {
+    /** The model that was scanned */
+    model: any;
+    /** Model name */
+    modelName: string;
+    /** Discovered sensitive fields */
+    fields: SensitiveField[];
+    /** Timestamp of scan */
+    scannedAt: Date;
+    /** Frameworks that apply to this model */
+    applicableFrameworks: ComplianceFramework[];
+}
+/**
+ * Register a custom discovery pattern.
+ */
+export declare function registerPattern(pattern: DiscoveryPattern): void;
+/**
+ * Remove a custom discovery pattern.
+ */
+export declare function unregisterPattern(patternId: string): boolean;
+/**
+ * Get all registered patterns.
+ */
+export declare function getPatterns(): DiscoveryPattern[];
+/**
+ * Scan a single model for sensitive fields.
+ */
+export declare function scanModel(Model: any, options?: ScanOptions): SensitiveField[];
+/**
+ * Scan all models in a Prorm instance.
+ */
+export declare function scanAllModels(prorm: any, options?: ScanOptions): ScanResult[];
+/**
+ * Get previously discovered fields for a model.
+ */
+export declare function getDiscoveredFieldsForModel(Model: any): SensitiveField[] | undefined;
+/**
+ * Get scan result for a specific model.
+ */
+export declare function getScanResult(prorm: any, modelName: string): ScanResult | undefined;
+/**
+ * Auto-protect a model by adding encryption/masking hooks.
+ */
+export declare function autoProtectModel(Model: any, options?: ScanOptions): void;
+/**
+ * Generate a compliance report for discovered fields.
+ */
+export declare function generateComplianceReport(prorm: any, options?: ScanOptions): {
+    summary: {
+        totalModels: number;
+        totalSensitiveFields: number;
+        byFramework: Record<ComplianceFramework, number>;
+        byType: Record<SensitiveDataType, number>;
+    };
+    models: ScanResult[];
+};
+export declare class SensitiveDataDiscovery {
+    static scan: typeof scanModel;
+    static scanAll: typeof scanAllModels;
+    static getDiscoveredFields: typeof getDiscoveredFieldsForModel;
+    static autoProtect: typeof autoProtectModel;
+    static registerPattern: typeof registerPattern;
+    static unregisterPattern: typeof unregisterPattern;
+    static getPatterns: typeof getPatterns;
+    static generateComplianceReport: typeof generateComplianceReport;
+}