@re-shell/cli/dist/core/environment-validator.d.ts

Full-stack development platform uniting microservices and microfrontends. Build complete applications with .NET (ASP.NET Core Web API, Minimal API), Java (Spring Boot, Quarkus, Micronaut, Vert.x), Rust (Actix-Web, Warp, Rocket, Axum), Python (FastAPI, Dja

import { EventEmitter } from 'events';
export interface EnvironmentRequirement {
    name: string;
    type: 'runtime' | 'tool' | 'package' | 'system' | 'network';
    required: boolean;
    minVersion?: string;
    maxVersion?: string;
    checkCommand?: string;
    installCommand?: string;
    installUrl?: string;
    validator?: () => Promise<boolean>;
    autoInstall?: boolean;
    platforms?: NodeJS.Platform[];
}
export interface ValidationResult {
    valid: boolean;
    issues: ValidationIssue[];
    warnings: ValidationWarning[];
    systemInfo: SystemInfo;
    recommendations: string[];
    autoFixAvailable: boolean;
}
export interface ValidationIssue {
    requirement: string;
    type: 'missing' | 'version' | 'permission' | 'configuration' | 'network';
    severity: 'error' | 'warning';
    message: string;
    fixCommand?: string;
    fixUrl?: string;
    autoFixable: boolean;
}
export interface ValidationWarning {
    message: string;
    type: 'performance' | 'compatibility' | 'security' | 'deprecated';
    recommendation?: string;
}
export interface SystemInfo {
    platform: NodeJS.Platform;
    arch: string;
    nodeVersion: string;
    npmVersion: string;
    osVersion: string;
    shell: string;
    memory: {
        total: number;
        free: number;
        used: number;
    };
    disk: {
        total: number;
        free: number;
        used: number;
    };
    cpu: {
        model: string;
        cores: number;
        speed: number;
    };
    network: {
        online: boolean;
        proxy?: string;
        vpn?: boolean;
    };
}
export interface SetupOptions {
    autoFix: boolean;
    interactive: boolean;
    verbose: boolean;
    skipOptional: boolean;
    parallel: boolean;
    timeout: number;
    retryAttempts: number;
}
export interface SetupResult {
    success: boolean;
    fixed: string[];
    failed: string[];
    skipped: string[];
    warnings: string[];
    duration: number;
    recoveryActions?: RecoveryAction[];
}
export interface RecoveryAction {
    name: string;
    command: string;
    description: string;
    priority: 'high' | 'medium' | 'low';
    automated: boolean;
}
export declare class EnvironmentValidator extends EventEmitter {
    private requirements;
    private systemInfo?;
    private validationCache;
    private readonly cacheTimeout;
    private readonly defaultOptions;
    constructor();
    private initializeRequirements;
    addRequirement(requirement: EnvironmentRequirement): void;
    removeRequirement(name: string): boolean;
    validate(options?: Partial<SetupOptions>): Promise<ValidationResult>;
    private validateRequirement;
    private checkCommand;
    private extractVersion;
    private validateSequentially;
    setup(options?: Partial<SetupOptions>): Promise<SetupResult>;
    private attemptFix;
    private gatherSystemInfo;
    private getMemoryInfo;
    private getDiskInfo;
    private getNetworkInfo;
    private getNpmVersion;
    private checkInternetConnection;
    private detectVPN;
    private analyzeSystemHealth;
    private generateRecommendations;
    private delay;
    generateReport(validation?: ValidationResult): Promise<string>;
    private formatBytes;
    getRequirements(): EnvironmentRequirement[];
    getRequirement(name: string): EnvironmentRequirement | undefined;
    clearCache(): void;
    exportRequirements(): string;
    importRequirements(json: string): void;
}
export declare function getEnvironmentValidator(): EnvironmentValidator;
export declare function validateEnvironment(options?: Partial<SetupOptions>): Promise<ValidationResult>;
export declare function setupEnvironment(options?: Partial<SetupOptions>): Promise<SetupResult>;