@yaseratiar/react-responsive-easy-cli/dist/index.d.ts

🚀 Enterprise-grade CLI tools with AI integration and performance monitoring for React Responsive Easy

import { Command } from 'commander';
export { Command } from 'commander';
import { EventEmitter } from 'events';
import { OptimizationSuggestions, AIModelConfig, ComponentUsageData, PerformanceMetrics as PerformanceMetrics$1 } from '@yaseratiar/react-responsive-easy-ai-optimizer';
import winston from 'winston';
import { PerformanceMetrics as PerformanceMetrics$2, PerformanceAlert } from '@yaseratiar/react-responsive-easy-performance-dashboard';

declare const initCommand: Command;

declare const buildCommand: Command;

declare const analyzeCommand: Command;

declare const devCommand: Command;

/**
 * AI Command - Enterprise AI-powered analysis and optimization
 */

declare const aiCommand: Command;

/**
 * Performance Command - Real-time performance monitoring and analytics
 */

declare const performanceCommand: Command;

/**
 * Enterprise-Grade CI/CD Integration Commands
 *
 * Provides comprehensive CLI commands for CI/CD setup, management, and deployment
 * with support for GitHub Actions, GitLab CI, and Jenkins.
 *
 * @author React Responsive Easy CLI
 * @version 2.0.0
 */

declare function createCICommands(): Command;

/**
 * Enterprise-Grade Team Management Commands
 *
 * Provides comprehensive CLI commands for team management, user roles,
 * shared workspaces, and collaborative project management.
 *
 * @author React Responsive Easy CLI
 * @version 2.0.0
 */

declare function createTeamCommands(): Command;

/**
 * Enterprise-Grade Security Commands
 *
 * Provides comprehensive CLI commands for security management including
 * OAuth integration, SSO setup, encryption, audit logging, and compliance.
 *
 * @author React Responsive Easy CLI
 * @version 2.0.0
 */

declare function createSecurityCommands(): Command;

/**
 * Enterprise-Grade Plugin Management Commands
 *
 * Provides comprehensive CLI commands for plugin management including
 * installation, configuration, lifecycle management, and analytics.
 *
 * @author React Responsive Easy CLI
 * @version 2.0.0
 */

declare function createPluginCommands(): Command;

/**
 * Cloud Deployment CLI Commands
 *
 * Provides comprehensive cloud deployment and management commands
 * for AWS, Azure, and Google Cloud Platform.
 *
 * @author React Responsive Easy CLI
 * @version 2.0.0
 */

/**
 * Create cloud deployment commands
 */
declare function createCloudCommands(): Command;

declare const program$1: Command;

declare const program: Command;

/**
 * Enterprise CLI Core Module
 *
 * Provides enterprise-grade functionality for React Responsive Easy CLI
 * including AI integration, performance monitoring, and advanced analytics.
 */

interface EnterpriseConfig$1 {
    ai: {
        enabled: boolean;
        modelPath?: string;
        optimizationLevel: 'conservative' | 'balanced' | 'aggressive';
        autoOptimize: boolean;
        learningEnabled: boolean;
    };
    performance: {
        enabled: boolean;
        preset: 'development' | 'production' | 'strict';
        customThresholds?: Record<string, number>;
        realTimeMonitoring: boolean;
        alerting: boolean;
    };
    analytics: {
        enabled: boolean;
        dataRetention: number;
        anonymizeData: boolean;
        exportFormat: 'json' | 'csv' | 'xlsx';
    };
    enterprise: {
        teamId?: string;
        projectId?: string;
        environment: 'development' | 'staging' | 'production';
        complianceMode: boolean;
        auditLogging: boolean;
    };
}
interface ProjectMetadata$1 {
    id: string;
    name: string;
    version: string;
    framework: string;
    lastAnalyzed: Date;
    lastOptimized: Date;
    performanceScore: number;
    optimizationCount: number;
    teamId?: string;
    environment: string;
}
interface AnalysisResult {
    id: string;
    timestamp: Date;
    projectId: string;
    performance: {
        score: number;
        metrics: Record<string, number>;
        recommendations: string[];
    };
    optimization: {
        suggestions: OptimizationSuggestions;
        applied: boolean;
        impact: 'low' | 'medium' | 'high';
    };
    compliance: {
        status: 'compliant' | 'warning' | 'non-compliant';
        issues: string[];
    };
}
declare class EnterpriseCLI extends EventEmitter {
    private config;
    private aiOptimizer?;
    private performanceMonitor?;
    private aiIntegration?;
    private alertingSystem?;
    private analyticsEngine?;
    private logger;
    private storage;
    private projectMetadata;
    constructor(config?: Partial<EnterpriseConfig$1>);
    private mergeWithDefaults;
    private getStorageSchema;
    private createLogger;
    private initializeEnterpriseFeatures;
    private getDefaultAlertRules;
    private getVersion;
    /**
     * Analyze a project with AI-powered insights
     */
    analyzeProject(projectPath: string, options?: {
        includePerformance?: boolean;
        includeOptimization?: boolean;
        includeCompliance?: boolean;
    }): Promise<AnalysisResult>;
    /**
     * Apply AI-powered optimizations to a project
     */
    optimizeProject(projectPath: string, options?: {
        dryRun?: boolean;
        backup?: boolean;
        optimizationLevel?: 'conservative' | 'balanced' | 'aggressive';
    }): Promise<{
        applied: boolean;
        changes: string[];
        impact: 'low' | 'medium' | 'high';
        rollback?: string;
    }>;
    /**
     * Start real-time monitoring for a project
     */
    startMonitoring(projectPath: string): Promise<void>;
    /**
     * Stop real-time monitoring
     */
    stopMonitoring(): Promise<void>;
    /**
     * Generate comprehensive project report
     */
    generateReport(projectPath: string, options?: {
        format?: 'json' | 'html' | 'pdf';
        includeCharts?: boolean;
        includeRecommendations?: boolean;
    }): Promise<string>;
    private getProjectId;
    private loadProjectConfig;
    private saveProjectConfig;
    private updateProjectMetadata;
    private detectFramework;
    private collectUsageData;
    private calculatePerformanceScore;
    private generatePerformanceRecommendations;
    private calculateOptimizationImpact;
    private analyzeCompliance;
    private applyOptimizations;
    private createBackup;
    private storeAnalysisResult;
    private getLatestAnalysis;
    private getPerformanceTrends;
    private saveReport;
    /**
     * Get enterprise configuration
     */
    getConfig(): EnterpriseConfig$1;
    /**
     * Update enterprise configuration
     */
    updateConfig(updates: Partial<EnterpriseConfig$1>): void;
    /**
     * Get project metadata
     */
    getProjectMetadata(projectId: string): ProjectMetadata$1 | undefined;
    /**
     * Get all projects
     */
    getAllProjects(): ProjectMetadata$1[];
    /**
     * Cleanup resources
     */
    cleanup(): Promise<void>;
}

