import { SecurityContextValue, SecurityViolation, SecurityConfiguration } from '../types';
/**
 * Hook for accessing the security context
 *
 * Provides access to security state, CSP nonces, CSRF tokens,
 * violation reporting, and security configuration.
 *
 * @returns Security context value
 * @throws Error if used outside SecurityProvider
 *
 * @example
 * ```tsx
 * function SecureComponent() {
 *   const {
 *     cspNonce,
 *     csrfToken,
 *     isInitialized,
 *     violations,
 *     reportViolation,
 *   } = useSecurityContext();
 *
 *   if (!isInitialized) {
 *     return <Loading />;
 *   }
 *
 *   return (
 *     <div>
 *       <p>Security violations: {violations.length}</p>
 *       <script nonce={cspNonce}>
 *         // inline script
 *       </script>
 *     </div>
 *   );
 * }
 * ```
 */
export declare function useSecurityContext(): SecurityContextValue;
/**
 * Hook for security state only (no actions)
 *
 * Useful when you only need to read security state.
 *
 * @example
 * ```tsx
 * function SecurityStatus() {
 *   const { isInitialized, violations } = useSecurityState();
 *
 *   return (
 *     <div>
 *       Status: {isInitialized ? 'Ready' : 'Initializing'}
 *       Violations: {violations.length}
 *     </div>
 *   );
 * }
 * ```
 */
export declare function useSecurityState(): {
    cspNonce: string;
    csrfToken: string;
    isInitialized: boolean;
    secureStorageAvailable: boolean;
    violations: readonly SecurityViolation[];
    lastEventAt: number;
};
/**
 * Hook for security actions only
 *
 * Useful when you only need security actions without state.
 *
 * @example
 * ```tsx
 * function SecurityControls() {
 *   const {
 *     regenerateNonce,
 *     regenerateCsrfToken,
 *     clearViolations,
 *   } = useSecurityActions();
 *
 *   return (
 *     <div>
 *       <button onClick={regenerateNonce}>Regenerate Nonce</button>
 *       <button onClick={() => regenerateCsrfToken()}>
 *         Regenerate CSRF Token
 *       </button>
 *       <button onClick={clearViolations}>Clear Violations</button>
 *     </div>
 *   );
 * }
 * ```
 */
export declare function useSecurityActions(): {
    regenerateNonce: () => string;
    regenerateCsrfToken: () => Promise<string>;
    reportViolation: (violation: Omit<SecurityViolation, 'id' | 'timestamp'>) => void;
    clearViolations: () => void;
    updateConfig: (partial: Partial<SecurityConfiguration>) => void;
};
/**
 * Hook for security configuration
 *
 * @example
 * ```tsx
 * function SecuritySettings() {
 *   const config = useSecurityConfig();
 *
 *   return (
 *     <pre>{JSON.stringify(config, null, 2)}</pre>
 *   );
 * }
 * ```
 */
export declare function useSecurityConfig(): SecurityConfiguration;
/**
 * Hook for violation reporting
 *
 * @example
 * ```tsx
 * function SecureInput() {
 *   const reportViolation = useViolationReporter();
 *
 *   const handleSuspiciousInput = (input: string) => {
 *     reportViolation({
 *       type: 'xss',
 *       details: `Suspicious input detected: ${input.slice(0, 50)}`,
 *       severity: 'medium',
 *       blocked: true,
 *     });
 *   };
 *
 *   // ...
 * }
 * ```
 */
export declare function useViolationReporter(): (violation: Omit<SecurityViolation, 'id' | 'timestamp'>) => void;
/**
 * Hook for monitoring violations
 *
 * @example
 * ```tsx
 * function ViolationMonitor() {
 *   const { violations, hasViolations, criticalCount } = useViolations();
 *
 *   useEffect(() => {
 *     if (criticalCount > 0) {
 *       notifySecurityTeam(violations);
 *     }
 *   }, [criticalCount, violations]);
 *
 *   return (
 *     <div>
 *       {hasViolations && (
 *         <Alert severity="warning">
 *           {violations.length} security violations detected
 *         </Alert>
 *       )}
 *     </div>
 *   );
 * }
 * ```
 */
export declare function useViolations(): {
    violations: readonly SecurityViolation[];
    hasViolations: boolean;
    criticalCount: number;
    highCount: number;
    clearViolations: () => void;
};
/**
 * Hook for security initialization status
 *
 * @example
 * ```tsx
 * function App() {
 *   const { isReady, isSecureStorageAvailable } = useSecurityStatus();
 *
 *   if (!isReady) {
 *     return <SplashScreen />;
 *   }
 *
 *   return <MainApp />;
 * }
 * ```
 */
export declare function useSecurityStatus(): {
    isReady: boolean;
    isSecureStorageAvailable: boolean;
};
/**
 * Hook that waits for security initialization
 *
 * Returns null until security is initialized, then returns the context.
 * Useful for conditional rendering.
 *
 * @example
 * ```tsx
 * function SecureFeature() {
 *   const security = useSecurityReady();
 *
 *   if (!security) {
 *     return <Loading message="Initializing security..." />;
 *   }
 *
 *   return <SecureContent nonce={security.cspNonce} />;
 * }
 * ```
 */
export declare function useSecurityReady(): SecurityContextValue | null;
/**
 * Hook for creating secure event handlers
 *
 * Wraps event handlers with security checks.
 *
 * @example
 * ```tsx
 * function SecureForm() {
 *   const createSecureHandler = useSecureHandler();
 *
 *   const handleSubmit = createSecureHandler(async (data: FormData) => {
 *     await submitForm(data);
 *   });
 *
 *   return <form onSubmit={handleSubmit}>...</form>;
 * }
 * ```
 */
export declare function useSecureHandler(): <T extends (...args: unknown[]) => unknown>(handler: T, options?: {
    validateCsrf?: boolean;
    reportOnError?: boolean;
}) => T;