/**
 * Data Sanitization Utility
 *
 * Centralized sanitization of sensitive data across all output paths.
 * Handles API keys, tokens, passwords, and other sensitive information.
 *
 * Security Features:
 * - Recursive object/array sanitization
 * - Multiple sensitive data patterns
 * - Configurable sanitization rules
 * - Type-safe implementation
 */
export interface SanitizationOptions {
    maskChar?: string;
    maskLength?: number;
    rules?: SanitizationRule[];
}
export interface SanitizationRule {
    description: string;
    pattern: RegExp;
    replacement: string;
}
/**
 * Data Sanitization Utility Class
 *
 * Provides comprehensive sanitization of sensitive data in:
 * - Objects and nested structures
 * - Strings and text content
 * - Arrays and collections
 * - JSON-serializable data
 */
export declare class DataSanitizer {
    private maskChar;
    private maskLength;
    private rules;
    private visitedObjects;
    constructor(options?: SanitizationOptions);
    /**
     * Sanitize any data structure recursively
     */
    sanitize<T>(data: T): T;
    /**
     * Sanitize a string value
     */
    private sanitizeString;
    /**
     * Sanitize an object recursively
     */
    private sanitizeObject;
    /**
     * Check if a field name indicates sensitive data
     */
    private isSensitiveField;
    /**
     * Check if a string contains sensitive data patterns
     */
    private containsSensitiveData;
    /**
     * Create a mask string for sensitive values
     */
    private createMask;
    /**
     * Add custom sanitization rules
     */
    addRule(rule: SanitizationRule): void;
    /**
     * Remove a sanitization rule by description
     */
    removeRule(description: string): void;
    /**
     * Get current sanitization rules
     */
    getRules(): readonly SanitizationRule[];
    /**
     * Clear all custom rules (keep defaults)
     */
    clearCustomRules(): void;
    /**
     * Sanitize a string for use in log entries
     *
     * Removes all control characters including newlines and carriage returns
     * to prevent log injection attacks that could forge log entries
     */
    sanitizeForLog(value: string): string;
}
/**
 * Get the global data sanitizer instance
 */
export declare function getDataSanitizer(options?: SanitizationOptions): DataSanitizer;
/**
 * Set a custom global sanitizer instance
 */
export declare function setDataSanitizer(sanitizer: DataSanitizer): void;
/**
 * Sanitize data using the global sanitizer
 */
export declare function sanitizeData<T>(data: T): T;
/**
 * Convenience function to sanitize objects for logging
 */
export declare function sanitizeForLogging(data: Record<string, unknown>): Record<string, unknown>;
/**
 * Convenience function to sanitize strings
 */
export declare function sanitizeString(value: string): string;
//# sourceMappingURL=data-sanitizer.d.ts.map