/**
 * Represents a breakpoint with width, height, and optional metadata
 */
interface Breakpoint {
    /** Unique identifier for the breakpoint */
    name: string;
    /** Width in pixels */
    width: number;
    /** Height in pixels */
    height: number;
    /** Optional alias (e.g., 'base', 'mobile', 'desktop') */
    alias?: string;
    /** Optional custom properties */
    custom?: Record<string, any>;
}
/**
 * Configuration for how a specific token type scales
 */
interface ScalingToken {
    /** Scaling factor (0.5 = half size, 1.0 = same size, 2.0 = double size) */
    scale: number | ((ratio: number) => number);
    /** Minimum value to prevent scaling below accessibility thresholds */
    min?: number;
    /** Maximum value to prevent excessive scaling */
    max?: number;
    /** Step increment for discrete scaling (e.g., spacing) */
    step?: number;
    /** Scaling curve for non-linear scaling */
    curve?: 'linear' | 'ease-in' | 'ease-out' | 'ease-in-out' | 'golden-ratio' | 'custom';
    /** CSS unit for the value */
    unit?: 'px' | 'rem' | 'em' | '%' | 'vw' | 'vh';
    /** Decimal precision for rounding */
    precision?: number;
    /** Whether this token should scale responsively */
    responsive?: boolean;
}
/**
 * Primary scaling strategy configuration
 */
interface ScalingStrategy {
    /** What dimension to use as the primary scaling factor */
    origin: 'width' | 'height' | 'min' | 'max' | 'diagonal' | 'area';
    /** Scaling mode for complex calculations */
    mode: 'linear' | 'exponential' | 'logarithmic' | 'golden-ratio' | 'custom';
    /** Token-specific scaling configurations */
    tokens: {
        fontSize: ScalingToken;
        spacing: ScalingToken;
        radius: ScalingToken;
        lineHeight: ScalingToken;
        shadow: ScalingToken;
        border: ScalingToken;
    };
    /** Rounding rules for scaled values */
    rounding: {
        mode: 'nearest' | 'up' | 'down' | 'custom';
        precision: number;
    };
    /** Accessibility constraints */
    accessibility: {
        minFontSize: number;
        minTapTarget: number;
        contrastPreservation: boolean;
    };
    /** Performance optimization settings */
    performance: {
        memoization: boolean;
        cacheStrategy: 'memory' | 'localStorage' | 'sessionStorage';
        precomputeValues: boolean;
    };
}
/**
 * Complete configuration for the responsive system
 */
interface ResponsiveConfig {
    /** Base breakpoint (usually the largest) */
    base: Breakpoint;
    /** All breakpoints including base */
    breakpoints: Breakpoint[];
    /** Scaling strategy configuration */
    strategy: ScalingStrategy;
    /** Development and debugging options */
    development?: {
        enableDebugMode: boolean;
        showScalingInfo: boolean;
        logScalingCalculations: boolean;
    };
}

/**
 * AI Integration Service
 *
 * Provides intelligent recommendations and optimizations using the AI-optimizer package
 */

interface AIAnalysisOptions {
    includePerformance?: boolean;
    includeAccessibility?: boolean;
    includeOptimization?: boolean;
    learningMode?: boolean;
    confidenceThreshold?: number;
}
interface AIRecommendation {
    id: string;
    type: 'performance' | 'accessibility' | 'optimization' | 'best-practice';
    priority: 'low' | 'medium' | 'high' | 'critical';
    title: string;
    description: string;
    impact: {
        performance: number;
        accessibility: number;
        maintainability: number;
    };
    confidence: number;
    codeExample?: string;
    implementationSteps: string[];
    estimatedEffort: 'low' | 'medium' | 'high';
    autoFixable: boolean;
}
interface AIInsight {
    category: string;
    insights: string[];
    recommendations: AIRecommendation[];
    metrics: {
        totalIssues: number;
        criticalIssues: number;
        autoFixableIssues: number;
        estimatedImprovement: number;
    };
}
declare class AIIntegrationService extends EventEmitter {
    private aiOptimizer?;
    private logger;
    private isInitialized;
    constructor(logger: winston.Logger);
    /**
     * Initialize the AI service
     */
    initialize(config?: Partial<AIModelConfig>): Promise<void>;
    /**
     * Analyze a project with AI-powered insights
     */
    analyzeProject(projectPath: string, config: ResponsiveConfig, options?: AIAnalysisOptions): Promise<AIInsight>;
    /**
     * Get intelligent recommendations for a specific issue
     */
    getRecommendations(issue: string, context: {
        config: ResponsiveConfig;
        usageData: ComponentUsageData[];
        performanceMetrics: PerformanceMetrics$1;
    }): Promise<AIRecommendation[]>;
    /**
     * Apply AI-suggested optimizations
     */
    applyOptimizations(config: ResponsiveConfig, suggestions: OptimizationSuggestions, options?: {
        dryRun?: boolean;
        confidenceThreshold?: number;
    }): Promise<{
        applied: boolean;
        changes: string[];
        rollback?: ResponsiveConfig;
    }>;
    /**
     * Learn from project usage patterns
     */
    learnFromProject(projectPath: string, config: ResponsiveConfig, performanceData: PerformanceMetrics$1): Promise<void>;
    /**
     * Predict performance impact of configuration changes
     */
    predictPerformanceImpact(config: ResponsiveConfig, proposedChanges: Partial<ResponsiveConfig>): Promise<{
        predictedImpact: {
            performance: number;
            accessibility: number;
            bundleSize: number;
        };
        confidence: number;
        recommendations: string[];
    }>;
    private collectUsageData;
    private analyzeFileForUsage;
    private collectPerformanceMetrics;
    private generateInsights;
    private analyzeIssue;
    private applySuggestion;
    private calculateEstimatedImprovement;
    /**
     * Check if the service is initialized
     */
    isReady(): boolean;
    /**
     * Get service status
     */
    getStatus(): {
        initialized: boolean;
        aiOptimizer: boolean;
        version: string;
    };
    /**
     * Cleanup resources
     */
    cleanup(): Promise<void>;
}

