@iota-big3/sdk-security/dist/types/integration.types.d.ts

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

/**
 * Integration Types for SDK Security
 * Uses contracts to ensure compatibility
 */
import type { TypedRequest } from '@iota-big3/sdk-types';
import type { SecurityCacheContract } from '../contracts/cache.contract';
import type { SecurityDatabaseContract } from '../contracts/database.contract';
import type { SecurityEventBusContract } from '../contracts/events.contract';
import type { SecurityLoggerContract } from '../contracts/logger.contract';
import type { SDK as CoreSDK } from '@iota-big3/sdk-core';
import type { UniversalAPIGateway } from '@iota-big3/sdk-gateway';
export interface SDKIntegrationOptions {
    database?: SecurityDatabaseContract;
    eventBus?: SecurityEventBusContract;
    logger?: SecurityLoggerContract;
    cache?: SecurityCacheContract;
    core?: CoreSDK;
    gateway?: UniversalAPIGateway;
}
export interface SecurityManagerOptions extends SDKIntegrationOptions {
    config: SecurityConfig;
}
import type { SecurityConfig } from '../types';
export interface SecurityEvents {
    'security:initialized': {
        timestamp: number;
    };
    'security:role.created': {
        roleId: string;
        permissions: string[];
    };
    'security:role.updated': {
        roleId: string;
        changes: Record<string, unknown>;
    };
    'security:role.deleted': {
        roleId: string;
    };
    'security:permission.granted': {
        userId: string;
        permission: string;
    };
    'security:permission.revoked': {
        userId: string;
        permission: string;
    };
    'security:policy.created': {
        policyId: string;
        rules: unknown[];
    };
    'security:policy.updated': {
        policyId: string;
        changes: Record<string, unknown>;
    };
    'security:scan.started': {
        scanId: string;
        targets: string[];
    };
    'security:scan.completed': {
        scanId: string;
        results: unknown;
    };
    'security:threat.detected': {
        threatId: string;
        severity: string;
    };
    'security:audit.logged': {
        eventId: string;
        action: string;
    };
}
export interface SecurityDatabaseTables {
    security_roles: {
        id: string;
        name: string;
        permissions: string;
        created_at: Date;
        updated_at: Date;
    };
    security_policies: {
        id: string;
        type: 'rbac' | 'abac';
        rules: string;
        created_at: Date;
    };
    security_audit_events: {
        id: string;
        event_type: string;
        actor_id: string;
        resource: string;
        action: string;
        result: 'success' | 'failure';
        timestamp: Date;
    };
    security_scan_results: {
        id: string;
        scan_type: string;
        target: string;
        vulnerabilities: string;
        timestamp: Date;
    };
}
export interface SecurityCacheKeys {
    accessControl: `access:${string}:${string}`;
    roles: `roles:${string}`;
    policies: `policy:${string}`;
    scanResults: `scan:${string}`;
}
export interface SecurityGatewayRoutes {
    '/api/security/auth': {
        methods: ['POST'];
        middleware: ['rate-limit', 'validate'];
    };
    '/api/security/roles': {
        methods: ['GET', 'POST', 'PUT', 'DELETE'];
        middleware: ['auth', 'admin'];
    };
    '/api/security/scan': {
        methods: ['POST'];
        middleware: ['auth', 'rate-limit'];
    };
}
export interface AuthenticatedRequest extends TypedRequest {
    user?: {
        id: string;
        roles?: string[];
        permissions?: string[];
    };
}
export interface SecurityCoreConfig {
    security: {
        enabled: boolean;
        rbac: {
            enabled: boolean;
        };
        abac: {
            enabled: boolean;
        };
        encryption: {
            algorithm: string;
        };
        auth: {
            sessionTimeout: number;
        };
    };
}
//# sourceMappingURL=integration.types.d.ts.map