import type { AppInstance, EdenConfig, ExecutionPrincipal, ProcessMetricsSnapshot, UserProfile } from "@edenapp/types";
import { AppChannelManager } from "../appbus/AppChannelManager";
import { ExecutionContext } from "../execution/ExecutionContext";
import { RuntimeContextRegistry } from "../execution/RuntimeContextRegistry";
import { CommandRegistry, EdenEmitter, IPCBridge } from "../ipc";
import { PackageCatalog } from "../package-manager/PackageCatalog";
import { PackageManager } from "../package-manager/PackageManager";
import { type ProcessMetricsPort } from "../platform/ports";
import { SessionContext } from "../session/SessionContext";
import { ViewManager } from "../view-manager/ViewManager";
import { BackendManager } from "./BackendManager";
/**
 * Events emitted by the ProcessManager
 */
interface ProcessNamespaceEvents {
    launched: {
        instance: AppInstance;
    };
    stopped: {
        appId: string;
    };
    reloading: {
        appId: string;
    };
    error: {
        appId: string;
        error: unknown;
    };
    exited: {
        appId: string;
        code: number;
    };
}
/**
 * ProcessManager
 *
 * Handles app lifecycle (launch, stop) and coordination between workers and views.
 */
export declare class ProcessManager extends EdenEmitter<ProcessNamespaceEvents> {
    private backendManager;
    private viewManager;
    private packageCatalog;
    private packageManager;
    private appChannelManager;
    private sessionContext;
    private executionContext;
    private config;
    private runtimeContexts;
    private runningApps;
    private processHandler;
    private processMetrics;
    private loginAppId?;
    private hotReloadStates;
    private hotReloadWatcher?;
    private hotReloadSetupPromise?;
    private hotReloadDebounceTimer?;
    private shuttingDown;
    constructor(backendManager: BackendManager, viewManager: ViewManager, ipcBridge: IPCBridge, packageCatalog: PackageCatalog, packageManager: PackageManager, appChannelManager: AppChannelManager, sessionContext: SessionContext, executionContext: ExecutionContext, config: EdenConfig, commandRegistry: CommandRegistry, runtimeContexts: RuntimeContextRegistry, processMetrics: ProcessMetricsPort);
    /**
     * Setup event handlers
     */
    private setupEventHandlers;
    private setupHotReloadWatcher;
    private handleHotReloadStateChanged;
    private refreshHotReloadApp;
    /**
     * Launch an app
     */
    launchApp(appId: string, bounds?: {
        x: number;
        y: number;
        width: number;
        height: number;
    }, launchArgs?: string[]): Promise<{
        success: boolean;
        instanceId: string;
        appId: string;
    }>;
    launchDaemon(appId: string, principal: ExecutionPrincipal, profile?: UserProfile): Promise<{
        success: boolean;
        instanceId: string;
        appId: string;
    }>;
    private launchAppInternal;
    ensureAppRunning(appId: string, options?: {
        bounds?: {
            x: number;
            y: number;
            width: number;
            height: number;
        };
        launchArgs?: string[];
    }): Promise<AppInstance>;
    /**
     * Stop a running app
     */
    stopApp(appId: string): Promise<void>;
    /**
     * Get list of running apps
     * @param showHidden - If true, includes overlay apps and daemons (hidden by default)
     */
    getRunningApps(showHidden?: boolean): AppInstance[];
    /**
     * Get app instance
     */
    getAppInstance(appId: string): AppInstance | undefined;
    getInstalledManifest(appId: string): import("@edenapp/types").RuntimeAppManifest | undefined;
    /**
     * Return a process metrics snapshot for running Eden apps.
     *
     * CPU percentages are interval-based values supplied by Electron. To avoid
     * concurrent callers resetting each other's sampling window, the main process
     * owns a shared sampler with a fixed cadence and can keep it alive for slower
     * polling clients.
     */
    getMetrics(showHidden?: boolean, pollingTimeoutMs?: number, waitForAccurateCpu?: boolean): Promise<ProcessMetricsSnapshot>;
    /**
     * Sync running app IDs with the IPC bridge
     */
    private syncRunningAppsState;
    /**
     * Handle app error
     */
    private handleAppError;
    /**
     * Handle app exit (called when backend crashes or exits unexpectedly)
     * Note: If stopApp() was called, the instance is already removed so this is a no-op
     */
    private handleAppExit;
    /**
     * Shutdown all apps
     */
    shutdown(): Promise<void>;
    dispose(): void;
    /**
     * Reload a running app
     */
    reloadApp(appId: string): Promise<void>;
    stopSessionApps(sessionId?: string): Promise<void>;
    private isLoginApp;
}
export {};
//# sourceMappingURL=ProcessManager.d.ts.map