/**
 * Performance Integration Service
 *
 * Provides real-time performance monitoring and analytics using the performance dashboard package
 */

interface PerformanceConfig$1 {
    preset: 'development' | 'production' | 'strict';
    customThresholds?: Record<string, number>;
    realTimeMonitoring: boolean;
    alerting: boolean;
    analytics: boolean;
    dataRetention: number;
}
interface PerformanceSnapshot {
    id: string;
    timestamp: Date;
    metrics: PerformanceMetrics$2;
    alerts: PerformanceAlert[];
    score: number;
    trends: {
        performance: 'improving' | 'stable' | 'degrading';
        memory: 'stable' | 'increasing' | 'decreasing';
        responsiveness: 'improving' | 'stable' | 'degrading';
    };
}
interface PerformanceReportData {
    id: string;
    projectId: string;
    generatedAt: Date;
    period: {
        start: Date;
        end: Date;
    };
    summary: {
        averageScore: number;
        totalAlerts: number;
        criticalIssues: number;
        recommendations: number;
    };
    metrics: {
        performance: PerformanceMetrics$2;
        trends: any;
        comparisons: any;
    };
    insights: {
        topIssues: string[];
        improvements: string[];
        recommendations: string[];
    };
}
declare class PerformanceIntegrationService extends EventEmitter {
    private performanceMonitor?;
    private aiIntegration?;
    private alertingSystem?;
    private analyticsEngine?;
    private logger;
    private config;
    private isMonitoring;
    private snapshots;
    private reports;
    constructor(config: PerformanceConfig$1, logger: winston.Logger);
    /**
     * Initialize the performance service
     */
    initialize(): Promise<void>;
    /**
     * Start real-time performance monitoring
     */
    startMonitoring(projectPath: string): Promise<void>;
    /**
     * Stop performance monitoring
     */
    stopMonitoring(): Promise<void>;
    /**
     * Get current performance snapshot
     */
    getCurrentSnapshot(): Promise<PerformanceSnapshot>;
    /**
     * Generate comprehensive performance report
     */
    generateReport(projectId: string, options?: {
        period?: {
            start: Date;
            end: Date;
        };
        includeTrends?: boolean;
        includeComparisons?: boolean;
        includeRecommendations?: boolean;
    }): Promise<PerformanceReportData>;
    /**
     * Get performance trends over time
     */
    getPerformanceTrends(period: {
        start: Date;
        end: Date;
    }): {
        performance: number[];
        memory: number[];
        responsiveness: number[];
        timestamps: Date[];
    };
    /**
     * Get performance alerts
     */
    getAlerts(options?: {
        severity?: 'info' | 'warning' | 'critical';
        limit?: number;
    }): Promise<PerformanceAlert[]>;
    /**
     * Set custom performance thresholds
     */
    setThresholds(thresholds: Record<string, number>): Promise<void>;
    /**
     * Export performance data
     */
    exportData(format: 'json' | 'csv' | 'xlsx', options?: {
        period?: {
            start: Date;
            end: Date;
        };
        includeSnapshots?: boolean;
        includeReports?: boolean;
    }): Promise<string>;
    private setupRealTimeCollection;
    private getDefaultAlertRules;
    private calculatePerformanceScore;
    private calculateTrends;
    private calculateComparisons;
    private generateInsights;
    private cleanupOldSnapshots;
    /**
     * Get service status
     */
    getStatus(): {
        initialized: boolean;
        monitoring: boolean;
        snapshots: number;
        reports: number;
    };
    /**
     * Get configuration
     */
    getConfig(): PerformanceConfig$1;
    /**
     * Update configuration
     */
    updateConfig(updates: Partial<PerformanceConfig$1>): void;
    /**
     * Cleanup resources
     */
    cleanup(): Promise<void>;
}

/**
 * Enterprise-Grade CI/CD Integration Service
 *
 * Provides comprehensive CI/CD integration for GitHub Actions, GitLab CI, and Jenkins
 * with enterprise-grade features including automated testing, deployment, and monitoring.
 *
 * @author React Responsive Easy CLI
 * @version 2.0.0
 */

