@useverse/profanity-guard 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,1548 @@
+import * as react from 'react';
+
+/**
+ * Type Definitions for ProfanityGuard
+ *
+ * @module types
+ * @description Comprehensive TypeScript type definitions for the ProfanityGuard content moderation library
+ */
+/**
+ * Moderation level enumeration
+ *
+ * @enum {string}
+ * @description Defines how strictly content should be moderated
+ *
+ * @example
+ * ```typescript
+ * import { ModerationLevel, ProfanityGuard } from 'profanity-guard';
+ *
+ * const strictModerator = new ProfanityGuard(ModerationLevel.STRICT);
+ * const relaxedModerator = new ProfanityGuard(ModerationLevel.RELAXED);
+ * ```
+ */
+declare enum ModerationLevel {
+    /**
+     * No moderation - all content passes through unchanged
+     *
+     * @remarks Use this when you want to disable moderation temporarily
+     * without removing the moderator instance
+     */
+    OFF = "off",
+    /**
+     * Relaxed moderation - only blocks SEVERE and WTF severity words
+     *
+     * @remarks Suitable for adult audiences or casual environments where
+     * mild profanity is acceptable
+     */
+    RELAXED = "relaxed",
+    /**
+     * Moderate moderation - blocks MODERATE, SEVERE, and WTF severity words
+     *
+     * @remarks The default level. Suitable for most general-purpose applications
+     * and public-facing content
+     */
+    MODERATE = "moderate",
+    /**
+     * Strict moderation - blocks all profanity (MILD, MODERATE, SEVERE, WTF)
+     *
+     * @remarks Suitable for family-friendly environments, educational platforms,
+     * or professional contexts where any profanity is unacceptable
+     */
+    STRICT = "strict"
+}
+/**
+ * Word severity classification enumeration
+ *
+ * @enum {string}
+ * @description Categorizes words by their offensive level
+ *
+ * @example
+ * ```typescript
+ * import { WordSeverity, ProfanityGuard } from 'profanity-guard';
+ *
+ * const moderator = new ProfanityGuard();
+ * moderator.addWord('example', WordSeverity.MODERATE, ['alternative']);
+ * const moderator = new ProfanityGuard();
+ * moderator.addWord('example', WordSeverity.MODERATE, ['alternative']);
+ * ```
+ */
+declare enum WordSeverity {
+    /**
+     * Mild severity - minor profanity
+     *
+     * @remarks Examples: damn, hell, crap
+     * Generally acceptable in casual adult conversations but may be
+     * inappropriate in professional or family settings
+     */
+    MILD = "mild",
+    /**
+     * Moderate severity - common profanity
+     *
+     * @remarks Examples: shit, ass, bitch
+     * Inappropriate in most public and professional contexts
+     */
+    MODERATE = "moderate",
+    /**
+     * Severe severity - strong profanity and slurs
+     *
+     * @remarks Examples: fuck, and various slurs
+     * Offensive in virtually all contexts, should be blocked
+     * in most applications
+     */
+    SEVERE = "severe",
+    /**
+     * WTF severity - extreme profanity and hate speech
+     *
+     * @remarks The most offensive category, including extreme profanity,
+     * slurs, and hate speech. Should always be blocked except in
+     * very specific research or archival contexts
+     */
+    WTF = "absolutely not"
+}
+/**
+ * Word entry structure for the moderation library
+ *
+ * @interface WordEntry
+ * @description Defines the structure of a word in the moderation library
+ *
+ * @example
+ * ```typescript
+ * const entry: WordEntry = {
+ *   word: 'damn',
+ *   severity: WordSeverity.MILD,
+ *   alternatives: ['darn', 'dang']
+ * };
+ *
+ * moderator.addWord(entry.word, entry.severity, entry.alternatives);
+ * ```
+ */
+interface WordEntry {
+    /**
+     * The base word to moderate (stored in lowercase)
+     *
+     * @type {string}
+     * @remarks The actual word will be matched case-insensitively and with
+     * common obfuscation patterns (e.g., @ for a, 3 for e)
+     */
+    word: string;
+    /**
+     * Severity classification of the word
+     *
+     * @type {WordSeverity}
+     * @remarks Determines at which moderation levels this word will be blocked
+     */
+    severity: WordSeverity;
+    /**
+     * Optional array of alternative replacement words
+     *
+     * @type {string[] | undefined}
+     * @remarks Used when calling {@link ProfanityGuard.moderateSentence} with
+     * `preserveStructure: true`. The first alternative will be used as replacement.
+     *
+     * @example
+     * ```typescript
+     * // Without alternatives: "That's damn good" → "That's **** good"
+     * // With alternatives ['darn']: "That's damn good" → "That's darn good"
+     * ```
+     */
+    alternatives?: string[];
+    /**
+     * Optional array of common obfuscated variations of the word
+     *
+     * @type {string[] | undefined}
+     * @remarks Used automatically by pattern matching to detect obfuscated variations
+     */
+    variants?: string[];
+}
+/**
+ * Match information for a detected profanity instance
+ *
+ * @interface Match
+ * @description Details about a single detected profane word in content
+ */
+interface Match {
+    /**
+     * The actual matched word as it appeared in the content
+     *
+     * @type {string}
+     * @remarks May be in any case or obfuscation (e.g., "D@mn", "DAMN", "d4mn")
+     */
+    word: string;
+    /**
+     * Severity level of the matched word
+     *
+     * @type {WordSeverity}
+     */
+    severity: WordSeverity;
+    /**
+     * Zero-based position where the word was found in the original content
+     *
+     * @type {number}
+     * @remarks Can be used to highlight or manipulate specific instances
+     *
+     * @example
+     * ```typescript
+     * const content = "Hello damn world";
+     * const result = moderator.moderate(content);
+     * // result.matches[0].position === 6
+     * ```
+     */
+    position: number;
+}
+/**
+ * Comprehensive moderation result
+ *
+ * @interface ModerationResult
+ * @description Contains all information about a moderation operation
+ *
+ * @example
+ * ```typescript
+ * const result: ModerationResult = moderator.moderate("This damn text has shit");
+ *
+ * if (!result.isClean) {
+ *   console.log(`Found ${result.foundWords.length} profane words`);
+ *   console.log(`Highest severity: ${result.severity}`);
+ *   console.log(`Sanitized: ${result.sanitized}`);
+ *
+ *   result.matches.forEach(match => {
+ *     console.log(`"${match.word}" at position ${match.position}`);
+ *   });
+ * }
+ * ```
+ */
+interface ModerationResult {
+    /**
+     * Whether the content is free of profanity
+     *
+     * @type {boolean}
+     * @remarks `true` if no profanity detected, `false` otherwise
+     */
+    isClean: boolean;
+    /**
+     * Array of unique profane words found in the content
+     *
+     * @type {string[]}
+     * @remarks Contains each unique matched word (duplicates removed).
+     * Words appear as they were matched in the content (preserving case/obfuscation).
+     *
+     * @example
+     * ```typescript
+     * // Content: "Damn this damn situation"
+     * // foundWords: ['Damn', 'damn'] or ['Damn'] depending on implementation
+     * ```
+     */
+    foundWords: string[];
+    /**
+     * Highest severity level found in the content
+     *
+     * @type {WordSeverity | null}
+     * @remarks `null` if no profanity detected, otherwise the most severe
+     * category found
+     *
+     * @example
+     * ```typescript
+     * // Content: "damn this shit"
+     * // severity: WordSeverity.MODERATE (shit is more severe than damn)
+     * ```
+     */
+    severity: WordSeverity | null;
+    /**
+     * Sanitized version of the content with profanity censored or replaced
+     *
+     * @type {string}
+     * @remarks Profane words are replaced with:
+     * - Censor characters (default: asterisks) in standard moderation
+     * - Alternative words when using {@link ProfanityGuard.moderateSentence} with `preserveStructure: true`
+     *
+     * @example
+     * ```typescript
+     * // Standard: "damn" → "****"
+     * // With alternatives: "damn" → "darn"
+     * ```
+     */
+    sanitized: string;
+    /**
+     * Detailed information about each match found
+     *
+     * @type {Match[]}
+     * @remarks Array of match objects sorted by position.
+     * Useful for detailed analysis, logging, or custom replacement logic.
+     *
+     * @example
+     * ```typescript
+     * result.matches.forEach(match => {
+     *   console.log(`Found "${match.word}" (${match.severity}) at position ${match.position}`);
+     * });
+     * ```
+     */
+    matches: Match[];
+}
+/**
+ * Library statistics structure
+ *
+ * @interface LibraryStats
+ * @description Statistics about the current word library
+ *
+ * @example
+ * ```typescript
+ * const stats = moderator.getStats();
+ * console.log(`Total words: ${stats.total}`);
+ * console.log(`Distribution: ${stats.mild} mild, ${stats.moderate} moderate, ${stats.severe} severe`);
+ * ```
+ */
+interface LibraryStats {
+    /**
+     * Total number of words in the library
+     *
+     * @type {number}
+     */
+    total: number;
+    /**
+     * Number of MILD severity words
+     *
+     * @type {number}
+     */
+    mild: number;
+    /**
+     * Number of MODERATE severity words
+     *
+     * @type {number}
+     */
+    moderate: number;
+    /**
+     * Number of SEVERE severity words
+     *
+     * @type {number}
+     */
+    severe: number;
+    /**
+     * Number of WTF severity words
+     *
+     * @type {number}
+     */
+    wtf?: number;
+}
+/**
+ * Configuration options for ProfanityGuard constructor
+ *
+ * @interface ProfanityGuardConfig
+ * @description Optional configuration object for creating ProfanityGuard instances
+ *
+ * @example
+ * ```typescript
+ * const config: ProfanityGuardConfig = {
+ *   moderationLevel: ModerationLevel.STRICT,
+ *   censorChar: '#',
+ *   autoImportLibrary: true
+ * };
+ *
+ * const moderator = new ProfanityGuard(config);
+ * ```
+ */
+interface ProfanityGuardConfig {
+    /**
+     * Initial moderation level
+     *
+     * @type {ModerationLevel}
+     * @default ModerationLevel.MODERATE
+     */
+    moderationLevel?: ModerationLevel;
+    /**
+     * Character used for censoring
+     *
+     * @type {string}
+     * @default '*'
+     */
+    censorChar?: string;
+    /**
+     * Whether to automatically import the default library
+     *
+     * @type {boolean}
+     * @default true
+     */
+    autoImportLibrary?: boolean;
+}
+
+/**
+ * Profanity Guard - A flexible, production-ready content moderation library
+ *
+ * @module ProfanityGuard
+ * @version 1.0.0
+ * @license MIT
+ *
+ * @description
+ * A comprehensive TypeScript library for content moderation and profanity filtering.
+ * Features multiple severity levels, customizable word libraries, obfuscation detection,
+ * and flexible sanitization options.
+ *
+ * @example
+ * ```typescript
+ * import { ProfanityGuard, ModerationLevel } from 'profanity-guard';
+ *
+ * const moderator = new ProfanityGuard(ModerationLevel.MODERATE);
+ * const result = moderator.moderate("This is some damn text");
+ *
+ * console.log(result.isClean); // false
+ * console.log(result.sanitized); // "This is some **** text"
+ * ```
+ */
+
+/**
+ * Main content moderation class
+ *
+ * @class ProfanityGuard
+ * @classdesc Provides comprehensive content moderation with configurable severity levels,
+ * custom word libraries, and advanced pattern matching including obfuscation detection.
+ *
+ * @example
+ * ```typescript
+ * // Basic usage
+ * const moderator = new ProfanityGuard();
+ * const clean = moderator.isClean("Hello world"); // true
+ *
+ * // With custom settings
+ * const strictModerator = new ProfanityGuard(ModerationLevel.STRICT, '#');
+ * const result = strictModerator.moderate("damn it");
+ * console.log(result.sanitized); // "#### it"
+ * ```
+ */
+declare class ProfanityGuard {
+    /** @private Current moderation level determining which words to filter */
+    private moderationLevel;
+    /** @private Internal word library storing all moderation entries */
+    private wordLibrary;
+    /** @private Character used to censor detected profanity */
+    private censorChar;
+    /**
+     * Creates a new ProfanityGuard instance
+     *
+     * @constructor
+     * @param {ModerationLevel} [moderationLevel=ModerationLevel.MODERATE] - Initial moderation level
+     * @param {string} [censorChar='*'] - Character used for censoring bad words
+     *
+     * @example
+     * ```typescript
+     * // Default settings (moderate level, '*' censor)
+     * const moderator = new ProfanityGuard();
+     *
+     * // Custom settings
+     * const strictModerator = new ProfanityGuard(ModerationLevel.STRICT, '#');
+     *
+     * // Relaxed moderation
+     * const relaxedModerator = new ProfanityGuard(ModerationLevel.RELAXED);
+     * ```
+     */
+    constructor(moderationLevel?: ModerationLevel, censorChar?: string);
+    /**
+     * Initializes the word library with a basic default set of words
+     *
+     * @private
+     * @returns {void}
+     *
+     * @remarks
+     * This method is called automatically during construction.
+     * The default library includes common profanity categorized by severity.
+     * Users should expand this library based on their specific needs using
+     * {@link addWord}, {@link addWords}, or {@link importLibrary}.
+     */
+    private initializeDefaultLibrary;
+    /**
+     * Adds a single word to the moderation library
+     *
+     * @param {string} word - The word to add (case-insensitive)
+     * @param {WordSeverity} severity - The severity level of the word
+     * @param {string[]} [alternatives] - Optional array of alternative words for replacement
+     * @returns {void}
+     *
+     * @example
+     * ```typescript
+     * moderator.addWord('badword', WordSeverity.MODERATE, ['alternative', 'replacement']);
+     * moderator.addWord('slur', WordSeverity.SEVERE);
+     * ```
+     *
+     * @remarks
+     * - Words are stored in lowercase for case-insensitive matching
+     * - Alternatives are used when {@link moderateSentence} is called with `preserveStructure: true`
+     * - Duplicate words will overwrite the existing entry
+     */
+    addWord(word: string, severity: WordSeverity, alternatives?: string[], variants?: string[]): void;
+    /**
+     * Adds multiple words to the library at once
+     *
+     * @param {WordEntry[]} entries - Array of word entries to add
+     * @returns {void}
+     *
+     * @example
+     * ```typescript
+     * moderator.addWords([
+     *   { word: 'badword1', severity: WordSeverity.MILD, alternatives: ['good1'] },
+     *   { word: 'badword2', severity: WordSeverity.MODERATE }
+     * ]);
+     * ```
+     *
+     * @see {@link WordEntry} for the structure of each entry
+     */
+    addWords(entries: WordEntry[]): void;
+    /**
+     * Removes a word from the moderation library
+     *
+     * @param {string} word - The word to remove (case-insensitive)
+     * @returns {boolean} `true` if the word was removed, `false` if it wasn't in the library
+     *
+     * @example
+     * ```typescript
+     * const removed = moderator.removeWord('damn');
+     * if (removed) {
+     *   console.log('Word removed successfully');
+     * }
+     * ```
+     */
+    removeWord(word: string): boolean;
+    /**
+     * Imports a word library from a JSON-compatible array
+     *
+     * @param {WordEntry[]} jsonData - Array of word entries to import
+     * @returns {void}
+     *
+     * @example
+     * ```typescript
+     * import customLibrary from './custom-words.json';
+     * moderator.importLibrary(customLibrary);
+     *
+     * // Or use the built-in library
+     * import { all_bad_words } from 'profanity-guard/core/library';
+     * moderator.importLibrary(all_bad_words);
+     * ```
+     *
+     * @remarks
+     * This method adds to the existing library rather than replacing it.
+     * Use {@link clearLibrary} first if you want to replace the entire library.
+     */
+    importLibrary(jsonData: WordEntry[]): void;
+    /**
+     * Exports the current word library as a JSON-compatible array
+     *
+     * @returns {WordEntry[]} Array of all word entries in the library
+     *
+     * @example
+     * ```typescript
+     * const library = moderator.exportLibrary();
+     * console.log(`Total words: ${library.length}`);
+     *
+     * // Save to file
+     * fs.writeFileSync('my-library.json', JSON.stringify(library, null, 2));
+     * ```
+     */
+    exportLibrary(): WordEntry[];
+    /**
+     * Clears all words from the library
+     *
+     * @returns {void}
+     *
+     * @example
+     * ```typescript
+     * moderator.clearLibrary();
+     * console.log(moderator.getStats().total); // 0
+     * ```
+     *
+     * @warning
+     * This will remove all words including the default library.
+     * Consider backing up with {@link exportLibrary} first.
+     */
+    clearLibrary(): void;
+    /**
+     * Changes the current moderation level
+     *
+     * @param {ModerationLevel} level - The new moderation level
+     * @returns {void}
+     *
+     * @example
+     * ```typescript
+     * moderator.setModerationLevel(ModerationLevel.STRICT);
+     * moderator.setModerationLevel(ModerationLevel.OFF); // Disables all moderation
+     * ```
+     *
+     * @see {@link ModerationLevel} for available levels and their behavior
+     */
+    setModerationLevel(level: ModerationLevel): void;
+    /**
+     * Gets the current moderation level
+     *
+     * @returns {ModerationLevel} The current moderation level
+     *
+     * @example
+     * ```typescript
+     * if (moderator.getModerationLevel() === ModerationLevel.STRICT) {
+     *   console.log('Running in strict mode');
+     * }
+     * ```
+     */
+    getModerationLevel(): ModerationLevel;
+    /**
+     * Determines if a word severity should be blocked based on current moderation level
+     *
+     * @private
+     * @param {WordSeverity} severity - The severity level to check
+     * @returns {boolean} `true` if the word should be blocked, `false` otherwise
+     *
+     * @remarks
+     * Moderation level hierarchy:
+     * - OFF: Blocks nothing
+     * - RELAXED: Blocks only SEVERE and WTF
+     * - MODERATE: Blocks MODERATE, SEVERE, and WTF
+     * - STRICT: Blocks MILD, MODERATE, SEVERE, and WTF
+     */
+    private shouldBlock;
+    /**
+     * Creates a regex pattern for matching a word with obfuscation detection
+     *
+     * @private
+     * @param {string} word - The word to create a pattern for
+     * @returns {RegExp} Regular expression that matches the word and common obfuscations
+     *
+     * @remarks
+     * The pattern handles:
+     * - Letter substitutions (e.g., @ for a, 3 for e, $ for s)
+     * - Case insensitivity
+     * - Special characters and spaces inserted between letters
+     * - Word boundaries to avoid false positives
+     *
+     * @example
+     * Pattern for "bad" will match: bad, b@d, B4D, b-a-d, b_a_d, etc.
+     */
+    private createWordPattern;
+    /**
+     * Get all words to check (main word + all variants)
+     */
+    private getAllWordsToCheck;
+    /**
+     * Performs comprehensive content moderation and returns detailed results
+     *
+     * @param {string} content - The text content to moderate
+     * @returns {ModerationResult} Detailed moderation results
+     *
+     * @example
+     * ```typescript
+     * const result = moderator.moderate("This damn text has shit in it");
+     *
+     * console.log(result.isClean);        // false
+     * console.log(result.foundWords);     // ['damn', 'shit']
+     * console.log(result.severity);       // 'moderate'
+     * console.log(result.sanitized);      // "This **** text has **** in it"
+     * console.log(result.matches.length); // 2
+     * ```
+     *
+     * @remarks
+     * - Detects obfuscated variations (e.g., "sh!t", "d@mn")
+     * - Handles overlapping matches correctly
+     * - Returns the highest severity level found
+     * - Preserves original text positions in match data
+     *
+     * @see {@link ModerationResult} for the complete result structure
+     */
+    moderate(content: string): ModerationResult;
+    /**
+     * Performs a quick check if content is clean (contains no profanity)
+     *
+     * @param {string} content - The text content to check
+     * @returns {boolean} `true` if clean, `false` if profanity detected
+     *
+     * @example
+     * ```typescript
+     * if (moderator.isClean("Hello world")) {
+     *   console.log("Content is safe!");
+     * }
+     *
+     * if (!moderator.isClean("This is shit")) {
+     *   console.log("Profanity detected!");
+     * }
+     * ```
+     *
+     * @remarks
+     * This is a convenience method that calls {@link moderate} and returns only the `isClean` property.
+     * Use {@link moderate} directly if you need additional details about detected words.
+     */
+    isClean(content: string): boolean;
+    /**
+     * Returns a sanitized (censored) version of the content
+     *
+     * @param {string} content - The text content to sanitize
+     * @returns {string} The sanitized text with profanity censored
+     *
+     * @example
+     * ```typescript
+     * const clean = moderator.sanitize("This damn text is shit");
+     * console.log(clean); // "This **** text is ****"
+     *
+     * // With custom censor character
+     * const moderator2 = new ProfanityGuard(ModerationLevel.MODERATE, '#');
+     * console.log(moderator2.sanitize("damn")); // "####"
+     * ```
+     *
+     * @remarks
+     * This is a convenience method that calls {@link moderate} and returns only the `sanitized` property.
+     */
+    sanitize(content: string): string;
+    /**
+     * Gets the numeric rank of a severity level for comparison
+     *
+     * @private
+     * @param {WordSeverity} severity - The severity level to rank
+     * @returns {number} Numeric rank (1=MILD, 2=MODERATE, 3=SEVERE)
+     */
+    private getSeverityRank;
+    /**
+     * Gets statistics about the current word library
+     *
+     * @returns {Object} Statistics object containing word counts by severity
+     * @returns {number} .total - Total number of words in the library
+     * @returns {number} .mild - Number of MILD severity words
+     * @returns {number} .moderate - Number of MODERATE severity words
+     * @returns {number} .severe - Number of SEVERE severity words
+     * @returns {number} .wtf - Number of WTF severity words
+     * @returns {number} .totalVariants - Total number of variants across all words
+     *
+     * @example
+     * ```typescript
+     * const stats = moderator.getStats();
+     * console.log(`Total words: ${stats.total}`);
+     * console.log(`Mild: ${stats.mild}, Moderate: ${stats.moderate}, Severe: ${stats.severe}`);
+     * ```
+     */
+    getStats(): {
+        total: number;
+        mild: number;
+        moderate: number;
+        severe: number;
+        wtf: number;
+        totalVariants: number;
+    };
+    /**
+     * Validates that critical words are in the library
+     *
+     * @param {string[]} [criticalWords] - Array of words that must be present
+     * @returns {Object} Validation result
+     * @returns {boolean} .allPresent - True if all critical words are in library
+     * @returns {string[]} .missing - Array of missing words
+     * @returns {string[]} .present - Array of present words
+     *
+     * @example
+     * ```typescript
+     * const validation = moderator.validateLibrary(['fuck', 'shit', 'nigga']);
+     * if (!validation.allPresent) {
+     *   console.error('Missing words:', validation.missing);
+     * }
+     * ```
+     */
+    validateLibrary(criticalWords?: string[]): {
+        allPresent: boolean;
+        missing: string[];
+        present: string[];
+    };
+    /**
+     * Debug a specific word - see if it's detected and how
+     *
+     * @param {string} word - The word to debug
+     * @param {string} [testText] - Optional text to test the word against
+     * @returns {Object} Debug information
+     * @returns {boolean} .inLibrary - True if word is in the library
+     * @returns {WordEntry} [.entry] - The word entry if found
+     * @returns {string} [.pattern] - The regex pattern used for matching
+     * @returns {boolean} .wouldBlock - True if word would be blocked at current level
+     * @returns {ModerationResult} [.testResult] - Result of testing against testText
+     *
+     * @example
+     * ```typescript
+     * const debug = moderator.debugWord('pussy', 'this pussy is bad');
+     * console.log('In library:', debug.inLibrary);
+     * console.log('Would block:', debug.wouldBlock);
+     * console.log('Test result:', debug.testResult);
+     * ```
+     */
+    debugWord(word: string, testText?: string): {
+        inLibrary: boolean;
+        entry?: WordEntry;
+        pattern?: string;
+        wouldBlock: boolean;
+        testResult?: ModerationResult;
+    };
+    /**
+     * Run comprehensive tests to ensure nothing slips through
+     *
+     * @returns {Object} Test results
+     * @returns {number} .passed - Number of tests that passed
+     * @returns {number} .failed - Number of tests that failed
+     * @returns {Array} .results - Detailed results for each test
+     *
+     * @example
+     * ```typescript
+     * const testResults = moderator.runTests();
+     * console.log(`${testResults.passed} passed, ${testResults.failed} failed`);
+     * testResults.results.forEach(r => {
+     *   console.log(`${r.passed ? '✅' : '❌'} ${r.test}: ${r.details}`);
+     * });
+     * ```
+     */
+    runTests(): {
+        passed: number;
+        failed: number;
+        results: Array<{
+            test: string;
+            passed: boolean;
+            details: string;
+        }>;
+    };
+    /**
+     * Moderates a sentence with optional structure preservation using alternatives
+     *
+     * @param {string} sentence - The sentence to moderate
+     * @param {boolean} [preserveStructure=false] - If true, replaces bad words with alternatives instead of censoring
+     * @returns {ModerationResult} Detailed moderation results
+     *
+     * @example
+     * ```typescript
+     * // Standard censoring
+     * const result1 = moderator.moderateSentence("This is damn good");
+     * console.log(result1.sanitized); // "This is **** good"
+     *
+     * // With structure preservation (uses alternatives)
+     * const result2 = moderator.moderateSentence("This is damn good", true);
+     * console.log(result2.sanitized); // "This is darn good"
+     * ```
+     *
+     * @remarks
+     * When `preserveStructure` is true, the method replaces profanity with the first alternative
+     * from the word's alternatives array. If no alternative exists, it falls back to censoring.
+     *
+     * This is useful for maintaining readability while removing profanity, such as in
+     * comment systems or user-generated content displays.
+     */
+    moderateSentence(sentence: string, preserveStructure?: boolean): ModerationResult;
+    /**
+     * Highlights profane words in content by wrapping them in custom tags
+     *
+     * @param {string} content - The text content to highlight
+     * @param {string} [openTag='<mark>'] - Opening tag to wrap profane words
+     * @param {string} [closeTag='</mark>'] - Closing tag to wrap profane words
+     * @returns {string} Content with profane words wrapped in tags
+     *
+     * @example
+     * ```typescript
+     * const highlighted = moderator.highlight("This damn text is shit");
+     * // Output: "This <mark>damn</mark> text is <mark>shit</mark>"
+     *
+     * const custom = moderator.highlight("damn it", '<span class="profanity">', '</span>');
+     * // Output: "damn it" becomes '<span class="profanity">damn</span> it'
+     * ```
+     *
+     * @remarks
+     * Useful for displaying flagged content to moderators or for educational purposes.
+     * The tags are not HTML-escaped, so ensure safe usage.
+     */
+    highlight(content: string, openTag?: string, closeTag?: string): string;
+    /**
+     * Counts profane words by severity level
+     *
+     * @param {string} content - The text content to analyze
+     * @returns {Object} Count of words by severity level
+     *
+     * @example
+     * ```typescript
+     * const counts = moderator.countBySeverity("This damn shit is fucking bad");
+     * // Output: { mild: 1, moderate: 1, severe: 1, wtf: 0, total: 3 }
+     * ```
+     */
+    countBySeverity(content: string): {
+        mild: number;
+        moderate: number;
+        severe: number;
+        wtf: number;
+        total: number;
+    };
+    /**
+     * Calculates a profanity score for the content
+     *
+     * @param {string} content - The text content to score
+     * @returns {number} Score from 0-100 (0 = clean, 100 = extremely profane)
+     *
+     * @example
+     * ```typescript
+     * const score = moderator.getProfanityScore("Hello world");
+     * console.log(score); // 0
+     *
+     * const badScore = moderator.getProfanityScore("This fucking damn shit");
+     * console.log(badScore); // ~75 (depends on word count and severity)
+     * ```
+     *
+     * @remarks
+     * Score calculation:
+     * - MILD words: 10 points each
+     * - MODERATE words: 25 points each
+     * - SEVERE words: 50 points each
+     * - WTF words: 100 points each
+     * - Normalized by word count and capped at 100
+     */
+    getProfanityScore(content: string): number;
+    /**
+     * Checks if content exceeds a profanity threshold
+     *
+     * @param {string} content - The text content to check
+     * @param {number} threshold - Maximum allowed profanity score (0-100)
+     * @returns {boolean} True if content is within threshold, false otherwise
+     *
+     * @example
+     * ```typescript
+     * const isAcceptable = moderator.isWithinThreshold("Hello world", 10);
+     * console.log(isAcceptable); // true
+     *
+     * const isTooProfiled = moderator.isWithinThreshold("This shit is bad", 15);
+     * console.log(isTooProfiled); // false (score too high)
+     * ```
+     */
+    isWithinThreshold(content: string, threshold: number): boolean;
+    /**
+     * Extracts only clean sentences from content
+     *
+     * @param {string} content - The text content to filter
+     * @param {string} [delimiter='.'] - Sentence delimiter
+     * @returns {string[]} Array of clean sentences
+     *
+     * @example
+     * ```typescript
+     * const text = "Hello world. This is damn bad. Nice day today.";
+     * const clean = moderator.getCleanSentences(text);
+     * // Output: ["Hello world", "Nice day today"]
+     * ```
+     */
+    getCleanSentences(content: string, delimiter?: string): string[];
+    /**
+     * Moderates an array of strings and returns results for each
+     *
+     * @param {string[]} contents - Array of text content to moderate
+     * @returns {ModerationResult[]} Array of moderation results
+     *
+     * @example
+     * ```typescript
+     * const results = moderator.moderateBatch([
+     *   "Hello world",
+     *   "This is damn bad",
+     *   "Nice day"
+     * ]);
+     * console.log(results[1].isClean); // false
+     * ```
+     */
+    moderateBatch(contents: string[]): ModerationResult[];
+    /**
+     * Gets a detailed report of all profanity found in content
+     *
+     * @param {string} content - The text content to analyze
+     * @returns {Object} Detailed profanity report
+     *
+     * @example
+     * ```typescript
+     * const report = moderator.getDetailedReport("This damn shit is bad");
+     * console.log(report);
+     * // {
+     * //   isClean: false,
+     * //   totalWords: 5,
+     * //   profaneWords: 2,
+     * //   profanityPercentage: 40,
+     * //   score: 35,
+     * //   highestSeverity: 'moderate',
+     * //   severityCounts: { mild: 1, moderate: 1, severe: 0, wtf: 0 },
+     * //   flaggedWords: ['damn', 'shit'],
+     * //   details: [...]
+     * // }
+     * ```
+     */
+    getDetailedReport(content: string): {
+        isClean: boolean;
+        totalWords: number;
+        profaneWords: number;
+        profanityPercentage: number;
+        score: number;
+        highestSeverity: WordSeverity | null;
+        severityCounts: {
+            mild: number;
+            moderate: number;
+            severe: number;
+            wtf: number;
+        };
+        flaggedWords: string[];
+        details: Array<{
+            word: string;
+            severity: WordSeverity;
+            position: number;
+            context: string;
+        }>;
+    };
+    /**
+     * Validates content and returns validation result
+     *
+     * @param {string} content - The text content to validate
+     * @param {Object} options - Validation options
+     * @param {number} [options.maxProfanityScore] - Maximum allowed profanity score
+     * @param {WordSeverity} [options.maxSeverity] - Maximum allowed severity level
+     * @param {number} [options.maxProfaneWords] - Maximum number of profane words allowed
+     * @returns {Object} Validation result with pass/fail and reasons
+     *
+     * @example
+     * ```typescript
+     * const validation = moderator.validate("This is damn good", {
+     *   maxProfanityScore: 20,
+     *   maxSeverity: WordSeverity.MILD,
+     *   maxProfaneWords: 1
+     * });
+     * console.log(validation);
+     * // {
+     * //   isValid: true,
+     * //   reasons: [],
+     * //   score: 10,
+     * //   profaneWordCount: 1
+     * // }
+     * ```
+     */
+    validate(content: string, options?: {
+        maxProfanityScore?: number;
+        maxSeverity?: WordSeverity;
+        maxProfaneWords?: number;
+    }): {
+        isValid: boolean;
+        reasons: string[];
+        score: number;
+        profaneWordCount: number;
+    };
+    /**
+     * Replaces profane words with random alternatives from their alternatives list
+     *
+     * @param {string} content - The text content to process
+     * @returns {string} Content with profanity replaced by random alternatives
+     *
+     * @example
+     * ```typescript
+     * const replaced = moderator.replaceWithAlternatives("This damn thing is shit");
+     * // Output might be: "This darn thing is shoot" or "This dang thing is crap"
+     * ```
+     */
+    replaceWithAlternatives(content: string): string;
+    /**
+     * Gets words by severity level
+     *
+     * @param {WordSeverity} severity - The severity level to filter by
+     * @returns {WordEntry[]} Array of words with the specified severity
+     *
+     * @example
+     * ```typescript
+     * const mildWords = moderator.getWordsBySeverity(WordSeverity.MILD);
+     * console.log(mildWords); // All MILD severity words in the library
+     * ```
+     */
+    getWordsBySeverity(severity: WordSeverity): WordEntry[];
+    /**
+     * Checks if a specific word is in the library
+     *
+     * @param {string} word - The word to check
+     * @returns {boolean} True if the word is in the library, false otherwise
+     *
+     * @example
+     * ```typescript
+     * const hasWord = moderator.hasWord('damn');
+     * console.log(hasWord); // true
+     * ```
+     */
+    hasWord(word: string): boolean;
+    /**
+     * Gets information about a specific word
+     *
+     * @param {string} word - The word to look up
+     * @returns {WordEntry | null} Word entry if found, null otherwise
+     *
+     * @example
+     * ```typescript
+     * const info = moderator.getWordInfo('damn');
+     * console.log(info);
+     * // { word: 'damn', severity: 'mild', alternatives: ['darn', 'dang'] }
+     * ```
+     */
+    getWordInfo(word: string): WordEntry | null;
+    /**
+     * Filters an array of strings to only include clean content
+     *
+     * @param {string[]} contents - Array of text content to filter
+     * @returns {string[]} Array containing only clean content
+     *
+     * @example
+     * ```typescript
+     * const filtered = moderator.filterClean([
+     *   "Hello world",
+     *   "This is damn bad",
+     *   "Nice day"
+     * ]);
+     * console.log(filtered); // ["Hello world", "Nice day"]
+     * ```
+     */
+    filterClean(contents: string[]): string[];
+    /**
+     * Filters an array of strings to only include profane content
+     *
+     * @param {string[]} contents - Array of text content to filter
+     * @returns {string[]} Array containing only profane content
+     *
+     * @example
+     * ```typescript
+     * const profane = moderator.filterProfane([
+     *   "Hello world",
+     *   "This is damn bad",
+     *   "Nice day"
+     * ]);
+     * console.log(profane); // ["This is damn bad"]
+     * ```
+     */
+    filterProfane(contents: string[]): string[];
+    /**
+     * Suggests alternatives for a given word if it's in the library
+     *
+     * @param {string} word - The word to get suggestions for
+     * @returns {string[]} Array of alternative words, empty if word not found or no alternatives
+     *
+     * @example
+     * ```typescript
+     * const suggestions = moderator.getSuggestions('damn');
+     * console.log(suggestions); // ['darn', 'dang']
+     * ```
+     */
+    getSuggestions(word: string): string[];
+    test(): void;
+}
+/**
+ * Quick utility function for one-off moderation without creating an instance
+ *
+ * @param {string} content - The text content to moderate
+ * @param {ModerationLevel} [level=ModerationLevel.MODERATE] - Moderation level to use
+ * @returns {ModerationResult} Detailed moderation results
+ *
+ * @example
+ * ```typescript
+ * import { quickModerate, ModerationLevel } from 'profanity-guard';
+ *
+ * const result = quickModerate("Some damn text", ModerationLevel.STRICT);
+ * console.log(result.sanitized);
+ * ```
+ *
+ * @remarks
+ * This function creates a new ProfanityGuard instance with the full word library for each call.
+ * For better performance when moderating multiple pieces of content, create a ProfanityGuard
+ * instance once and reuse it.
+ */
+declare function quickModerate(content: string, level?: ModerationLevel): ModerationResult;
+/**
+ * Quick utility to check if content is clean
+ *
+ * @param {string} content - The text content to check
+ * @param {ModerationLevel} [level=ModerationLevel.MODERATE] - Moderation level to use
+ * @returns {boolean} True if clean, false otherwise
+ *
+ * @example
+ * ```typescript
+ * import { quickCheck } from 'profanity-guard';
+ *
+ * if (quickCheck("Hello world")) {
+ *   console.log("Content is clean!");
+ * }
+ * ```
+ */
+declare function quickCheck(content: string, level?: ModerationLevel): boolean;
+/**
+ * Quick utility to sanitize content
+ *
+ * @param {string} content - The text content to sanitize
+ * @param {ModerationLevel} [level=ModerationLevel.MODERATE] - Moderation level to use
+ * @param {string} [censorChar='*'] - Character to use for censoring
+ * @returns {string} Sanitized content
+ *
+ * @example
+ * ```typescript
+ * import { quickSanitize } from 'profanity-guard';
+ *
+ * const clean = quickSanitize("This damn text");
+ * console.log(clean); // "This **** text"
+ * ```
+ */
+declare function quickSanitize(content: string, level?: ModerationLevel, censorChar?: string): string;
+/**
+ * Quick utility to get profanity score
+ *
+ * @param {string} content - The text content to score
+ * @param {ModerationLevel} [level=ModerationLevel.MODERATE] - Moderation level to use
+ * @returns {number} Profanity score (0-100)
+ *
+ * @example
+ * ```typescript
+ * import { quickScore } from 'profanity-guard';
+ *
+ * const score = quickScore("This damn shit is bad");
+ * console.log(score); // e.g., 45
+ * ```
+ */
+declare function quickScore(content: string, level?: ModerationLevel): number;
+/**
+ * Quick utility to validate content against criteria
+ *
+ * @param {string} content - The text content to validate
+ * @param {Object} options - Validation options
+ * @returns {boolean} True if valid, false otherwise
+ *
+ * @example
+ * ```typescript
+ * import { quickValidate } from 'profanity-guard';
+ *
+ * const isValid = quickValidate("Hello world", { maxProfanityScore: 10 });
+ * console.log(isValid); // true
+ * ```
+ */
+declare function quickValidate(content: string, options?: {
+    maxProfanityScore?: number;
+    maxSeverity?: WordSeverity;
+    maxProfaneWords?: number;
+    level?: ModerationLevel;
+}): boolean;
+/**
+ * Quick moderation for RELAXED level (only severe/wtf words)
+ * Lazy-loads only severe and wtf word lists for minimal bundle impact
+ *
+ * @param {string} content - The text content to moderate
+ * @returns {ModerationResult} Detailed moderation results
+ */
+declare function quickModerateRelaxed(content: string): ModerationResult;
+/**
+ * Quick moderation for MODERATE level (moderate/severe/wtf words)
+ * Lazy-loads moderate, severe, and wtf word lists
+ *
+ * @param {string} content - The text content to moderate
+ * @returns {ModerationResult} Detailed moderation results
+ */
+declare function quickModerateModerate(content: string): ModerationResult;
+/**
+ * Quick moderation for STRICT level (all words)
+ * Lazy-loads all word lists
+ *
+ * @param {string} content - The text content to moderate
+ * @returns {ModerationResult} Detailed moderation results
+ */
+declare function quickModerateStrict(content: string): ModerationResult;
+/**
+ * Quick check for RELAXED level
+ * @param {string} content - The text content to check
+ * @returns {boolean} True if clean, false otherwise
+ */
+declare function quickCheckRelaxed(content: string): boolean;
+/**
+ * Quick check for MODERATE level
+ * @param {string} content - The text content to check
+ * @returns {boolean} True if clean, false otherwise
+ */
+declare function quickCheckModerate(content: string): boolean;
+/**
+ * Quick check for STRICT level
+ * @param {string} content - The text content to check
+ * @returns {boolean} True if clean, false otherwise
+ */
+declare function quickCheckStrict(content: string): boolean;
+/**
+ * Quick sanitize for RELAXED level
+ * @param {string} content - The text content to sanitize
+ * @param {string} [censorChar='*'] - Character to use for censoring
+ * @returns {string} Sanitized content
+ */
+declare function quickSanitizeRelaxed(content: string, censorChar?: string): string;
+/**
+ * Quick sanitize for MODERATE level
+ * @param {string} content - The text content to sanitize
+ * @param {string} [censorChar='*'] - Character to use for censoring
+ * @returns {string} Sanitized content
+ */
+declare function quickSanitizeModerate(content: string, censorChar?: string): string;
+/**
+ * Quick sanitize for STRICT level
+ * @param {string} content - The text content to sanitize
+ * @param {string} [censorChar='*'] - Character to use for censoring
+ * @returns {string} Sanitized content
+ */
+declare function quickSanitizeStrict(content: string, censorChar?: string): string;
+
+/**
+ * Word Library Module
+ *
+ * @module core/library
+ * @description Comprehensive word library for content moderation with severity classifications
+ *
+ * @remarks
+ * This library uses lazy loading to minimize bundle size. Word lists are only loaded when needed.
+ * The library is expandable and should be customized based on your specific needs using:
+ * - {@link ProfanityGuard.addWord}
+ * - {@link ProfanityGuard.addWords}
+ * - {@link ProfanityGuard.importLibrary}
+ */
+
+/**
+ * Legacy exports for backward compatibility
+ * @deprecated Use lazy loading functions instead for better bundle size
+ */
+declare const mild_bad_words: WordEntry[];
+declare const moderate_bad_words: WordEntry[];
+declare const severe_bad_words: WordEntry[];
+declare const wtf_bad_words: WordEntry[];
+declare const all_bad_words: WordEntry[];
+
+/**
+ * Configuration options for useProfanityGuard hook
+ */
+interface UseProfanityGuardOptions {
+    /** Moderation level to use */
+    level?: ModerationLevel;
+    /** Character to use for censoring */
+    censorChar?: string;
+    /** Custom word library to import */
+    customLibrary?: WordEntry[];
+    /** Whether to clear default library before importing custom library */
+    clearDefault?: boolean;
+}
+/**
+ * Main hook for content moderation
+ *
+ * @param options - Configuration options
+ * @returns Moderation utilities and state
+ *
+ * @example
+ * ```tsx
+ * function CommentForm() {
+ *   const { moderate, isClean, sanitize } = useProfanityGuard({
+ *     level: ModerationLevel.MODERATE
+ *   });
+ *
+ *   const [comment, setComment] = useState('');
+ *   const result = moderate(comment);
+ *
+ *   return (
+ *     <div>
+ *       <textarea value={comment} onChange={e => setComment(e.target.value)} />
+ *       {!result.isClean && <p>Please remove profanity</p>}
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function useProfanityGuard(options?: UseProfanityGuardOptions): {
+    moderate: (content: string) => ModerationResult;
+    isClean: (content: string) => boolean;
+    sanitize: (content: string) => string;
+    moderateSentence: (content: string, preserveStructure?: boolean) => ModerationResult;
+    setModerationLevel: (newLevel: ModerationLevel) => void;
+    addWord: (word: string, severity: WordSeverity, alternatives?: string[]) => void;
+    removeWord: (word: string) => boolean;
+    moderator: ProfanityGuard;
+};
+/**
+ * Hook for real-time content moderation with state management
+ *
+ * @param initialContent - Initial content value
+ * @param options - Configuration options
+ * @returns Content state and moderation utilities
+ *
+ * @example
+ * ```tsx
+ * function ChatInput() {
+ *   const {
+ *     content,
+ *     setContent,
+ *     result,
+ *     sanitizedContent,
+ *     isClean
+ *   } = useModeratedInput('', { level: ModerationLevel.STRICT });
+ *
+ *   return (
+ *     <div>
+ *       <input
+ *         value={content}
+ *         onChange={e => setContent(e.target.value)}
+ *       />
+ *       {!isClean && <p className="error">Contains profanity</p>}
+ *       <p>Preview: {sanitizedContent}</p>
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function useModeratedInput(initialContent?: string, options?: UseProfanityGuardOptions): {
+    content: string;
+    setContent: react.Dispatch<react.SetStateAction<string>>;
+    result: ModerationResult;
+    sanitizedContent: string;
+    isClean: boolean;
+    foundWords: string[];
+    severity: WordSeverity;
+};
+/**
+ * Hook for batch content moderation
+ *
+ * @param options - Configuration options
+ * @returns Batch moderation utilities
+ *
+ * @example
+ * ```tsx
+ * function CommentList({ comments }) {
+ *   const { moderateBatch, filterClean, filterProfane } = useBatchModeration();
+ *
+ *   const results = moderateBatch(comments);
+ *   const cleanComments = filterClean(comments);
+ *
+ *   return (
+ *     <div>
+ *       {cleanComments.map(comment => <div key={comment}>{comment}</div>)}
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function useBatchModeration(options?: UseProfanityGuardOptions): {
+    moderateBatch: (contents: string[]) => ModerationResult[];
+    filterClean: (contents: string[]) => string[];
+    filterProfane: (contents: string[]) => string[];
+};
+/**
+ * Hook for form validation with profanity checking
+ *
+ * @param options - Configuration options
+ * @returns Validation utilities
+ *
+ * @example
+ * ```tsx
+ * function SignupForm() {
+ *   const { validateField, errors } = useProfanityValidation();
+ *   const [username, setUsername] = useState('');
+ *
+ *   const handleSubmit = (e) => {
+ *     e.preventDefault();
+ *     if (validateField('username', username)) {
+ *       // Submit form
+ *     }
+ *   };
+ *
+ *   return (
+ *     <form onSubmit={handleSubmit}>
+ *       <input value={username} onChange={e => setUsername(e.target.value)} />
+ *       {errors.username && <p>{errors.username}</p>}
+ *     </form>
+ *   );
+ * }
+ * ```
+ */
+declare function useProfanityValidation(options?: UseProfanityGuardOptions): {
+    validateField: (fieldName: string, value: string) => boolean;
+    errors: Record<string, string>;
+    clearError: (fieldName: string) => void;
+    clearAllErrors: () => void;
+    hasErrors: boolean;
+};
+/**
+ * Hook for live content sanitization with debouncing
+ *
+ * @param delay - Debounce delay in milliseconds
+ * @param options - Configuration options
+ * @returns Sanitization utilities
+ *
+ * @example
+ * ```tsx
+ * function LiveEditor() {
+ *   const { content, setContent, sanitized, isProcessing } = useLiveSanitizer(300);
+ *
+ *   return (
+ *     <div>
+ *       <textarea value={content} onChange={e => setContent(e.target.value)} />
+ *       {isProcessing && <span>Processing...</span>}
+ *       <div>Sanitized: {sanitized}</div>
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function useLiveSanitizer(delay?: number, options?: UseProfanityGuardOptions): {
+    content: string;
+    setContent: react.Dispatch<react.SetStateAction<string>>;
+    sanitized: string;
+    isProcessing: boolean;
+};
+/**
+ * Hook for profanity statistics and analytics
+ *
+ * @param options - Configuration options
+ * @returns Statistics utilities
+ *
+ * @example
+ * ```tsx
+ * function ModerationDashboard() {
+ *   const { stats, analyzeContent, history } = useProfanityStats();
+ *
+ *   return (
+ *     <div>
+ *       <h2>Moderation Stats</h2>
+ *       <p>Total analyzed: {history.length}</p>
+ *       <p>Flagged: {history.filter(h => !h.isClean).length}</p>
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function useProfanityStats(options?: UseProfanityGuardOptions): {
+    stats: {
+        library: {
+            total: number;
+            mild: number;
+            moderate: number;
+            severe: number;
+            wtf: number;
+            totalVariants: number;
+        };
+        analyzed: {
+            total: number;
+            flagged: number;
+            clean: number;
+            flaggedPercentage: number;
+        };
+    };
+    analyzeContent: (content: string) => ModerationResult;
+    history: ModerationResult[];
+    clearHistory: () => void;
+};
+/**
+ * Hook for content replacement with alternatives
+ *
+ * @param options - Configuration options
+ * @returns Replacement utilities
+ *
+ * @example
+ * ```tsx
+ * function SmartEditor() {
+ *   const { replaceWithAlternatives, getSuggestions } = useContentReplacement();
+ *   const [text, setText] = useState('');
+ *
+ *   const handleReplace = () => {
+ *     setText(replaceWithAlternatives(text));
+ *   };
+ *
+ *   return (
+ *     <div>
+ *       <textarea value={text} onChange={e => setText(e.target.value)} />
+ *       <button onClick={handleReplace}>Replace Profanity</button>
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function useContentReplacement(options?: UseProfanityGuardOptions): {
+    replaceWithAlternatives: (content: string) => string;
+    getSuggestions: (word: string) => string[];
+    getWordInfo: (word: string) => WordEntry;
+};
+
+export { type LibraryStats, type Match, ModerationLevel, type ModerationResult, ProfanityGuard, type ProfanityGuardConfig, type UseProfanityGuardOptions, type WordEntry, WordSeverity, all_bad_words, mild_bad_words, moderate_bad_words, quickCheck, quickCheckModerate, quickCheckRelaxed, quickCheckStrict, quickModerate, quickModerateModerate, quickModerateRelaxed, quickModerateStrict, quickSanitize, quickSanitizeModerate, quickSanitizeRelaxed, quickSanitizeStrict, quickScore, quickValidate, severe_bad_words, useBatchModeration, useContentReplacement, useLiveSanitizer, useModeratedInput, useProfanityGuard, useProfanityStats, useProfanityValidation, wtf_bad_words };