@iota-big3/sdk-security/dist/iam/rbac-abac.d.ts

Advanced security features including zero trust, quantum-safe crypto, and ML threat detection

import { EventEmitter } from 'events';
import { Role, Permission, AccessRequest, AccessDecision } from '../types/security.types';
import { Logger } from '@iota-big3/sdk-observability';
export interface RBACConfig {
    enableHierarchy: boolean;
    enableDynamicRoles: boolean;
    cacheTimeout: number;
    defaultDenyMessage: string;
}
export interface ABACConfig {
    enableAttributeInheritance: boolean;
    policyEngine: 'opa' | 'custom';
    policyPath?: string;
    evaluationTimeout: number;
}
export declare class RBACManager extends EventEmitter {
    private roles;
    private _permissions;
    private userRoles;
    private roleHierarchy;
    private config;
    private logger;
    private cache;
    constructor(config: RBACConfig, logger: Logger);
    createRole(role: Role): Promise<Role>;
    assignRole(userId: string, roleId: string): Promise<void>;
    removeRole(userId: string, roleId: string): Promise<void>;
    getUserPermissions(userId: string): Permission[];
    private collectRoles;
    hasPermission(userId: string, resource: string, action: string): boolean;
    private matchPattern;
    private clearUserCache;
    private startCacheCleanup;
    getRole(roleId: string): Role | undefined;
    getUserRoles(userId: string): Role[];
    exportConfig(): any;
    importConfig(config: any): Promise<void>;
}
export declare class ABACManager extends EventEmitter {
    private config;
    private logger;
    private policyEngine?;
    private policies;
    private attributeProviders;
    constructor(config: ABACConfig, logger: Logger);
    private initializePolicyEngine;
    registerAttributeProvider(name: string, provider: (_request: AccessRequest) => Promise<any>): void;
    loadPolicy(name: string, policy: string): Promise<void>;
    evaluate(_request: AccessRequest, rbacDecision?: boolean): Promise<AccessDecision>;
    private enrichRequest;
    private evaluateWithOPA;
    private evaluateWithCustomEngine;
    private logDecision;
    getPolicies(): string[];
    removePolicy(): void;
}
export declare class AccessControl {
    private rbacManager;
    private abacManager;
    private logger;
    constructor(rbacConfig: RBACConfig, abacConfig: ABACConfig, logger: Logger);
    checkAccess(_request: AccessRequest): Promise<AccessDecision>;
    get rbac(): RBACManager;
    get abac(): ABACManager;
}
//# sourceMappingURL=rbac-abac.d.ts.map