interface CICDPlatform {
    name: 'github' | 'gitlab' | 'jenkins';
    displayName: string;
    supportedFeatures: CICDFeature[];
    configuration: CICDConfiguration;
}
interface CICDFeature {
    id: string;
    name: string;
    description: string;
    enabled: boolean;
    configuration?: Record<string, any>;
}
interface CICDConfiguration {
    platform: CICDPlatform['name'];
    repository: string;
    branch: string;
    environment: 'development' | 'staging' | 'production';
    secrets: Record<string, string>;
    variables: Record<string, string>;
    notifications: NotificationConfig$2;
    security: SecurityConfig$2;
    monitoring: MonitoringConfig$1;
}
interface NotificationConfig$2 {
    enabled: boolean;
    channels: NotificationChannel$3[];
    events: NotificationEvent$1[];
    escalation: EscalationPolicy$2;
}
interface NotificationChannel$3 {
    type: 'email' | 'slack' | 'teams' | 'webhook';
    endpoint: string;
    enabled: boolean;
    filters: string[];
}
interface NotificationEvent$1 {
    type: 'build_start' | 'build_success' | 'build_failure' | 'deployment' | 'security_scan';
    enabled: boolean;
    channels: string[];
}
interface EscalationPolicy$2 {
    enabled: boolean;
    levels: EscalationLevel$2[];
    timeout: number;
}
interface EscalationLevel$2 {
    level: number;
    condition: string;
    action: string;
    recipients: string[];
}
interface SecurityConfig$2 {
    enabled: boolean;
    scanning: SecurityScanning;
    compliance: ComplianceConfig$3;
    secrets: SecretsManagement;
}
interface SecurityScanning {
    code: boolean;
    dependencies: boolean;
    containers: boolean;
    infrastructure: boolean;
    schedule: string;
}
interface ComplianceConfig$3 {
    standards: string[];
    policies: CompliancePolicy$1[];
    reporting: boolean;
}
interface CompliancePolicy$1 {
    id: string;
    name: string;
    description: string;
    severity: 'low' | 'medium' | 'high' | 'critical';
    enabled: boolean;
}
interface SecretsManagement {
    provider: 'github' | 'gitlab' | 'vault' | 'aws-secrets';
    rotation: boolean;
    audit: boolean;
    encryption: boolean;
}
interface MonitoringConfig$1 {
    enabled: boolean;
    metrics: MetricsConfig$1;
    alerts: AlertConfig;
    dashboards: DashboardConfig$1;
}
interface MetricsConfig$1 {
    performance: boolean;
    security: boolean;
    quality: boolean;
    deployment: boolean;
    custom: string[];
}
interface AlertConfig {
    enabled: boolean;
    rules: AlertRule$1[];
    channels: string[];
    escalation: boolean;
}
interface AlertRule$1 {
    id: string;
    name: string;
    condition: string;
    threshold: number;
    severity: 'info' | 'warning' | 'error' | 'critical';
    enabled: boolean;
}
interface DashboardConfig$1 {
    enabled: boolean;
    provider: 'grafana' | 'datadog' | 'newrelic' | 'custom';
    url: string;
    refresh: number;
}
interface CICDWorkflow {
    id: string;
    name: string;
    platform: CICDPlatform['name'];
    triggers: WorkflowTrigger[];
    jobs: WorkflowJob[];
    environment: string;
    secrets: string[];
    variables: Record<string, string>;
    notifications: NotificationConfig$2;
    security: SecurityConfig$2;
    monitoring: MonitoringConfig$1;
    metadata: WorkflowMetadata;
}
interface WorkflowTrigger {
    type: 'push' | 'pull_request' | 'schedule' | 'manual' | 'webhook';
    condition: string;
    enabled: boolean;
}
interface WorkflowJob {
    id: string;
    name: string;
    type: 'test' | 'build' | 'deploy' | 'security' | 'quality' | 'custom';
    steps: WorkflowStep[];
    dependencies: string[];
    environment: string;
    timeout: number;
    retry: number;
    parallel: boolean;
}
interface WorkflowStep {
    id: string;
    name: string;
    type: 'script' | 'action' | 'docker' | 'cache' | 'artifacts';
    command?: string;
    action?: string;
    image?: string;
    environment: Record<string, string>;
    timeout: number;
    retry: number;
    condition: string;
}
interface WorkflowMetadata {
    version: string;
    author: string;
    description: string;
    tags: string[];
    documentation: string;
    lastModified: Date;
    created: Date;
}
interface CICDStatus {
    id: string;
    workflow: string;
    status: 'pending' | 'running' | 'success' | 'failure' | 'cancelled';
    startTime: Date;
    endTime?: Date;
    duration?: number;
    logs: string[];
    artifacts: string[];
    metrics: Record<string, any>;
    errors: string[];
    warnings: string[];
}
interface CICDReport {
    id: string;
    workflow: string;
    timestamp: Date;
    summary: ReportSummary;
    details: ReportDetails;
    recommendations: string[];
    nextSteps: string[];
}
interface ReportSummary {
    totalJobs: number;
    successfulJobs: number;
    failedJobs: number;
    duration: number;
    status: 'success' | 'failure' | 'partial';
    score: number;
}
interface ReportDetails {
    jobs: JobReport[];
    security: SecurityReport;
    quality: QualityReport;
    performance: PerformanceReport;
    deployment: DeploymentReport;
}
interface JobReport {
    id: string;
    name: string;
    status: string;
    duration: number;
    logs: string[];
    artifacts: string[];
    metrics: Record<string, any>;
}
interface SecurityReport {
    vulnerabilities: number;
    critical: number;
    high: number;
    medium: number;
    low: number;
    fixed: number;
    details: SecurityVulnerability[];
}
interface SecurityVulnerability {
    id: string;
    severity: string;
    package: string;
    version: string;
    description: string;
    fix: string;
    references: string[];
}
interface QualityReport {
    score: number;
    coverage: number;
    complexity: number;
    maintainability: number;
    reliability: number;
    security: number;
    issues: QualityIssue[];
}
interface QualityIssue {
    id: string;
    type: string;
    severity: string;
    file: string;
    line: number;
    message: string;
    rule: string;
}
interface PerformanceReport {
    score: number;
    metrics: PerformanceMetrics;
    recommendations: string[];
    bottlenecks: string[];
}
interface PerformanceMetrics {
    buildTime: number;
    testTime: number;
    deployTime: number;
    bundleSize: number;
    memoryUsage: number;
    cpuUsage: number;
}
interface DeploymentReport {
    environment: string;
    status: string;
    duration: number;
    rollback: boolean;
    healthCheck: boolean;
    monitoring: boolean;
    details: DeploymentDetail[];
}
interface DeploymentDetail {
    service: string;
    version: string;
    status: string;
    health: string;
    metrics: Record<string, any>;
}
interface CICDIntegration {
    platform: CICDPlatform['name'];
    client: any;
    authenticated: boolean;
    permissions: string[];
    rateLimit: RateLimit;
}
interface RateLimit {
    limit: number;
    remaining: number;
    reset: Date;
    retryAfter?: number;
}
declare class CICDService extends EventEmitter {
    private integrations;
    private workflows;
    private statuses;
    private reports;
    private config;
    private templates;
    constructor(config: CICDConfiguration);
    /**
     * Initialize CI/CD templates for different platforms
     */
    private initializeTemplates;
    /**
     * Setup CI/CD integration for a specific platform
     */
    setupIntegration(platform: CICDPlatform['name'], options?: any): Promise<CICDIntegration>;
    /**
     * Setup GitHub Actions integration
     */
    private setupGitHubIntegration;
    /**
     * Setup GitLab CI integration
     */
    private setupGitLabIntegration;
    /**
     * Setup Jenkins integration
     */
    private setupJenkinsIntegration;
    /**
     * Create GitHub client
     */
    private createGitHubClient;
    /**
     * Create GitLab client
     */
    private createGitLabClient;
    /**
     * Create Jenkins client
     */
    private createJenkinsClient;
    /**
     * Validate GitHub permissions
     */
    private validateGitHubPermissions;
    /**
     * Validate GitLab permissions
     */
    private validateGitLabPermissions;
    /**
     * Validate Jenkins permissions
     */
    private validateJenkinsPermissions;
    /**
     * Get GitHub rate limit
     */
    private getGitHubRateLimit;
    /**
     * Get GitLab rate limit
     */
    private getGitLabRateLimit;
    /**
     * Create a new CI/CD workflow
     */
    createWorkflow(template: string, customizations?: any): Promise<CICDWorkflow>;
    /**
     * Deploy workflow to CI/CD platform
     */
    deployWorkflow(workflowId: string, platform: CICDPlatform['name']): Promise<void>;
    /**
     * Deploy GitHub Actions workflow
     */
    private deployGitHubWorkflow;
    /**
     * Deploy GitLab CI workflow
     */
    private deployGitLabWorkflow;
    /**
     * Deploy Jenkins workflow
     */
    private deployJenkinsWorkflow;
    /**
     * Generate GitHub Actions workflow content
     */
    private generateGitHubWorkflow;
    /**
     * Generate GitLab CI workflow content
     */
    private generateGitLabWorkflow;
    /**
     * Generate Jenkins workflow content
     */
    private generateJenkinsWorkflow;
    /**
     * Write workflow file to filesystem
     */
    private writeWorkflowFile;
    /**
     * Validate CI/CD configuration
     */
    validateConfiguration(): Promise<{
        valid: boolean;
        errors: string[];
        warnings: string[];
    }>;
    /**
     * Get CI/CD status for a workflow
     */
    getWorkflowStatus(workflowId: string): Promise<CICDStatus | null>;
    /**
     * Get CI/CD report for a workflow
     */
    getWorkflowReport(workflowId: string): Promise<CICDReport | null>;
    /**
     * List all available templates
     */
    getAvailableTemplates(): string[];
    /**
     * Get template details
     */
    getTemplateDetails(templateId: string): any;
    /**
     * Get all integrations
     */
    getIntegrations(): CICDIntegration[];
    /**
     * Get all workflows
     */
    getWorkflows(): CICDWorkflow[];
    /**
     * Cleanup resources
     */
    cleanup(): Promise<void>;
}

