openredaction 1.0.8 → 1.0.10

package/dist/react.d.ts

@@ -0,0 +1,1124 @@
+import * as react0 from "react";
+
+//#region src/types.d.ts
+/**
+ * Core types for PII Shield
+ */
+/**
+ * PII pattern definition with validation
+ */
+interface PIIPattern {
+  /** Pattern type identifier (e.g., "EMAIL", "PHONE_UK_MOBILE") */
+  type: string;
+  /** Regular expression for matching */
+  regex: RegExp;
+  /** Priority for detection order (higher = checked first) */
+  priority: number;
+  /** Optional validator function for false positive reduction */
+  validator?: (match: string, context: string) => boolean;
+  /** Placeholder template (e.g., "[EMAIL_{n}]") */
+  placeholder: string;
+  /** Optional description */
+  description?: string;
+  /** Severity level */
+  severity?: 'critical' | 'high' | 'medium' | 'low';
+}
+/**
+ * Detected PII instance
+ */
+interface PIIDetection {
+  /** Type of PII detected */
+  type: string;
+  /** Original detected value */
+  value: string;
+  /** Placeholder used for redaction */
+  placeholder: string;
+  /** Position in text [start, end] */
+  position: [number, number];
+  /** Severity level */
+  severity: 'critical' | 'high' | 'medium' | 'low';
+  /** Confidence score (0-1) based on context analysis */
+  confidence?: number;
+}
+/**
+ * Detection result
+ */
+interface DetectionResult {
+  /** Original text */
+  original: string;
+  /** Redacted text */
+  redacted: string;
+  /** Array of detections */
+  detections: PIIDetection[];
+  /** Map of placeholders to original values for restoration */
+  redactionMap: Record<string, string>;
+  /** Statistics */
+  stats?: {
+    /** Processing time in milliseconds */processingTime?: number; /** Total PII count */
+    piiCount: number;
+  };
+}
+/**
+ * Redaction mode - controls how PII is replaced
+ */
+type RedactionMode = 'placeholder' | 'mask-middle' | 'mask-all' | 'format-preserving' | 'token-replace';
+/**
+ * Configuration options for OpenRedaction
+ */
+type PresetName = 'gdpr' | 'hipaa' | 'ccpa' | 'healthcare' | 'healthcare-provider' | 'healthcare-research' | 'finance' | 'financial-services' | 'education' | 'transport-logistics' | 'transportation' | 'logistics';
+interface OpenRedactionOptions {
+  /** Include name detection (default: true) */
+  includeNames?: boolean;
+  /** Include address detection (default: true) */
+  includeAddresses?: boolean;
+  /** Include phone detection (default: true) */
+  includePhones?: boolean;
+  /** Include email detection (default: true) */
+  includeEmails?: boolean;
+  /** Pattern categories to include (e.g., ['personal', 'financial']) */
+  categories?: string[];
+  /** Whitelist specific patterns only */
+  patterns?: string[];
+  /** Add custom patterns */
+  customPatterns?: PIIPattern[];
+  /** Whitelist of terms to ignore (e.g., company names) */
+  whitelist?: string[];
+  /** Enable deterministic placeholders (default: true) */
+  deterministic?: boolean;
+  /** Redaction mode (default: 'placeholder') */
+  redactionMode?: RedactionMode;
+  /** Compliance preset */
+  preset?: PresetName;
+  /** Enable context-aware detection (default: true) */
+  enableContextAnalysis?: boolean;
+  /** Minimum confidence threshold for detections (0-1, default: 0.5) */
+  confidenceThreshold?: number;
+  /** Enable false positive filtering (default: false, experimental) */
+  enableFalsePositiveFilter?: boolean;
+  /** False positive confidence threshold (0-1, default: 0.7) */
+  falsePositiveThreshold?: number;
+  /** Enable multi-pass detection for better accuracy (default: false, experimental) */
+  enableMultiPass?: boolean;
+  /** Number of detection passes (2-5, default: 3) */
+  multiPassCount?: number;
+  /** Enable result caching for repeated inputs (default: false) */
+  enableCache?: boolean;
+  /** Maximum cache size (default: 100) */
+  cacheSize?: number;
+  /** Enable debug logging (default: false) */
+  debug?: boolean;
+  /** Enable audit logging (default: false) */
+  enableAuditLog?: boolean;
+  /** Audit logger instance (optional, default: in-memory logger) */
+  auditLogger?: IAuditLogger;
+  /** User context for audit logs */
+  auditUser?: string;
+  /** Session ID for audit logs */
+  auditSessionId?: string;
+  /** Additional metadata for audit logs */
+  auditMetadata?: Record<string, unknown>;
+  /** Enable metrics collection (default: false) */
+  enableMetrics?: boolean;
+  /** Metrics collector instance (optional, default: in-memory collector) */
+  metricsCollector?: IMetricsCollector;
+  /** Enable RBAC (Role-Based Access Control) (default: false) */
+  enableRBAC?: boolean;
+  /** RBAC manager instance (optional, default: admin role) */
+  rbacManager?: IRBACManager;
+  /** Predefined role name (admin, analyst, operator, viewer) */
+  role?: RoleName;
+  /** Optional AI assist configuration */
+  ai?: AIOptions;
+}
+/**
+ * AI assist configuration options
+ */
+interface AIOptions {
+  /** Enable AI assist mode (default: false) */
+  enabled?: boolean;
+  /** AI endpoint URL (defaults to OPENREDACTION_AI_ENDPOINT env var if available) */
+  endpoint?: string;
+}
+/**
+ * Audit log entry for tracking redaction operations
+ */
+interface AuditLogEntry {
+  /** Unique identifier for this audit entry */
+  id: string;
+  /** Timestamp of the operation (ISO 8601) */
+  timestamp: string;
+  /** Operation type */
+  operation: 'redact' | 'detect' | 'restore';
+  /** Number of PII items found/processed */
+  piiCount: number;
+  /** Types of PII detected (e.g., ["EMAIL", "SSN", "PHONE"]) */
+  piiTypes: string[];
+  /** Text length processed */
+  textLength: number;
+  /** Processing time in milliseconds */
+  processingTimeMs: number;
+  /** Redaction mode used */
+  redactionMode?: RedactionMode;
+  /** Success status */
+  success: boolean;
+  /** Error message if operation failed */
+  error?: string;
+  /** Optional user context */
+  user?: string;
+  /** Optional session/request identifier */
+  sessionId?: string;
+  /** Optional metadata */
+  metadata?: Record<string, unknown>;
+}
+/**
+ * Audit logger interface
+ */
+interface IAuditLogger {
+  /** Log an audit entry */
+  log(entry: Omit<AuditLogEntry, 'id' | 'timestamp'>): void;
+  /** Get all audit logs */
+  getLogs(): AuditLogEntry[];
+  /** Get audit logs filtered by operation type */
+  getLogsByOperation(operation: AuditLogEntry['operation']): AuditLogEntry[];
+  /** Get audit logs filtered by date range */
+  getLogsByDateRange(startDate: Date, endDate: Date): AuditLogEntry[];
+  /** Export audit logs as JSON */
+  exportAsJson(): string;
+  /** Export audit logs as CSV */
+  exportAsCsv(): string;
+  /** Clear all audit logs */
+  clear(): void;
+  /** Get audit statistics */
+  getStats(): AuditStats;
+}
+/**
+ * Audit statistics
+ */
+interface AuditStats {
+  /** Total number of operations */
+  totalOperations: number;
+  /** Total PII items detected */
+  totalPiiDetected: number;
+  /** Average processing time in milliseconds */
+  averageProcessingTime: number;
+  /** Most common PII types */
+  topPiiTypes: Array<{
+    type: string;
+    count: number;
+  }>;
+  /** Operations by type */
+  operationsByType: Record<string, number>;
+  /** Success rate (0-1) */
+  successRate: number;
+}
+/**
+ * Metrics for monitoring redaction operations
+ */
+interface RedactionMetrics {
+  /** Total number of redaction operations */
+  totalRedactions: number;
+  /** Total number of PII items detected */
+  totalPiiDetected: number;
+  /** Total processing time in milliseconds */
+  totalProcessingTime: number;
+  /** Average processing time in milliseconds */
+  averageProcessingTime: number;
+  /** Total text length processed (characters) */
+  totalTextLength: number;
+  /** PII detection counts by type */
+  piiByType: Record<string, number>;
+  /** Operation counts by redaction mode */
+  byRedactionMode: Record<string, number>;
+  /** Error count */
+  totalErrors: number;
+  /** Timestamp of last update */
+  lastUpdated: string;
+}
+/**
+ * Metrics exporter interface
+ */
+interface IMetricsExporter {
+  /** Export metrics in Prometheus format */
+  exportPrometheus(metrics: RedactionMetrics, prefix?: string): string;
+  /** Export metrics in StatsD format */
+  exportStatsD(metrics: RedactionMetrics, prefix?: string): string[];
+  /** Get current metrics snapshot */
+  getMetrics(): RedactionMetrics;
+  /** Reset all metrics */
+  reset(): void;
+}
+/**
+ * Metrics collector interface
+ */
+interface IMetricsCollector {
+  /** Record a redaction operation */
+  recordRedaction(result: DetectionResult, processingTimeMs: number, redactionMode: RedactionMode): void;
+  /** Record an error */
+  recordError(): void;
+  /** Get metrics exporter */
+  getExporter(): IMetricsExporter;
+}
+/**
+ * RBAC Permission - granular access control
+ */
+type Permission = 'pattern:read' | 'pattern:write' | 'pattern:delete' | 'detection:detect' | 'detection:redact' | 'detection:restore' | 'audit:read' | 'audit:export' | 'audit:delete' | 'metrics:read' | 'metrics:export' | 'metrics:reset' | 'config:read' | 'config:write';
+/**
+ * RBAC Role - collection of permissions
+ */
+interface Role {
+  /** Role identifier */
+  name: string;
+  /** Role description */
+  description?: string;
+  /** Permissions granted to this role */
+  permissions: Permission[];
+}
+/**
+ * Predefined role names
+ */
+type RoleName = 'admin' | 'analyst' | 'operator' | 'viewer' | 'custom';
+/**
+ * RBAC manager interface for access control
+ */
+interface IRBACManager {
+  /** Check if user has specific permission */
+  hasPermission(permission: Permission): boolean;
+  /** Check if user has all specified permissions */
+  hasAllPermissions(permissions: Permission[]): boolean;
+  /** Check if user has any of the specified permissions */
+  hasAnyPermission(permissions: Permission[]): boolean;
+  /** Get current role */
+  getRole(): Role;
+  /** Set role */
+  setRole(role: Role): void;
+  /** Get all permissions for current role */
+  getPermissions(): Permission[];
+  /** Filter patterns based on read permissions */
+  filterPatterns(patterns: PIIPattern[]): PIIPattern[];
+}
+//#endregion
+//#region src/learning/LocalLearningStore.d.ts
+interface WhitelistEntry {
+  pattern: string;
+  confidence: number;
+  occurrences: number;
+  firstSeen: number;
+  lastSeen: number;
+  contexts: string[];
+}
+interface PatternAdjustment {
+  type: string;
+  issue: string;
+  suggestion: string;
+  confidence: number;
+  examples: string[];
+  occurrences: number;
+}
+interface LearningStats {
+  totalDetections: number;
+  falsePositives: number;
+  falseNegatives: number;
+  accuracy: number;
+  lastUpdated: number;
+}
+interface LearningData {
+  version: string;
+  whitelist: WhitelistEntry[];
+  patternAdjustments: PatternAdjustment[];
+  stats: LearningStats;
+}
+declare class LocalLearningStore {
+  private filePath;
+  private data;
+  private autoSave;
+  private confidenceThreshold;
+  constructor(filePath?: string, options?: {
+    autoSave?: boolean;
+    confidenceThreshold?: number;
+  });
+  /**
+   * Load learning data from file
+   */
+  private load;
+  /**
+   * Save learning data to file
+   */
+  private save;
+  /**
+   * Record a false positive detection
+   */
+  recordFalsePositive(text: string, _type: string, context: string): void;
+  /**
+   * Record a false negative (missed detection)
+   */
+  recordFalseNegative(text: string, type: string, _context: string): void;
+  /**
+   * Record a correct detection
+   */
+  recordCorrectDetection(): void;
+  /**
+   * Update accuracy calculation
+   */
+  private updateAccuracy;
+  /**
+   * Get whitelist entries above confidence threshold
+   */
+  getWhitelist(): string[];
+  /**
+   * Get all whitelist entries with metadata
+   */
+  getWhitelistEntries(): WhitelistEntry[];
+  /**
+   * Get pattern adjustments above confidence threshold
+   */
+  getPatternAdjustments(): PatternAdjustment[];
+  /**
+   * Get all pattern adjustments
+   */
+  getAllPatternAdjustments(): PatternAdjustment[];
+  /**
+   * Get learning statistics
+   */
+  getStats(): LearningStats;
+  /**
+   * Get confidence score for a specific pattern
+   */
+  getConfidence(pattern: string): number;
+  /**
+   * Get occurrences count for a specific pattern
+   */
+  getOccurrences(pattern: string): number;
+  /**
+   * Manually add pattern to whitelist
+   */
+  addToWhitelist(pattern: string, confidence?: number): void;
+  /**
+   * Remove pattern from whitelist
+   */
+  removeFromWhitelist(pattern: string): void;
+  /**
+   * Clear all learning data
+   */
+  clear(): void;
+  /**
+   * Export learning data (for sharing)
+   */
+  export(options?: {
+    includeContexts?: boolean;
+    minConfidence?: number;
+  }): LearningData;
+  /**
+   * Import learning data (merge with existing)
+   */
+  import(data: LearningData, merge?: boolean): void;
+  /**
+   * Manually save data
+   */
+  flush(): void;
+}
+//#endregion
+//#region src/optimizer/PriorityOptimizer.d.ts
+interface PatternStats {
+  type: string;
+  totalDetections: number;
+  falsePositives: number;
+  falseNegatives: number;
+  accuracy: number;
+  priority: number;
+  adjustedPriority: number;
+}
+interface OptimizerOptions {
+  learningWeight: number;
+  minSampleSize: number;
+  maxPriorityAdjustment: number;
+}
+/**
+ * Priority Optimizer - Dynamically adjusts pattern priorities based on learning data
+ */
+declare class PriorityOptimizer {
+  private learningStore;
+  private options;
+  constructor(learningStore: LocalLearningStore, options?: Partial<OptimizerOptions>);
+  /**
+   * Optimize pattern priorities based on learning data
+   */
+  optimizePatterns(patterns: PIIPattern[]): PIIPattern[];
+  /**
+   * Get pattern statistics with learning data
+   */
+  getPatternStats(patterns: PIIPattern[]): PatternStats[];
+  /**
+   * Infer pattern type from a whitelisted value
+   * This is a heuristic - in production we'd track this explicitly
+   */
+  private inferPatternType;
+  /**
+   * Reset all priority adjustments
+   */
+  resetPriorities(patterns: PIIPattern[]): PIIPattern[];
+  /**
+   * Get optimizer configuration
+   */
+  getOptions(): OptimizerOptions;
+  /**
+   * Update optimizer configuration
+   */
+  setOptions(options: Partial<OptimizerOptions>): void;
+}
+//#endregion
+//#region src/document/types.d.ts
+/**
+ * Supported document formats
+ */
+type DocumentFormat = 'pdf' | 'docx' | 'txt' | 'image' | 'json' | 'csv' | 'xlsx';
+/**
+ * OCR language codes (Tesseract format)
+ */
+type OCRLanguage = 'eng' | 'spa' | 'fra' | 'deu' | 'por' | 'ita' | 'rus' | 'chi_sim' | 'chi_tra' | 'jpn' | 'kor';
+/**
+ * OCR options
+ */
+interface OCROptions {
+  /** OCR language (default: 'eng' for English) */
+  language?: OCRLanguage | OCRLanguage[];
+  /** OCR engine mode (0-3, default: 3 for best accuracy) */
+  oem?: 0 | 1 | 2 | 3;
+  /** Page segmentation mode (0-13, default: 3 for automatic) */
+  psm?: number;
+}
+/**
+ * Document processing options
+ */
+interface DocumentOptions {
+  /** Document format (auto-detected if not specified) */
+  format?: DocumentFormat;
+  /** Extract text from specific pages (PDF only, 1-indexed) */
+  pages?: number[];
+  /** Password for encrypted PDFs */
+  password?: string;
+  /** Maximum document size in bytes (default: 50MB) */
+  maxSize?: number;
+  /** Enable OCR for image-based content (default: false) */
+  enableOCR?: boolean;
+  /** OCR configuration options */
+  ocrOptions?: OCROptions;
+}
+/**
+ * Document processing result
+ */
+interface DocumentResult {
+  /** Extracted text from document */
+  text: string;
+  /** Document metadata */
+  metadata: DocumentMetadata;
+  /** Detection result with PII findings */
+  detection: DetectionResult;
+  /** Original file size in bytes */
+  fileSize: number;
+  /** Text extraction time in milliseconds */
+  extractionTime: number;
+}
+/**
+ * Document metadata
+ */
+interface DocumentMetadata {
+  /** Document format */
+  format: DocumentFormat;
+  /** Number of pages (if applicable) */
+  pages?: number;
+  /** Document title */
+  title?: string;
+  /** Document author */
+  author?: string;
+  /** Creation date */
+  creationDate?: Date;
+  /** Last modified date */
+  modifiedDate?: Date;
+  /** OCR confidence (0-100) if OCR was used */
+  ocrConfidence?: number;
+  /** Whether OCR was used for extraction */
+  usedOCR?: boolean;
+  /** Additional custom metadata */
+  custom?: Record<string, unknown>;
+}
+//#endregion
+//#region src/context/ContextRules.d.ts
+/**
+ * Proximity rule for context-based confidence adjustment
+ */
+interface ProximityRule {
+  /** Pattern type this rule applies to (e.g., 'EMAIL', 'PHONE', 'SSN') */
+  patternType: string | string[];
+  /** Keywords to look for near the match */
+  keywords: string[];
+  /** Maximum word distance from match (default: 10) */
+  proximityWindow?: number;
+  /** Confidence boost if keyword found (0-1) */
+  confidenceBoost?: number;
+  /** Confidence penalty if keyword found (0-1) */
+  confidencePenalty?: number;
+  /** Whether match must come AFTER keyword (default: both directions) */
+  keywordBefore?: boolean;
+  /** Whether match must come BEFORE keyword (default: both directions) */
+  keywordAfter?: boolean;
+  /** Rule description */
+  description?: string;
+}
+/**
+ * Domain-specific vocabulary for context detection
+ */
+interface DomainVocabulary {
+  /** Domain name */
+  domain: 'medical' | 'legal' | 'financial' | 'technical' | 'hr' | 'custom';
+  /** Domain-specific terms */
+  terms: string[];
+  /** Pattern types to boost in this domain */
+  boostPatterns?: string[];
+  /** Confidence boost amount (default: 0.15) */
+  boostAmount?: number;
+}
+/**
+ * Contextual rules configuration
+ */
+interface ContextRulesConfig {
+  /** Proximity rules */
+  proximityRules?: ProximityRule[];
+  /** Domain vocabularies */
+  domainVocabularies?: DomainVocabulary[];
+  /** Enable default rules (default: true) */
+  useDefaultRules?: boolean;
+}
+//#endregion
+//#region src/context/ContextAnalyzer.d.ts
+/**
+ * Context Analysis for PII Detection
+ * Provides NLP-lite features to reduce false positives
+ */
+interface ContextAnalysis {
+  /** 5 words before detection */
+  beforeWords: string[];
+  /** 5 words after detection */
+  afterWords: string[];
+  /** Full sentence containing detection */
+  sentence: string;
+  /** Inferred document type */
+  documentType: 'email' | 'document' | 'code' | 'chat' | 'unknown';
+  /** Confidence that this is actual PII (0-1) */
+  confidence: number;
+}
+//#endregion
+//#region src/explain/ExplainAPI.d.ts
+/**
+ * Pattern match result for explain
+ */
+interface PatternMatchResult {
+  /** Pattern that was tested */
+  pattern: PIIPattern;
+  /** Whether the pattern matched */
+  matched: boolean;
+  /** Matched value (if matched) */
+  matchedValue?: string;
+  /** Position of match (if matched) */
+  position?: [number, number];
+  /** Why it didn't match or was filtered */
+  reason?: string;
+  /** Validator result (if validator exists) */
+  validatorPassed?: boolean;
+  /** Context analysis (if enabled) */
+  contextAnalysis?: ContextAnalysis;
+  /** False positive check (if enabled) */
+  falsePositiveCheck?: {
+    isFalsePositive: boolean;
+    confidence: number;
+    reason?: string;
+  };
+}
+/**
+ * Explanation for a specific text
+ */
+interface TextExplanation {
+  /** Original text */
+  text: string;
+  /** All pattern match results */
+  patternResults: PatternMatchResult[];
+  /** Patterns that matched */
+  matchedPatterns: PatternMatchResult[];
+  /** Patterns that didn't match */
+  unmatchedPatterns: PatternMatchResult[];
+  /** Patterns that matched but were filtered */
+  filteredPatterns: PatternMatchResult[];
+  /** Final detections */
+  detections: PIIDetection[];
+  /** Summary statistics */
+  summary: {
+    totalPatternsChecked: number;
+    patternsMatched: number;
+    patternsFiltered: number;
+    finalDetections: number;
+  };
+}
+/**
+ * Explain API for debugging
+ */
+declare class ExplainAPI {
+  private detector;
+  private patterns;
+  private options;
+  constructor(detector: OpenRedaction);
+  /**
+   * Explain why text was or wasn't detected as PII
+   */
+  explain(text: string): Promise<TextExplanation>;
+  /**
+   * Explain a specific detection
+   */
+  explainDetection(detection: PIIDetection, text: string): Promise<{
+    detection: PIIDetection;
+    pattern?: PIIPattern;
+    contextAnalysis?: ContextAnalysis;
+    reasoning: string[];
+    suggestions: string[];
+  }>;
+  /**
+   * Suggest why text wasn't detected
+   */
+  suggestWhy(text: string, expectedType: string): Promise<{
+    text: string;
+    expectedType: string;
+    suggestions: string[];
+    similarPatterns: PIIPattern[];
+  }>;
+  /**
+   * Get debugging information for entire detection process
+   */
+  debug(text: string): Promise<{
+    text: string;
+    textLength: number;
+    enabledFeatures: string[];
+    patternCount: number;
+    explanation: TextExplanation;
+    performance: {
+      estimatedTime: string;
+    };
+  }>;
+}
+//#endregion
+//#region src/reports/ReportGenerator.d.ts
+/**
+ * Report format options
+ */
+type ReportFormat = 'html' | 'markdown';
+/**
+ * Report type options
+ */
+type ReportType = 'summary' | 'detailed' | 'compliance';
+/**
+ * Report generation options
+ */
+interface ReportOptions {
+  /** Report format */
+  format: ReportFormat;
+  /** Report type */
+  type?: ReportType;
+  /** Report title */
+  title?: string;
+  /** Include original text (default: false for privacy) */
+  includeOriginalText?: boolean;
+  /** Include redacted text (default: true) */
+  includeRedactedText?: boolean;
+  /** Include detection details (default: true) */
+  includeDetectionDetails?: boolean;
+  /** Include statistics (default: true) */
+  includeStatistics?: boolean;
+  /** Include explanation (requires ExplainAPI, default: false) */
+  includeExplanation?: boolean;
+  /** Company/project name for compliance reports */
+  organizationName?: string;
+  /** Additional metadata */
+  metadata?: Record<string, string>;
+}
+//#endregion
+//#region src/detector.d.ts
+declare class OpenRedaction {
+  private patterns;
+  private compiledPatterns;
+  private options;
+  private multiPassConfig?;
+  private resultCache?;
+  private valueToPlaceholder;
+  private placeholderCounter;
+  private learningStore?;
+  private priorityOptimizer?;
+  private enableLearning;
+  private auditLogger?;
+  private auditUser?;
+  private auditSessionId?;
+  private auditMetadata?;
+  private metricsCollector?;
+  private rbacManager?;
+  private nerDetector?;
+  private contextRulesEngine?;
+  private severityClassifier;
+  constructor(options?: OpenRedactionOptions & {
+    configPath?: string;
+    enableLearning?: boolean;
+    learningStorePath?: string;
+    enablePriorityOptimization?: boolean;
+    optimizerOptions?: Partial<OptimizerOptions>;
+    enableNER?: boolean;
+    enableContextRules?: boolean;
+    contextRulesConfig?: ContextRulesConfig;
+    maxInputSize?: number;
+    regexTimeout?: number;
+  });
+  /**
+   * Create OpenRedaction instance from config file
+   */
+  static fromConfig(configPath?: string): Promise<OpenRedaction>;
+  /**
+   * Build the list of patterns based on options
+   * Supports three filtering modes (in order of priority):
+   * 1. Specific pattern types (patterns option)
+   * 2. Pattern categories (categories option) - NEW!
+   * 3. All patterns with type-specific filters (includeNames, etc.)
+   */
+  private buildPatternList;
+  /**
+   * Validate all patterns to prevent malicious regex injection
+   * ONLY validates custom patterns - built-in patterns are already vetted
+   * Timeout protection in safeExec() is the primary defense against ReDoS
+   */
+  private validatePatterns;
+  /**
+   * Pre-compile all regex patterns for performance
+   * Avoids creating new RegExp objects on every detect() call
+   */
+  private precompilePatterns;
+  /**
+   * Process patterns and detect PII
+   * Used by both single-pass and multi-pass detection
+   */
+  private processPatterns;
+  /**
+   * Detect PII in text
+   * Now async to support optional AI assist
+   */
+  detect(text: string): Promise<DetectionResult>;
+  /**
+   * Restore redacted text using redaction map
+   */
+  restore(redactedText: string, redactionMap: Record<string, string>): string;
+  /**
+   * Generate placeholder for a detected value
+   */
+  private generatePlaceholder;
+  /**
+   * Check if a range overlaps with existing detections
+   */
+  private overlapsWithExisting;
+  /**
+   * Escape special regex characters
+   */
+  private escapeRegex;
+  /**
+   * Get the list of active patterns
+   */
+  getPatterns(): PIIPattern[];
+  /**
+   * Get severity-based scan results
+   */
+  scan(text: string): Promise<{
+    high: PIIDetection[];
+    medium: PIIDetection[];
+    low: PIIDetection[];
+    total: number;
+  }>;
+  /**
+   * Record a false positive (incorrectly detected as PII)
+   */
+  recordFalsePositive(detection: PIIDetection, context?: string): void;
+  /**
+   * Record a false negative (missed PII that should have been detected)
+   */
+  recordFalseNegative(text: string, expectedType: string, context?: string): void;
+  /**
+   * Record a correct detection (for accuracy tracking)
+   */
+  recordCorrectDetection(): void;
+  /**
+   * Get learning statistics
+   */
+  getLearningStats(): LearningStats | null;
+  /**
+   * Get learned whitelist entries
+   */
+  getLearnedWhitelist(): WhitelistEntry[];
+  /**
+   * Get pattern adjustment suggestions
+   */
+  getPatternAdjustments(): PatternAdjustment[];
+  /**
+   * Export learned patterns for sharing
+   */
+  exportLearnings(options?: {
+    includeContexts?: boolean;
+    minConfidence?: number;
+  }): LearningData | null;
+  /**
+   * Import learned patterns from another source
+   */
+  importLearnings(data: any, merge?: boolean): void;
+  /**
+   * Manually add a term to the whitelist
+   */
+  addToWhitelist(pattern: string, confidence?: number): void;
+  /**
+   * Remove a term from the whitelist
+   */
+  removeFromWhitelist(pattern: string): void;
+  /**
+   * Get the learning store instance
+   */
+  getLearningStore(): LocalLearningStore | undefined;
+  /**
+   * Get the priority optimizer instance
+   */
+  getPriorityOptimizer(): PriorityOptimizer | undefined;
+  /**
+   * Optimize pattern priorities based on learning data
+   * Call this to re-optimize priorities after accumulating new learning data
+   */
+  optimizePriorities(): void;
+  /**
+   * Get pattern statistics with learning data
+   */
+  getPatternStats(): PatternStats[] | null;
+  /**
+   * Clear the result cache (if caching is enabled)
+   */
+  clearCache(): void;
+  /**
+   * Get cache statistics
+   */
+  getCacheStats(): {
+    size: number;
+    maxSize: number;
+    enabled: boolean;
+  };
+  /**
+   * Get the audit logger instance (if audit logging is enabled)
+   */
+  getAuditLogger(): IAuditLogger | undefined;
+  /**
+   * Get the metrics collector instance (if metrics collection is enabled)
+   */
+  getMetricsCollector(): IMetricsCollector | undefined;
+  /**
+   * Get the RBAC manager instance (if RBAC is enabled)
+   */
+  getRBACManager(): IRBACManager | undefined;
+  /**
+   * Create an explain API for debugging detections
+   */
+  explain(): ExplainAPI;
+  /**
+   * Generate a report from detection results
+   */
+  generateReport(result: DetectionResult, options: ReportOptions): string;
+  /**
+   * Export current configuration
+   */
+  exportConfig(metadata?: {
+    description?: string;
+    author?: string;
+    tags?: string[];
+  }): string;
+  /**
+   * Run health check
+   */
+  healthCheck(options?: {
+    testDetection?: boolean;
+    checkPerformance?: boolean;
+    performanceThreshold?: number;
+    memoryThreshold?: number;
+  }): Promise<any>;
+  /**
+   * Quick health check (minimal overhead)
+   */
+  quickHealthCheck(): Promise<{
+    status: 'healthy' | 'unhealthy';
+    message: string;
+  }>;
+  /**
+   * Detect PII in a document (PDF, DOCX, TXT)
+   * Requires optional peer dependencies:
+   * - pdf-parse for PDF support
+   * - mammoth for DOCX support
+   */
+  detectDocument(buffer: Buffer, options?: DocumentOptions): Promise<DocumentResult>;
+  /**
+   * Detect PII in a document file from filesystem
+   * Convenience method that reads file and calls detectDocument
+   */
+  detectDocumentFile(filePath: string, options?: DocumentOptions): Promise<DocumentResult>;
+  /**
+   * Batch detect PII in multiple texts using worker threads (parallel)
+   * Significantly faster for processing many texts
+   */
+  static detectBatch(texts: string[], options?: OpenRedactionOptions & {
+    numWorkers?: number;
+  }): Promise<DetectionResult[]>;
+  /**
+   * Batch process multiple documents using worker threads (parallel)
+   * Efficient for processing many documents at once
+   */
+  static detectDocumentsBatch(buffers: Buffer[], options?: DocumentOptions & {
+    numWorkers?: number;
+  }): Promise<DocumentResult[]>;
+}
+//#endregion
+//#region src/integrations/react.d.ts
+/**
+ * Hook for PII detection in React components
+ *
+ * @example
+ * ```tsx
+ * function MyForm() {
+ *   const { detect, result, isDetecting } = useOpenRedaction();
+ *
+ *   const handleSubmit = (text: string) => {
+ *     const detection = detect(text);
+ *     if (detection.detections.length > 0) {
+ *       alert('PII detected!');
+ *     }
+ *   };
+ * }
+ * ```
+ */
+declare function useOpenRedaction(options?: OpenRedactionOptions): {
+  detect: (text: string) => Promise<DetectionResult>;
+  result: DetectionResult | null;
+  isDetecting: boolean;
+  hasPII: boolean;
+  count: number;
+  clear: () => void;
+  detector: OpenRedaction;
+};
+/**
+ * Hook for real-time PII detection with debouncing
+ *
+ * @example
+ * ```tsx
+ * function EmailInput() {
+ *   const [email, setEmail] = useState('');
+ *   const { result, hasPII } = usePIIDetector(email, { debounce: 500 });
+ *
+ *   return (
+ *     <div>
+ *       <input value={email} onChange={e => setEmail(e.target.value)} />
+ *       {hasPII && <Warning>PII detected!</Warning>}
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function usePIIDetector(text: string, options?: OpenRedactionOptions & {
+  debounce?: number;
+}): {
+  result: DetectionResult | null;
+  isDetecting: boolean;
+  hasPII: boolean;
+  count: number;
+  detections: PIIDetection[];
+};
+/**
+ * Hook for form field PII validation
+ *
+ * @example
+ * ```tsx
+ * function UserForm() {
+ *   const emailValidation = useFormFieldValidator({
+ *     failOnPII: true,
+ *     types: ['EMAIL', 'PHONE']
+ *   });
+ *
+ *   return (
+ *     <input
+ *       {...emailValidation.getFieldProps()}
+ *       onChange={e => emailValidation.validate(e.target.value)}
+ *     />
+ *   );
+ * }
+ * ```
+ */
+declare function useFormFieldValidator(options?: OpenRedactionOptions & {
+  failOnPII?: boolean;
+  types?: string[];
+  onPIIDetected?: (result: DetectionResult) => void;
+}): {
+  value: string;
+  error: string | null;
+  result: DetectionResult | null;
+  validate: (inputValue: string) => Promise<boolean>;
+  getFieldProps: () => {
+    value: string;
+    'aria-invalid': string;
+    'aria-describedby': string | undefined;
+  };
+  isValid: boolean;
+  hasPII: boolean;
+};
+/**
+ * Hook for batch PII detection
+ *
+ * @example
+ * ```tsx
+ * function BatchProcessor() {
+ *   const { processAll, results, isProcessing } = useBatchDetector();
+ *
+ *   const handleProcess = async () => {
+ *     const documents = ['text1', 'text2', 'text3'];
+ *     await processAll(documents);
+ *   };
+ * }
+ * ```
+ */
+declare function useBatchDetector(options?: OpenRedactionOptions): {
+  processAll: (texts: string[]) => Promise<DetectionResult[]>;
+  results: DetectionResult[];
+  isProcessing: boolean;
+  progress: number;
+  totalDetections: number;
+  clear: () => void;
+};
+/**
+ * Hook for PII detection with auto-redaction
+ *
+ * @example
+ * ```tsx
+ * function SecureTextArea() {
+ *   const { text, setText, redactedText, hasPII } = useAutoRedact();
+ *
+ *   return (
+ *     <div>
+ *       <textarea value={text} onChange={e => setText(e.target.value)} />
+ *       {hasPII && <div>Redacted: {redactedText}</div>}
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function useAutoRedact(options?: OpenRedactionOptions & {
+  debounce?: number;
+}): {
+  text: string;
+  setText: react0.Dispatch<react0.SetStateAction<string>>;
+  result: DetectionResult | null;
+  redactedText: string;
+  hasPII: boolean;
+  detections: PIIDetection[];
+  count: number;
+};
+//#endregion
+export { useAutoRedact, useBatchDetector, useFormFieldValidator, useOpenRedaction, usePIIDetector };
+//# sourceMappingURL=react.d.ts.map