import { F as FilterConfig, C as CheckProfanityResult, S as SeverityLevel } from './types-BPmUdKPv.js';

/**
 * Core profanity filter class.
 * Provides comprehensive profanity detection with support for multiple languages,
 * leetspeak detection, Unicode normalization, and context-aware filtering.
 *
 * @example
 * ```typescript
 * const filter = new Filter({
 *   languages: ['english'],
 *   detectLeetspeak: true,
 *   normalizeUnicode: true,
 * });
 *
 * filter.isProfane('f4ck');  // Returns: true
 * filter.isProfane('fυck');  // Returns: true (Greek upsilon)
 * ```
 */
declare class Filter {
    private words;
    private caseSensitive;
    private wordBoundaries;
    private replaceWith?;
    private severityLevels;
    private ignoreWords;
    private logProfanity;
    private allowObfuscatedMatch;
    private fuzzyToleranceLevel;
    private enableContextAware;
    private contextWindow;
    private confidenceThreshold;
    private contextAnalyzer?;
    private primaryLanguage;
    private detectLeetspeak;
    private leetspeakLevel;
    private normalizeUnicodeEnabled;
    private cacheResults;
    private maxCacheSize;
    private cache;
    private matcher;
    private obfuscationOption;
    private whitelistWords;
    private scanner?;
    private legacyWhitelist?;
    /**
     * Creates a new Filter instance with the specified configuration.
     *
     * @param config - Filter configuration options
     *
     * @example
     * ```typescript
     * // Basic usage
     * const filter = new Filter({ languages: ['english'] });
     *
     * // With leetspeak detection
     * const filter = new Filter({
     *   languages: ['english'],
     *   detectLeetspeak: true,
     *   leetspeakLevel: 'moderate',
     * });
     *
     * // With all advanced features
     * const filter = new Filter({
     *   languages: ['english', 'spanish'],
     *   detectLeetspeak: true,
     *   normalizeUnicode: true,
     *   cacheResults: true,
     *   enableContextAware: true,
     * });
     * ```
     */
    constructor(config?: FilterConfig);
    /**
     * The obfuscation-aware scanner needs word boundaries; fuzzy matching
     * (wordBoundaries off) and `obfuscation: 'off'` keep the legacy scan.
     */
    private static readonly ACCENT_ALIAS_MIN_LENGTH;
    private static withAccentFoldedAliases;
    private createScanner;
    private debugLog;
    /**
     * Normalizes text with every enabled method (Unicode, leetspeak, legacy
     * obfuscation). `aggressive` collapses repeated characters to one.
     */
    private normalizeText;
    /**
     * Clears the result cache.
     * Useful when dictionary or configuration changes.
     */
    clearCache(): void;
    /**
     * Gets the current cache size.
     * @returns Number of cached results
     */
    getCacheSize(): number;
    /**
     * Exports the current filter configuration as a JSON-serializable object.
     * Useful for saving configuration to files or sharing between environments.
     *
     * @returns The current filter configuration
     *
     * @example
     * ```typescript
     * const filter = new Filter({
     *   languages: ['english', 'spanish'],
     *   detectLeetspeak: true,
     *   leetspeakLevel: 'aggressive',
     * });
     *
     * const config = filter.getConfig();
     * // Save to file: fs.writeFileSync('filter.config.json', JSON.stringify(config));
     *
     * // Later, restore:
     * // const saved = JSON.parse(fs.readFileSync('filter.config.json'));
     * // const restored = new Filter(saved);
     * ```
     */
    getConfig(): FilterConfig;
    /**
     * Returns the current word dictionary size.
     * Useful for monitoring and debugging.
     *
     * @returns Number of words in the dictionary
     */
    getWordCount(): number;
    /**
     * Adds a result to the cache, evicting oldest entries if necessary.
     */
    private addToCache;
    /**
     * Gets a cached result if available.
     */
    private getFromCache;
    private redact;
    /** Safe spans of the text on the legacy path, and the text with them blanked. */
    private legacySafe;
    private legacyContext;
    /**
     * Checks if the given text contains profanity.
     *
     * @param value - The text to check
     * @returns True if the text contains profanity
     *
     * @example
     * ```typescript
     * const filter = new Filter({ detectLeetspeak: true });
     *
     * filter.isProfane('hello');     // false
     * filter.isProfane('fuck');      // true
     * filter.isProfane('f4ck');      // true (leetspeak)
     * filter.isProfane('fυck');      // true (Unicode homoglyph)
     * ```
     */
    isProfane(value: string): boolean;
    matches(word: string): boolean;
    /**
     * Performs a comprehensive profanity check on the given text.
     *
     * @param text - The text to check for profanity
     * @returns Result object containing detected profanity information
     *
     * @example
     * ```typescript
     * const filter = new Filter({
     *   languages: ['english'],
     *   detectLeetspeak: true,
     *   normalizeUnicode: true,
     * });
     *
     * const result = filter.checkProfanity('This is f4ck!ng bad');
     * console.log(result.containsProfanity);  // true
     * console.log(result.profaneWords);       // ['fuck']
     *
     * // With caching for repeated checks
     * const filter2 = new Filter({ cacheResults: true });
     * filter2.checkProfanity('same text');  // Computed
     * filter2.checkProfanity('same text');  // Retrieved from cache
     * ```
     */
    checkProfanity(text: string): CheckProfanityResult;
    /**
     * Checks profanity with minimum severity filtering.
     *
     * @param text - The text to check
     * @param minSeverity - Minimum severity level to include in results
     * @returns Object with filtered words and full result
     */
    checkProfanityWithMinSeverity(text: string, minSeverity?: SeverityLevel): {
        filteredWords: string[];
        result: CheckProfanityResult;
    };
}

export { Filter as F };