/**
 * Enterprise-Grade Team Management Service
 *
 * Provides comprehensive team management with user roles, permissions,
 * shared workspaces, and collaborative configuration management.
 *
 * @author React Responsive Easy CLI
 * @version 2.0.0
 */

interface Team {
    id: string;
    name: string;
    description: string;
    slug: string;
    avatar?: string;
    settings: TeamSettings;
    members: TeamMember[];
    workspaces: Workspace[];
    invitations: TeamInvitation[];
    createdAt: Date;
    updatedAt: Date;
    createdBy: string;
    metadata: TeamMetadata;
}
interface TeamSettings {
    visibility: 'public' | 'private' | 'restricted';
    allowInvites: boolean;
    requireApproval: boolean;
    defaultRole: UserRole;
    maxMembers: number;
    billing: BillingSettings;
    security: TeamSecuritySettings;
    notifications: TeamNotificationSettings;
    integrations: TeamIntegrationSettings;
}
interface BillingSettings {
    plan: 'free' | 'pro' | 'enterprise';
    usage: UsageMetrics;
    limits: UsageLimits;
    billingEmail: string;
    paymentMethod?: string;
}
interface UsageMetrics {
    members: number;
    workspaces: number;
    projects: number;
    storage: number;
    apiCalls: number;
    lastUpdated: Date;
}
interface UsageLimits {
    maxMembers: number;
    maxWorkspaces: number;
    maxProjects: number;
    maxStorage: number;
    maxApiCalls: number;
}
interface TeamSecuritySettings {
    twoFactorRequired: boolean;
    sessionTimeout: number;
    ipWhitelist: string[];
    allowedDomains: string[];
    auditLogging: boolean;
    encryption: boolean;
}
interface TeamNotificationSettings {
    email: boolean;
    slack: boolean;
    teams: boolean;
    webhook: boolean;
    channels: NotificationChannel$2[];
}
interface TeamIntegrationSettings {
    github: boolean;
    gitlab: boolean;
    jenkins: boolean;
    jira: boolean;
    confluence: boolean;
    custom: CustomIntegration[];
}
interface CustomIntegration {
    id: string;
    name: string;
    type: string;
    config: Record<string, any>;
    enabled: boolean;
}
interface TeamMember {
    id: string;
    userId: string;
    email: string;
    name: string;
    avatar?: string;
    role: UserRole;
    permissions: Permission[];
    status: 'active' | 'inactive' | 'pending' | 'suspended';
    joinedAt: Date;
    lastActiveAt: Date;
    invitedBy: string;
    metadata: MemberMetadata;
}
interface UserRole {
    id: string;
    name: string;
    description: string;
    level: number;
    permissions: Permission[];
    isDefault: boolean;
    isSystem: boolean;
    createdAt: Date;
    updatedAt: Date;
}
interface Permission {
    id: string;
    name: string;
    description: string;
    resource: string;
    action: string;
    conditions?: PermissionCondition$2[];
}
interface PermissionCondition$2 {
    field: string;
    operator: 'equals' | 'not_equals' | 'contains' | 'starts_with' | 'ends_with';
    value: any;
}
interface MemberMetadata {
    department?: string;
    title?: string;
    location?: string;
    timezone?: string;
    preferences: UserPreferences;
    skills: string[];
    experience: string;
}
interface UserPreferences {
    theme: 'light' | 'dark' | 'auto';
    language: string;
    notifications: NotificationPreferences$1;
    dashboard: DashboardPreferences;
}
interface NotificationPreferences$1 {
    email: boolean;
    push: boolean;
    inApp: boolean;
    frequency: 'immediate' | 'daily' | 'weekly';
    types: string[];
}
interface DashboardPreferences {
    layout: string;
    widgets: string[];
    refreshRate: number;
}
interface Workspace {
    id: string;
    name: string;
    description: string;
    slug: string;
    teamId: string;
    type: 'project' | 'department' | 'client' | 'custom';
    settings: WorkspaceSettings;
    members: WorkspaceMember[];
    projects: Project[];
    resources: WorkspaceResource[];
    createdAt: Date;
    updatedAt: Date;
    createdBy: string;
    metadata: WorkspaceMetadata;
}
interface WorkspaceSettings {
    visibility: 'public' | 'private' | 'restricted';
    allowMemberInvites: boolean;
    requireApproval: boolean;
    defaultRole: UserRole;
    maxMembers: number;
    maxProjects: number;
    storage: StorageSettings;
    security: WorkspaceSecuritySettings;
    notifications: WorkspaceNotificationSettings;
}
interface StorageSettings {
    limit: number;
    used: number;
    provider: 'local' | 'aws' | 'azure' | 'gcp';
    encryption: boolean;
    backup: boolean;
    retention: number;
}
interface WorkspaceSecuritySettings {
    accessControl: boolean;
    auditLogging: boolean;
    dataEncryption: boolean;
    ipRestrictions: string[];
    sessionTimeout: number;
}
interface WorkspaceNotificationSettings {
    enabled: boolean;
    channels: NotificationChannel$2[];
    events: NotificationEvent[];
}
interface WorkspaceMember {
    id: string;
    userId: string;
    email: string;
    name: string;
    role: UserRole;
    permissions: Permission[];
    status: 'active' | 'inactive' | 'pending';
    joinedAt: Date;
    lastActiveAt: Date;
    invitedBy: string;
}
interface Project {
    id: string;
    name: string;
    description: string;
    workspaceId: string;
    type: 'responsive' | 'component' | 'library' | 'template';
    status: 'active' | 'archived' | 'draft';
    settings: ProjectSettings;
    members: ProjectMember[];
    configurations: ProjectConfiguration[];
    resources: ProjectResource[];
    createdAt: Date;
    updatedAt: Date;
    createdBy: string;
    metadata: ProjectMetadata;
}
interface ProjectSettings {
    visibility: 'public' | 'private' | 'restricted';
    allowCollaboration: boolean;
    requireReview: boolean;
    autoSave: boolean;
    versioning: boolean;
    backup: boolean;
    security: ProjectSecuritySettings;
}
interface ProjectSecuritySettings {
    accessControl: boolean;
    auditLogging: boolean;
    dataEncryption: boolean;
    ipRestrictions: string[];
    sessionTimeout: number;
}
interface ProjectMember {
    id: string;
    userId: string;
    email: string;
    name: string;
    role: UserRole;
    permissions: Permission[];
    status: 'active' | 'inactive' | 'pending';
    joinedAt: Date;
    lastActiveAt: Date;
    invitedBy: string;
}
interface ProjectConfiguration {
    id: string;
    name: string;
    description: string;
    type: 'responsive' | 'theme' | 'component' | 'layout';
    settings: Record<string, any>;
    version: string;
    isDefault: boolean;
    isShared: boolean;
    createdAt: Date;
    updatedAt: Date;
    createdBy: string;
    collaborators: string[];
}
interface ProjectResource {
    id: string;
    name: string;
    type: 'file' | 'image' | 'document' | 'code' | 'data';
    path: string;
    size: number;
    mimeType: string;
    metadata: Record<string, any>;
    createdAt: Date;
    updatedAt: Date;
    createdBy: string;
    permissions: Permission[];
}
interface WorkspaceResource {
    id: string;
    name: string;
    type: 'template' | 'library' | 'documentation' | 'asset';
    path: string;
    size: number;
    mimeType: string;
    metadata: Record<string, any>;
    createdAt: Date;
    updatedAt: Date;
    createdBy: string;
    permissions: Permission[];
}
interface TeamInvitation {
    id: string;
    email: string;
    role: UserRole;
    workspaceIds: string[];
    invitedBy: string;
    status: 'pending' | 'accepted' | 'declined' | 'expired';
    expiresAt: Date;
    createdAt: Date;
    token: string;
    metadata: InvitationMetadata;
}
interface InvitationMetadata {
    message?: string;
    source: 'email' | 'link' | 'admin';
    ipAddress?: string;
    userAgent?: string;
}
interface TeamMetadata {
    industry?: string;
    size?: string;
    location?: string;
    website?: string;
    description?: string;
    tags: string[];
    customFields: Record<string, any>;
}
interface WorkspaceMetadata {
    category?: string;
    client?: string;
    department?: string;
    location?: string;
    description?: string;
    tags: string[];
    customFields: Record<string, any>;
}
interface ProjectMetadata {
    category?: string;
    client?: string;
    department?: string;
    location?: string;
    description?: string;
    tags: string[];
    customFields: Record<string, any>;
}
interface NotificationChannel$2 {
    id: string;
    type: 'email' | 'slack' | 'teams' | 'webhook' | 'in_app';
    name: string;
    config: Record<string, any>;
    enabled: boolean;
    verified: boolean;
}
interface NotificationEvent {
    id: string;
    type: string;
    name: string;
    description: string;
    enabled: boolean;
    channels: string[];
    conditions: NotificationCondition[];
}
interface NotificationCondition {
    field: string;
    operator: 'equals' | 'not_equals' | 'contains' | 'greater_than' | 'less_than';
    value: any;
}
interface TeamAnalytics {
    teamId: string;
    period: 'day' | 'week' | 'month' | 'quarter' | 'year';
    metrics: TeamMetrics;
    trends: TeamTrends;
    insights: TeamInsight[];
    recommendations: string[];
    generatedAt: Date;
}
interface TeamMetrics {
    members: {
        total: number;
        active: number;
        new: number;
        churn: number;
    };
    workspaces: {
        total: number;
        active: number;
        new: number;
    };
    projects: {
        total: number;
        active: number;
        completed: number;
        new: number;
    };
    activity: {
        logins: number;
        actions: number;
        collaborations: number;
        apiCalls: number;
    };
    performance: {
        avgResponseTime: number;
        uptime: number;
        errorRate: number;
        satisfaction: number;
    };
}
interface TeamTrends {
    members: TrendData$2[];
    workspaces: TrendData$2[];
    projects: TrendData$2[];
    activity: TrendData$2[];
    performance: TrendData$2[];
}
interface TrendData$2 {
    date: Date;
    value: number;
    change: number;
    changePercent: number;
}
interface TeamInsight {
    id: string;
    type: 'growth' | 'performance' | 'engagement' | 'security' | 'usage';
    title: string;
    description: string;
    severity: 'info' | 'warning' | 'error' | 'critical';
    impact: 'low' | 'medium' | 'high';
    actionable: boolean;
    recommendations: string[];
    data: Record<string, any>;
}
declare class TeamService extends EventEmitter {
    private teams;
    private users;
    private roles;
    private invitations;
    private analytics;
    private config;
    constructor(config?: any);
    /**
     * Initialize default user roles
     */
    private initializeDefaultRoles;
    /**
     * Create a new team
     */
    createTeam(data: {
        name: string;
        description: string;
        createdBy: string;
        settings?: Partial<TeamSettings>;
    }): Promise<Team>;
    /**
     * Create a new workspace
     */
    createWorkspace(teamId: string, data: {
        name: string;
        description: string;
        type: Workspace['type'];
        createdBy: string;
        settings?: Partial<WorkspaceSettings>;
    }): Promise<Workspace>;
    /**
     * Create a new project
     */
    createProject(workspaceId: string, data: {
        name: string;
        description: string;
        type: Project['type'];
        createdBy: string;
        settings?: Partial<ProjectSettings>;
    }): Promise<Project>;
    /**
     * Invite user to team
     */
    inviteUser(teamId: string, data: {
        email: string;
        role: string;
        workspaceIds: string[];
        invitedBy: string;
        message?: string;
    }): Promise<TeamInvitation>;
    /**
     * Accept team invitation
     */
    acceptInvitation(invitationId: string, userId: string): Promise<TeamMember>;
    /**
     * Get team analytics
     */
    getTeamAnalytics(teamId: string, period?: TeamAnalytics['period']): Promise<TeamAnalytics>;
    /**
     * Helper methods
     */
    private generateSlug;
    private generateInvitationToken;
    private findWorkspaceById;
    private getAllPermissions;
    private getAdminPermissions;
    private getDeveloperPermissions;
    private getDesignerPermissions;
    private getViewerPermissions;
    /**
     * Get all teams
     */
    getTeams(): Team[];
    /**
     * Get team by ID
     */
    getTeam(teamId: string): Team | null;
    /**
     * Get all roles
     */
    getRoles(): UserRole[];
    /**
     * Get role by ID
     */
    getRole(roleId: string): UserRole | null;
    /**
     * Cleanup resources
     */
    cleanup(): Promise<void>;
}

