import { HTMLEncodingContext, SanitizationOptions, ThreatDetail, UseSanitizedContentResult } from '../types';
import { createSafeHTMLProps } from '../xss-prevention';
/**
 * Options for the useSanitizedContent hook
 */
export interface UseSanitizedContentOptions extends SanitizationOptions {
    /** Whether to auto-sanitize on content change */
    autoSanitize?: boolean;
    /** Callback when threats are detected */
    onThreatsDetected?: (threats: readonly ThreatDetail[]) => void;
}
/**
 * Hook for XSS-safe content handling
 *
 * Provides sanitized HTML content, threat detection, and
 * context-aware encoding utilities.
 *
 * @param content - The content to sanitize
 * @param options - Sanitization options
 * @returns Sanitized content and utilities
 *
 * @example
 * ```tsx
 * function UserContent({ html }: { html: string }) {
 *   const {
 *     sanitizedHTML,
 *     wasModified,
 *     threats,
 *     isSafe,
 *   } = useSanitizedContent(html);
 *
 *   if (!isSafe) {
 *     console.warn('Threats detected:', threats);
 *   }
 *
 *   return (
 *     <div>
 *       {wasModified && (
 *         <div className="warning">Content was sanitized for safety</div>
 *       )}
 *       <div dangerouslySetInnerHTML={{ __html: sanitizedHTML }} />
 *     </div>
 *   );
 * }
 * ```
 */
export declare function useSanitizedContent(content: string, options?: UseSanitizedContentOptions): UseSanitizedContentResult;
/**
 * Hook for creating safe innerHTML props
 *
 * Convenience hook that returns props ready for React elements.
 *
 * @example
 * ```tsx
 * function RichText({ content }: { content: string }) {
 *   const { props, isSafe, warnings } = useSafeInnerHTML(content);
 *
 *   return (
 *     <div {...props} className="rich-text" />
 *   );
 * }
 * ```
 */
export declare function useSafeInnerHTML(content: string, options?: SanitizationOptions): {
    props: {
        dangerouslySetInnerHTML: {
            __html: string;
        };
    };
    isSafe: boolean;
    warnings: readonly string[];
};
/**
 * Hook for validating user input in real-time
 *
 * @example
 * ```tsx
 * function CommentInput() {
 *   const [value, setValue] = useState('');
 *   const { isValid, threats, preview } = useValidatedInput(value);
 *
 *   return (
 *     <div>
 *       <textarea
 *         value={value}
 *         onChange={(e) => setValue(e.target.value)}
 *         className={isValid ? '' : 'error'}
 *       />
 *       {!isValid && (
 *         <p className="warning">
 *           Content contains potentially dangerous patterns
 *         </p>
 *       )}
 *       <div className="preview">
 *         <strong>Preview:</strong>
 *         <div dangerouslySetInnerHTML={{ __html: preview }} />
 *       </div>
 *     </div>
 *   );
 * }
 * ```
 */
export declare function useValidatedInput(input: string, options?: SanitizationOptions): {
    isValid: boolean;
    threats: readonly ThreatDetail[];
    preview: string;
    sanitized: string;
};
/**
 * Hook for safe text rendering (no HTML)
 *
 * Strips all HTML and encodes for safe display.
 *
 * @example
 * ```tsx
 * function PlainText({ content }: { content: string }) {
 *   const safeText = useSafeText(content);
 *
 *   return <p>{safeText}</p>;
 * }
 * ```
 */
export declare function useSafeText(content: string): string;
/**
 * Hook for context-aware encoding
 *
 * @example
 * ```tsx
 * function SearchHighlight({ term }: { term: string }) {
 *   const encode = useContextEncoder();
 *
 *   // Safe for HTML content
 *   const htmlSafe = encode(term, 'html-content');
 *
 *   // Safe for URL parameter
 *   const urlSafe = encode(term, 'url-param');
 *
 *   return (
 *     <a href={`/search?q=${urlSafe}`}>
 *       Search for: {htmlSafe}
 *     </a>
 *   );
 * }
 * ```
 */
export declare function useContextEncoder(): (content: string, context: HTMLEncodingContext) => string;
/**
 * Hook for creating safe HTML props with threat reporting
 *
 * @example
 * ```tsx
 * function ModeratedContent({ html }: { html: string }) {
 *   const { props, report } = useSafeHTMLWithReport(html, {
 *     onReport: (report) => analytics.track('xss_attempt', report),
 *   });
 *
 *   return <div {...props} />;
 * }
 * ```
 */
export declare function useSafeHTMLWithReport(content: string, options?: {
    sanitizationOptions?: SanitizationOptions;
    onReport?: (report: {
        originalContent: string;
        threats: readonly ThreatDetail[];
        sanitizedContent: string;
        timestamp: number;
    }) => void;
}): {
    props: ReturnType<typeof createSafeHTMLProps>;
    report: {
        hadThreats: boolean;
        threatCount: number;
        threatTypes: readonly string[];
    };
};