@re-shell/cli/dist/core/resource-cleanup.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 ResourceHandle {
    id: string;
    type: ResourceType;
    resource: any;
    metadata: {
        created: Date;
        lastAccessed: Date;
        size?: number;
        tags?: string[];
        priority: ResourcePriority;
    };
    cleanup: () => Promise<void> | void;
}
export declare enum ResourceType {
    FILE_HANDLE = "file_handle",
    STREAM = "stream",
    NETWORK_CONNECTION = "network_connection",
    CHILD_PROCESS = "child_process",
    TIMER = "timer",
    EVENT_LISTENER = "event_listener",
    TEMPORARY_FILE = "temporary_file",
    TEMPORARY_DIRECTORY = "temporary_directory",
    CACHE_ENTRY = "cache_entry",
    MEMORY_BUFFER = "memory_buffer",
    DATABASE_CONNECTION = "database_connection",
    CUSTOM = "custom"
}
export declare enum ResourcePriority {
    LOW = 0,
    NORMAL = 1,
    HIGH = 2,
    CRITICAL = 3
}
export interface StateSnapshot {
    id: string;
    timestamp: Date;
    operation: string;
    state: any;
    resources: string[];
    checksum: string;
}
export interface RecoveryPlan {
    id: string;
    operation: string;
    steps: RecoveryStep[];
    rollbackSteps: RecoveryStep[];
    resources: string[];
    metadata: {
        created: Date;
        estimatedDuration: number;
        dependencies: string[];
    };
}
export interface RecoveryStep {
    id: string;
    type: 'cleanup' | 'restore' | 'recreate' | 'verify' | 'rollback';
    description: string;
    action: () => Promise<void>;
    rollback?: () => Promise<void>;
    timeout: number;
    critical: boolean;
}
export interface CleanupOptions {
    gracefulTimeout: number;
    forceTimeout: number;
    priority: ResourcePriority;
    preserveTypes: ResourceType[];
    dryRun: boolean;
}
export declare class ResourceManager extends EventEmitter {
    private resources;
    private stateSnapshots;
    private recoveryPlans;
    private activeOperations;
    private cleanupInProgress;
    private shutdownHooksRegistered;
    constructor();
    private registerShutdownHooks;
    registerResource<T>(type: ResourceType, resource: T, cleanup: () => Promise<void> | void, options?: {
        tags?: string[];
        priority?: ResourcePriority;
        size?: number;
    }): string;
    unregisterResource(id: string): boolean;
    cleanupResource(id: string, force?: boolean): Promise<boolean>;
    private gracefulCleanupResource;
    private forceCleanupResource;
    private performForceCleanup;
    private getTimeoutForPriority;
    cleanupByType(type: ResourceType, options?: Partial<CleanupOptions>): Promise<number>;
    cleanupByTags(tags: string[], options?: Partial<CleanupOptions>): Promise<number>;
    cleanupAll(options?: Partial<CleanupOptions>): Promise<number>;
    private performEmergencyCleanup;
    private performGracefulShutdown;
    createSnapshot(operation: string, state: any): string;
    restoreSnapshot(id: string): any;
    createRecoveryPlan(operation: string, steps: RecoveryStep[]): string;
    executeRecoveryPlan(id: string): Promise<void>;
    private executeRollback;
    private generateResourceId;
    private generateSnapshotId;
    private generateRecoveryPlanId;
    private calculateChecksum;
    private deepClone;
    private cleanupOldSnapshots;
    private withTimeout;
    getResourceCount(): number;
    getResourcesByType(type: ResourceType): ResourceHandle[];
    getResourcesByTags(tags: string[]): ResourceHandle[];
    getResourceStats(): {
        total: number;
        byType: Record<string, number>;
        byPriority: Record<string, number>;
        totalSize: number;
    };
    getSnapshots(): StateSnapshot[];
    getRecoveryPlans(): RecoveryPlan[];
}
export declare function createResourceManager(): ResourceManager;
export declare function getGlobalResourceManager(): ResourceManager;
export declare function setGlobalResourceManager(manager: ResourceManager): void;