import { EventEmitter } from 'events';
import { UniversalPackageManager } from '../core/rarn-core.js';
export interface Plugin {
    name: string;
    version: string;
    hooks?: PluginHooks;
    commands?: PluginCommand[];
    resolvers?: PackageResolver[];
    fetchers?: PackageFetcher[];
}
export interface PluginHooks {
    beforeInstall?: (packages: string[], context: PluginContext) => Promise<void>;
    afterInstall?: (installedPackages: Map<string, any>, context: PluginContext) => Promise<void>;
    beforeResolve?: (requirements: Record<string, string>, context: PluginContext) => Promise<void>;
    afterResolve?: (resolved: Map<string, any>, context: PluginContext) => Promise<void>;
    beforeFetch?: (packageInfo: any, context: PluginContext) => Promise<void>;
    afterFetch?: (packageData: Buffer, context: PluginContext) => Promise<Buffer>;
}
export interface PluginContext {
    upm: UniversalPackageManager;
    config: any;
    cwd: string;
    env: NodeJS.ProcessEnv;
}
export interface PluginCommand {
    name: string;
    description: string;
    handler: (args: string[], context: PluginContext) => Promise<void>;
}
export interface PackageResolver {
    name: string;
    canResolve: (packageSpec: string) => boolean;
    resolve: (packageSpec: string, context: PluginContext) => Promise<ResolvedPackage>;
}
export interface PackageFetcher {
    name: string;
    canFetch: (resolvedPackage: ResolvedPackage) => boolean;
    fetch: (resolvedPackage: ResolvedPackage, context: PluginContext) => Promise<FetchResult>;
}
export interface ResolvedPackage {
    name: string;
    version: string;
    source: string;
    checksum?: string;
    dependencies?: Record<string, string>;
}
export interface FetchResult {
    buffer: Buffer;
    checksum: string;
    extractMethod: 'tar' | 'zip' | 'none';
}
export declare class PluginManager extends EventEmitter {
    private plugins;
    private hooks;
    private commands;
    private resolvers;
    private fetchers;
    loadPlugin(pluginPath: string): Promise<void>;
    registerPlugin(plugin: Plugin): void;
    executeHook(hookName: string, ...args: any[]): Promise<void>;
    getCommand(name: string): PluginCommand | undefined;
    getResolver(packageSpec: string): PackageResolver | undefined;
    getFetcher(resolvedPackage: ResolvedPackage): PackageFetcher | undefined;
}
export interface Workspace {
    root: string;
    packages: WorkspacePackage[];
    dependencies: Map<string, string>;
    devDependencies: Map<string, string>;
}
export interface WorkspacePackage {
    name: string;
    path: string;
    version: string;
    dependencies?: Record<string, string>;
    devDependencies?: Record<string, string>;
    workspaceDependencies?: string[];
}
export declare class WorkspaceManager {
    private workspace;
    loadWorkspace(rootPath: string): Promise<Workspace>;
    private findPackages;
    private isPackage;
    private loadPackage;
    private buildDependencyGraph;
    installWorkspace(): Promise<void>;
    private topologicalSort;
    private linkWorkspaceDependencies;
}
export declare class BinaryPackageHandler {
    private platform;
    private arch;
    constructor();
    extractBinaryPackage(packageData: Buffer, targetPath: string, metadata: BinaryPackageMetadata): Promise<void>;
    private extractCondaPackage;
    private extractWheelPackage;
    private createActivationScripts;
    private relocateBinaries;
}
export interface BinaryPackageMetadata {
    format: 'conda' | 'wheel' | 'native';
    platform: string;
    arch: string;
    dependencies: string[];
    envVars?: Record<string, string>;
    relocatable: boolean;
}
export declare class NetworkManager {
    private maxRetries;
    private timeout;
    download(url: string, options?: DownloadOptions): Promise<Buffer>;
    private doDownload;
}
interface DownloadOptions {
    headers?: Record<string, string>;
    onProgress?: (received: number, total: number) => void;
}
export declare const GitResolverPlugin: Plugin;
export declare class ZeroInstallManager {
    private vendorPath;
    constructor(vendorPath?: string);
    vendorPackage(packageName: string, packageData: Buffer, metadata: any): Promise<void>;
    loadVendoredPackage(packageName: string): Promise<Buffer | null>;
}
export {};
//# sourceMappingURL=rarn-plugins.d.ts.map