/**
 * Enterprise-Grade Collaboration Service
 *
 * Provides real-time collaborative configuration management,
 * conflict resolution, and team synchronization.
 *
 * @author React Responsive Easy CLI
 * @version 2.0.0
 */

interface CollaborationSession {
    id: string;
    projectId: string;
    workspaceId: string;
    teamId: string;
    participants: CollaborationParticipant[];
    status: 'active' | 'paused' | 'ended';
    startedAt: Date;
    lastActivityAt: Date;
    endedAt?: Date;
    metadata: CollaborationMetadata;
}
interface CollaborationParticipant {
    id: string;
    userId: string;
    name: string;
    email: string;
    role: string;
    status: 'online' | 'away' | 'offline';
    joinedAt: Date;
    lastSeenAt: Date;
    cursor?: CursorPosition;
    selections: SelectionRange[];
    permissions: CollaborationPermission[];
}
interface CursorPosition {
    file: string;
    line: number;
    column: number;
    timestamp: Date;
}
interface SelectionRange {
    file: string;
    startLine: number;
    startColumn: number;
    endLine: number;
    endColumn: number;
    timestamp: Date;
}
interface CollaborationPermission {
    resource: string;
    action: string;
    granted: boolean;
    conditions?: PermissionCondition$1[];
}
interface PermissionCondition$1 {
    field: string;
    operator: 'equals' | 'not_equals' | 'contains' | 'starts_with' | 'ends_with';
    value: any;
}
interface CollaborationMetadata {
    title?: string;
    description?: string;
    tags: string[];
    settings: CollaborationSettings;
    customFields: Record<string, any>;
}
interface CollaborationSettings {
    allowRealTimeSync: boolean;
    conflictResolution: 'manual' | 'automatic' | 'last-writer-wins';
    autoSave: boolean;
    saveInterval: number;
    maxParticipants: number;
    requireApproval: boolean;
    enableComments: boolean;
    enableSuggestions: boolean;
    enableVersioning: boolean;
    enableAuditLog: boolean;
}
interface ConfigurationChange {
    id: string;
    sessionId: string;
    participantId: string;
    file: string;
    type: 'insert' | 'delete' | 'replace' | 'move';
    position: ChangePosition;
    content: string;
    timestamp: Date;
    version: number;
    hash: string;
    metadata: ChangeMetadata;
}
interface ChangePosition {
    startLine: number;
    startColumn: number;
    endLine: number;
    endColumn: number;
}
interface ChangeMetadata {
    description?: string;
    tags: string[];
    priority: 'low' | 'medium' | 'high' | 'critical';
    requiresReview: boolean;
    approvedBy?: string;
    approvedAt?: Date;
}
interface CollaborationComment {
    id: string;
    sessionId: string;
    participantId: string;
    file: string;
    position: ChangePosition;
    content: string;
    type: 'comment' | 'suggestion' | 'question' | 'issue';
    status: 'open' | 'resolved' | 'closed';
    createdAt: Date;
    updatedAt: Date;
    replies: CommentReply[];
    mentions: string[];
    tags: string[];
}
interface CommentReply {
    id: string;
    participantId: string;
    content: string;
    createdAt: Date;
    updatedAt: Date;
    mentions: string[];
}
interface CollaborationSuggestion {
    id: string;
    sessionId: string;
    participantId: string;
    file: string;
    position: ChangePosition;
    originalContent: string;
    suggestedContent: string;
    type: 'improvement' | 'optimization' | 'bug-fix' | 'enhancement';
    status: 'pending' | 'accepted' | 'rejected' | 'modified';
    createdAt: Date;
    updatedAt: Date;
    acceptedBy?: string;
    acceptedAt?: Date;
    rejectedBy?: string;
    rejectedAt?: Date;
    reason?: string;
}
interface CollaborationAnalytics {
    sessionId: string;
    period: 'session' | 'day' | 'week' | 'month';
    metrics: CollaborationMetrics;
    insights: CollaborationInsight[];
    recommendations: string[];
    generatedAt: Date;
}
interface CollaborationMetrics {
    participants: {
        total: number;
        active: number;
        average: number;
        peak: number;
    };
    activity: {
        totalEvents: number;
        edits: number;
        comments: number;
        suggestions: number;
        conflicts: number;
        resolutions: number;
    };
    productivity: {
        linesAdded: number;
        linesDeleted: number;
        linesModified: number;
        filesChanged: number;
        timeSpent: number;
    };
    quality: {
        conflictsResolved: number;
        suggestionsAccepted: number;
        commentsResolved: number;
        reviewTime: number;
    };
}
interface CollaborationInsight {
    id: string;
    type: 'productivity' | 'collaboration' | 'quality' | 'engagement';
    title: string;
    description: string;
    severity: 'info' | 'warning' | 'error' | 'critical';
    impact: 'low' | 'medium' | 'high';
    actionable: boolean;
    recommendations: string[];
    data: Record<string, any>;
}
declare class CollaborationService extends EventEmitter {
    private sessions;
    private events;
    private changes;
    private comments;
    private suggestions;
    private versions;
    private conflicts;
    private analytics;
    constructor();
    /**
     * Start a new collaboration session
     */
    startSession(data: {
        projectId: string;
        workspaceId: string;
        teamId: string;
        participantId: string;
        participantName: string;
        participantEmail: string;
        participantRole: string;
        settings?: Partial<CollaborationSettings>;
    }): Promise<CollaborationSession>;
    /**
     * Join an existing collaboration session
     */
    joinSession(sessionId: string, data: {
        participantId: string;
        participantName: string;
        participantEmail: string;
        participantRole: string;
    }): Promise<CollaborationSession>;
    /**
     * Leave a collaboration session
     */
    leaveSession(sessionId: string, participantId: string): Promise<void>;
    /**
     * End a collaboration session
     */
    endSession(sessionId: string): Promise<void>;
    /**
     * Apply configuration changes
     */
    applyChanges(sessionId: string, changes: ConfigurationChange[]): Promise<void>;
    /**
     * Add a comment
     */
    addComment(sessionId: string, data: {
        participantId: string;
        file: string;
        position: ChangePosition;
        content: string;
        type: CollaborationComment['type'];
        mentions?: string[];
        tags?: string[];
    }): Promise<CollaborationComment>;
    /**
     * Add a suggestion
     */
    addSuggestion(sessionId: string, data: {
        participantId: string;
        file: string;
        position: ChangePosition;
        originalContent: string;
        suggestedContent: string;
        type: CollaborationSuggestion['type'];
    }): Promise<CollaborationSuggestion>;
    /**
     * Update cursor position
     */
    updateCursor(sessionId: string, participantId: string, cursor: CursorPosition): Promise<void>;
    /**
     * Update selection range
     */
    updateSelection(sessionId: string, participantId: string, selection: SelectionRange): Promise<void>;
    /**
     * Get session analytics
     */
    getSessionAnalytics(sessionId: string): Promise<CollaborationAnalytics>;
    /**
     * Helper methods
     */
    private emitEvent;
    private detectConflicts;
    private isOverlapping;
    private resolveConflicts;
    private calculateChangeHash;
    private getDefaultPermissions;
    /**
     * Get session by ID
     */
    getSession(sessionId: string): CollaborationSession | null;
    /**
     * Get all sessions
     */
    getSessions(): CollaborationSession[];
    /**
     * Cleanup resources
     */
    cleanup(): Promise<void>;
}

