import { RateLimitModule } from '../modules/RateLimit';
import { AuthenticationModule } from '../modules/Authentication';
import { OrganizationModule } from '../modules/Organization';
import { SecurityModule } from '../modules/Security';
import { AnalyticsModule } from '../modules/Analytics';
import { EnhancedSecurityModule } from '../modules/EnhancedSecurity';
import { ComplianceModule } from '../modules/Compliance';
import { GitIntegrationModule } from '../modules/GitIntegration';
import { EncryptionModule } from '../modules/EncryptionModule';
import { MisconfigurationScannerModule } from '../modules/MisconfigurationScanner';
import { SecKavConfig } from '../types/common';
export interface SecKavMiddleware {
    expressMiddleware: () => any;
    nextMiddleware: () => any;
}
/**
 * SecKav Security SDK - Main class for all security features
 * Supports: Rate Limiting, Authentication, Organization Management, Security, Analytics, Enhanced Security, Compliance Reporting, Git Integration
 * NEW: GDPR/DPDP/CERT-IN Compliance, OpenAPI Security Scanning, GitHub/GitLab Integration
 */
export declare class SecKavSDK {
    private config;
    private rateLimit?;
    private authentication?;
    private organization?;
    private security?;
    private analytics?;
    private enhancedSecurity?;
    private compliance?;
    private gitIntegration?;
    private encryption?;
    private misconfigurationScanner?;
    constructor(config: SecKavConfig);
    /**
     * Get Express.js middleware with all enabled security features
     */
    getExpressMiddleware(): any;
    /**
     * Get Next.js middleware with all enabled security features
     */
    getNextMiddleware(): (req: any) => Promise<Response | null>;
    /**
     * Get individual modules for advanced usage
     */
    getRateLimitModule(): RateLimitModule | null;
    getAuthenticationModule(): AuthenticationModule | null;
    getOrganizationModule(): OrganizationModule | null;
    getSecurityModule(): SecurityModule | null;
    getEnhancedSecurityModule(): EnhancedSecurityModule | null;
    getAnalyticsModule(): AnalyticsModule | null;
    getComplianceModule(): ComplianceModule | null;
    getGitIntegrationModule(): GitIntegrationModule | null;
    getEncryptionModule(): EncryptionModule | null;
    getMisconfigurationScannerModule(): MisconfigurationScannerModule | null;
    /**
     * Direct access to misconfiguration scanning features
     */
    get misconfigurationScanning(): MisconfigurationScannerModule;
    /**
     * Convenience methods for common operations
     */
    login(email: string, password: string): Promise<import("../types/common").AuthResult>;
    register(email: string, password: string, name: string): Promise<import("../types/common").AuthResult>;
    getProfile(token: string): Promise<import("../types/common").AuthResult>;
    createOrganization(token: string, name: string, description?: string, domain?: string): Promise<import("../types/common").OrganizationResult>;
    getOrganizations(token: string): Promise<import("../types/common").OrganizationResult>;
    getSecuritySettings(token: string): Promise<import("../types/common").SecurityResult>;
    updateIpWhitelist(token: string, ipAddresses: string[]): Promise<import("../types/common").SecurityResult>;
    getRealTimeMetrics(token: string): Promise<import("../types/common").AnalyticsResult>;
    getAnalytics(token: string, timeframe?: '1h' | '24h' | '7d' | '30d'): Promise<import("../types/common").AnalyticsResult>;
    analyzeThreat(token: string, data: any): Promise<import("../modules/EnhancedSecurity").ThreatAnalysisResult>;
    analyzeAnomaly(token: string, requestData: any): Promise<import("../modules/EnhancedSecurity").AnomalyAnalysisResult>;
    scanFile(token: string, file: any): Promise<import("../modules/EnhancedSecurity").FileAnalysisResult>;
    getSecurityMetrics(token: string, timeRange?: '1h' | '24h' | '7d' | '30d'): Promise<import("../modules/EnhancedSecurity").SecurityMetrics>;
    checkDDoSStatus(token: string, organizationId: string): Promise<{
        isUnderAttack: boolean;
        attackType?: "volumetric" | "protocol" | "application";
        intensity: number;
        mitigationActions: string[];
        recommendedLimits: {
            requestsPerSecond: number;
            connectionsPerIp: number;
            payload: number;
        };
    }>;
    getSecurityHealth(token: string): Promise<{
        status: "healthy" | "degraded" | "unhealthy";
        components: {
            threatDetection: boolean;
            anomalyDetection: boolean;
            rateLimiting: boolean;
            fileScanning: boolean;
            threatIntelligence: boolean;
        };
        lastUpdate: Date;
        issues: string[];
    }>;
    /**
     * Generate a compliance report (GDPR, DPDP, CERT-IN)
     */
    generateComplianceReport(token: string, reportType: 'gdpr' | 'dpdp' | 'cert_in', period: {
        startDate: Date;
        endDate: Date;
    }): Promise<import("../modules/Compliance").ComplianceReport>;
    /**
     * Get compliance dashboard data
     */
    getComplianceDashboard(token: string): Promise<import("../modules/Compliance").ComplianceDashboard>;
    /**
     * Scan OpenAPI/Swagger specification for security issues
     */
    scanApiSpecification(token: string, file: {
        name: string;
        content: string;
        type: 'openapi' | 'swagger';
    }): Promise<import("../modules/Compliance").ApiSecurityScan>;
    /**
     * Test Git provider connection
     */
    testGitConnection(token: string, provider: {
        type: 'github' | 'gitlab';
        token: string;
        baseUrl?: string;
    }): Promise<{
        success: boolean;
        userInfo?: {
            username: string;
            email: string;
            name: string;
        };
        error?: string;
    }>;
    /**
     * Get repositories from Git provider
     */
    getRepositories(token: string, provider: {
        type: 'github' | 'gitlab';
        token: string;
        baseUrl?: string;
    }, options?: {
        page?: number;
        perPage?: number;
        search?: string;
    }): Promise<{
        repositories: import("../modules/GitIntegration").Repository[];
        pagination: {
            page: number;
            perPage: number;
            total?: number;
            hasMore: boolean;
        };
    }>;
    /**
     * Scan repository for security issues
     */
    scanRepository(token: string, provider: {
        type: 'github' | 'gitlab';
        token: string;
        baseUrl?: string;
    }, repositoryId: string, options?: {
        branch?: string;
        includeApiSpecs?: boolean;
        includeConfigFiles?: boolean;
    }): Promise<import("../modules/GitIntegration").SecurityScanResult>;
    /**
     * Get encryption status for organization
     */
    getEncryptionStatus(token: string): Promise<import("../modules/EncryptionModule").EncryptionResult>;
    /**
     * Enable encryption for organization
     */
    enableEncryption(token: string, config?: any): Promise<import("../modules/EncryptionModule").EncryptionResult>;
    /**
     * Rotate encryption key manually
     */
    rotateEncryptionKey(token: string, reason?: string): Promise<import("../modules/EncryptionModule").KeyRotationResult>;
    /**
     * Test encryption functionality
     */
    testEncryption(token: string, data: any, algorithm?: string): Promise<import("../modules/EncryptionModule").EncryptionTestResult>;
    /**
     * Scan OpenAPI specification for security issues
     */
    scanOpenAPISpec(token: string, specContent: string, filename: string): Promise<import("../modules/MisconfigurationScanner").ScannerResult>;
    /**
     * Upload and scan configuration files
     */
    scanConfigurationFiles(token: string, files: Array<{
        name: string;
        content: string | Buffer;
    }>): Promise<import("../modules/MisconfigurationScanner").ScannerResult>;
    /**
     * Get AI-powered security recommendations
     */
    getSecurityRecommendations(token: string, context: any): Promise<import("../modules/MisconfigurationScanner").ScannerResult>;
    /**
     * Configure LLM provider for enhanced scanning
     */
    configureLLMProvider(token: string, provider: any): Promise<import("../modules/MisconfigurationScanner").ScannerResult>;
    /**
     * Test LLM integration
     */
    testLLMIntegration(token: string, testPrompt?: string): Promise<import("../modules/MisconfigurationScanner").ScannerResult>;
    /**
     * Perform quick security assessment
     */
    performQuickSecurityAssessment(token: string, assessment: {
        openApiSpecs?: Array<{
            content: string;
            filename: string;
        }>;
        configFiles?: Array<{
            name: string;
            content: string;
        }>;
        generateRecommendations?: boolean;
    }): Promise<import("../modules/MisconfigurationScanner").ScannerResult>;
    /**
     * Generate security report from scan results
     */
    generateSecurityReport(token: string, options: {
        scanIds: string[];
        format?: 'json' | 'html' | 'markdown';
        includeRemediation?: boolean;
    }): Promise<import("../modules/MisconfigurationScanner").ScannerResult>;
    /**
     * Get SDK information and enabled features
     */
    getInfo(): {
        version: string;
        enabledFeatures: string[];
        organization: string;
        apiUrl: string;
        modules: {
            rateLimit: {
                name: string;
                version: string;
                organization: string;
                apiUrl: string;
            } | null;
            authentication: {
                name: string;
                version: string;
                description: string;
                apiUrl: string;
            } | null;
            organization: {
                name: string;
                version: string;
                description: string;
                apiUrl: string;
            } | null;
            security: {
                name: string;
                version: string;
                description: string;
                apiUrl: string;
            } | null;
            analytics: {
                name: string;
                version: string;
                description: string;
                apiUrl: string;
            } | null;
            enhancedSecurity: {
                name: string;
                version: string;
                features: string[];
                description: string;
            } | null;
            compliance: {
                name: string;
                version: string;
            } | null;
            gitIntegration: {
                name: string;
                version: string;
            } | null;
            encryption: {
                name: string;
                version: string;
                description: string;
                features: string[];
                apiUrl: string;
            } | null;
            misconfigurationScanner: {
                name: string;
                version: string;
                capabilities: string[];
                supportedFormats: string[];
                llmProviders: string[];
                apiUrl: string;
            } | null;
        };
    };
    /**
     * Update configuration at runtime
     */
    updateConfig(newConfig: Partial<SecKavConfig>): void;
}
export declare function createSecKavMiddleware(config: SecKavConfig): any;
export declare function createSecKavNextMiddleware(config: SecKavConfig): (req: any) => Promise<Response | null>;
//# sourceMappingURL=SecKavSDK.d.ts.map