import { Permission, PermissionAction, RoleDefinition, AccessRequest, EvaluationResult } from './types';
/**
 * Return type for the useRBAC hook.
 */
export interface UseRBACReturn {
    /** Whether RBAC is initialized */
    initialized: boolean;
    /** Whether RBAC is loading */
    loading: boolean;
    /** Current user's role IDs */
    userRoles: string[];
    /** Current user's direct permissions */
    userPermissions: Permission[];
    /** Any initialization error */
    error: string | null;
    /** Check if user has a permission */
    hasPermission: (permission: Permission) => boolean;
    /** Check if user has any of the permissions */
    hasAnyPermission: (permissions: Permission[]) => boolean;
    /** Check if user has all permissions */
    hasAllPermissions: (permissions: Permission[]) => boolean;
    /** Check if user has a role */
    hasRole: (role: string) => boolean;
    /** Check if user has any of the roles */
    hasAnyRole: (roles: string[]) => boolean;
    /** Check if user has all roles */
    hasAllRoles: (roles: string[]) => boolean;
    /** Check if user can access resource with action */
    canAccess: (resource: string, action: PermissionAction, resourceId?: string) => boolean;
    /** Check resource-level permission */
    checkResourcePermission: (resourceType: string, resourceId: string, action: PermissionAction) => boolean;
    /** Full access evaluation */
    evaluate: (request: AccessRequest) => EvaluationResult;
    /** Get all effective permissions */
    getEffectivePermissions: () => Permission[];
    /** Get user's role definitions */
    getRoleDefinitions: () => RoleDefinition[];
    /** Refresh permissions from server */
    refreshPermissions: () => Promise<void>;
    /** Clear evaluation cache */
    clearCache: () => void;
    /** Check create permission for resource */
    canCreate: (resource: string) => boolean;
    /** Check read permission for resource */
    canRead: (resource: string) => boolean;
    /** Check update permission for resource */
    canUpdate: (resource: string) => boolean;
    /** Check delete permission for resource */
    canDelete: (resource: string) => boolean;
    /** Check manage permission for resource */
    canManage: (resource: string) => boolean;
    /** Check if user is admin */
    isAdmin: boolean;
    /** Check if user is manager */
    isManager: boolean;
}
/**
 * Main RBAC hook for permission and role checking.
 *
 * @example
 * ```tsx
 * function DocumentsPage() {
 *   const {
 *     canCreate,
 *     canRead,
 *     canDelete,
 *     hasPermission,
 *     isAdmin,
 *   } = useRBAC();
 *
 *   return (
 *     <div>
 *       <h1>Documents</h1>
 *       {canRead('documents') && <DocumentList />}
 *       {canCreate('documents') && <CreateDocumentButton />}
 *       {hasPermission('documents:export') && <ExportButton />}
 *       {isAdmin && <AdminPanel />}
 *     </div>
 *   );
 * }
 * ```
 *
 * @returns RBAC utilities and state
 * @throws Error if used outside RBACProvider
 */
export declare function useRBAC(): UseRBACReturn;
/**
 * Hook for checking permissions only.
 *
 * @example
 * ```tsx
 * function SettingsPage() {
 *   const { hasPermission, hasAnyPermission } = usePermissions();
 *
 *   return (
 *     <div>
 *       {hasPermission('settings:view') && <GeneralSettings />}
 *       {hasAnyPermission(['settings:admin', 'settings:manage']) && (
 *         <AdvancedSettings />
 *       )}
 *     </div>
 *   );
 * }
 * ```
 */
export declare function usePermissions(): {
    permissions: Permission[];
    effectivePermissions: Permission[];
    hasPermission: (permission: Permission) => boolean;
    hasAnyPermission: (permissions: Permission[]) => boolean;
    hasAllPermissions: (permissions: Permission[]) => boolean;
};
/**
 * Hook for checking roles only.
 *
 * @example
 * ```tsx
 * function Dashboard() {
 *   const { hasRole, isAdmin, isManager } = useRoles();
 *
 *   return (
 *     <div>
 *       {isAdmin && <AdminDashboard />}
 *       {isManager && !isAdmin && <ManagerDashboard />}
 *       {!isManager && <UserDashboard />}
 *     </div>
 *   );
 * }
 * ```
 */
export declare function useRoles(): {
    roles: string[];
    roleDefinitions: RoleDefinition[];
    hasRole: (role: string) => boolean;
    hasAnyRole: (roles: string[]) => boolean;
    hasAllRoles: (roles: string[]) => boolean;
    isAdmin: boolean;
    isManager: boolean;
};
/**
 * Hook for resource-level access control.
 *
 * @example
 * ```tsx
 * function DocumentViewer({ documentId }) {
 *   const { canAccess, checkResource } = useResourceAccess('documents');
 *
 *   const canView = checkResource(documentId, 'read');
 *   const canEdit = checkResource(documentId, 'update');
 *   const canDelete = checkResource(documentId, 'delete');
 *
 *   return (
 *     <div>
 *       {canView && <DocumentContent />}
 *       {canEdit && <EditButton />}
 *       {canDelete && <DeleteButton />}
 *     </div>
 *   );
 * }
 * ```
 */
export declare function useResourceAccess(resourceType: string): {
    resourceType: string;
    canAccess: (action: PermissionAction) => boolean;
    checkResource: (resourceId: string, action: PermissionAction) => boolean;
    evaluateAccess: (resourceId: string, action: string, context?: Record<string, unknown>) => EvaluationResult;
    canCreate: () => boolean;
    canRead: () => boolean;
    canUpdate: () => boolean;
    canDelete: () => boolean;
    canManage: () => boolean;
};
/**
 * Hook for conditional rendering based on permission.
 *
 * @example
 * ```tsx
 * function AdminPanel() {
 *   const { allowed, loading } = usePermissionGate('admin:access');
 *
 *   if (loading) return <Spinner />;
 *   if (!allowed) return <AccessDenied />;
 *
 *   return <AdminContent />;
 * }
 * ```
 */
export declare function usePermissionGate(permission: Permission): {
    allowed: boolean;
    loading: boolean;
};
/**
 * Hook for conditional rendering based on role.
 *
 * @example
 * ```tsx
 * function ManagerFeature() {
 *   const { allowed, loading } = useRoleGate(['manager', 'admin']);
 *
 *   if (loading) return <Spinner />;
 *   if (!allowed) return null;
 *
 *   return <ManagerContent />;
 * }
 * ```
 */
export declare function useRoleGate(roles: string | string[]): {
    allowed: boolean;
    loading: boolean;
};
/**
 * Hook for checking multiple permissions/roles at once.
 *
 * @example
 * ```tsx
 * function FeatureComponent() {
 *   const checks = useAccessChecks({
 *     canViewReports: { permission: 'reports:view' },
 *     canExport: { permission: 'reports:export' },
 *     isAdmin: { role: 'admin' },
 *     canManageUsers: { resource: 'users', action: 'manage' },
 *   });
 *
 *   return (
 *     <div>
 *       {checks.canViewReports && <ReportViewer />}
 *       {checks.canExport && <ExportButton />}
 *       {checks.isAdmin && <AdminSection />}
 *       {checks.canManageUsers && <UserManager />}
 *     </div>
 *   );
 * }
 * ```
 */
export declare function useAccessChecks<T extends Record<string, {
    permission: Permission;
} | {
    role: string;
} | {
    roles: string[];
} | {
    resource: string;
    action: PermissionAction;
}>>(checks: T): Record<keyof T, boolean>;