/**
 * Enterprise-Grade Security Service
 *
 * Provides comprehensive security management including OAuth integration,
 * SSO support, encryption, audit logging, and threat detection.
 *
 * @author React Responsive Easy CLI
 * @version 2.0.0
 */

interface SecurityConfig$1 {
    encryption: EncryptionConfig$1;
    authentication: AuthenticationConfig$1;
    authorization: AuthorizationConfig$1;
    audit: AuditConfig$2;
    compliance: ComplianceConfig$2;
    threatDetection: ThreatDetectionConfig$1;
    keyManagement: KeyManagementConfig;
}
interface EncryptionConfig$1 {
    enabled: boolean;
    algorithm: 'aes-256-gcm' | 'aes-256-cbc' | 'chacha20-poly1305';
    keyDerivation: 'pbkdf2' | 'scrypt' | 'argon2';
    keyRotation: boolean;
    rotationInterval: number;
    saltLength: number;
    ivLength: number;
}
interface AuthenticationConfig$1 {
    providers: AuthProvider[];
    mfa: MFAConfig$1;
    session: SessionConfig$1;
    password: PasswordConfig;
    lockout: LockoutConfig$1;
}
interface AuthProvider {
    id: string;
    name: string;
    type: 'oauth' | 'saml' | 'ldap' | 'local';
    enabled: boolean;
    config: OAuthConfig | SAMLConfig$1 | LDAPConfig$1 | LocalConfig;
    scopes: string[];
    claims: string[];
    mapping: ClaimMapping;
}
interface OAuthConfig {
    clientId: string;
    clientSecret: string;
    authorizationUrl: string;
    tokenUrl: string;
    userInfoUrl: string;
    redirectUri: string;
    responseType: 'code' | 'token';
    grantType: 'authorization_code' | 'client_credentials';
}
interface SAMLConfig$1 {
    entityId: string;
    ssoUrl: string;
    sloUrl: string;
    certificate: string;
    privateKey: string;
    nameIdFormat: string;
    assertionConsumerServiceUrl: string;
    audience: string;
}
interface LDAPConfig$1 {
    server: string;
    port: number;
    baseDN: string;
    bindDN: string;
    bindPassword: string;
    userSearchFilter: string;
    groupSearchFilter: string;
    ssl: boolean;
    tls: boolean;
}
interface LocalConfig {
    allowRegistration: boolean;
    requireEmailVerification: boolean;
    passwordPolicy: any;
}
interface ClaimMapping {
    userId: string;
    email: string;
    name: string;
    firstName: string;
    lastName: string;
    groups: string;
    roles: string;
    custom: Record<string, string>;
}
interface MFAConfig$1 {
    enabled: