import { ConnectionState, type ConsoleTransportConfig, type ConsoleTransportCallbacks } from './types.js';
import { type ConsoleEventData, type ConsoleEventEnvelope, type ConsoleEventHistoryPage, type ConsoleEventHistoryQuery, type ConsoleConfigSource } from "@zhin.js/console-protocol";
export type ConsoleEventListener<Type extends string> = (event: ConsoleEventEnvelope<Type, ConsoleEventData<Type>>) => void;
export interface ConsoleEventRecoveryGap {
    readonly query: ConsoleEventHistoryQuery;
    readonly page: ConsoleEventHistoryPage;
}
export type ConsoleEventRecoveryGapListener = (gap: ConsoleEventRecoveryGap) => void;
export declare class ConsoleTransport {
    private config;
    private callbacks;
    private state;
    private reconnectAttempts;
    private reconnectTimer;
    private requestId;
    private connectedListeners;
    private eventListeners;
    private recoveryGapListeners;
    private sseAbort;
    private eventRuntimeId;
    private lastEventId;
    private durableCursorBlocked;
    private disposed;
    private connectionGeneration;
    constructor(config?: ConsoleTransportConfig, callbacks?: ConsoleTransportCallbacks);
    onConnectionChange(listener: (connected: boolean) => void): () => void;
    /** Subscribe by event name; known names infer their exact payload type. */
    onConsoleEvent<Type extends string>(type: Type, listener: ConsoleEventListener<Type>): () => void;
    /** Observe a non-resumable cursor so domain views can perform a full resync. */
    onConsoleEventRecoveryGap(listener: ConsoleEventRecoveryGapListener): () => void;
    private notifyConnection;
    connect(): void;
    private connectSse;
    private pumpSse;
    private recoverEventHistory;
    private deliverConsoleEvent;
    private notifyRecoveryGap;
    disconnect(): void;
    send(message: unknown): void;
    sendRequest<T = unknown>(message: unknown): Promise<T>;
    isConnected(): boolean;
    getState(): ConnectionState;
    dispose(): void;
    getConfig(pluginName: string): Promise<unknown>;
    planPluginInstall(packageName: string): Promise<{
        packageName: string;
        instanceKey: string;
        alreadyDeclared: boolean;
        alreadyInstalled: boolean;
        restartRequired: boolean;
        changes: {
            packageManifest: string;
            config: string;
        };
        warnings: string[];
    }>;
    installPlugin(packageName: string, expectedRevision?: string): Promise<{
        success: boolean;
        plan: Awaited<ReturnType<ConsoleTransport["planPluginInstall"]>>;
        restartRequired: boolean;
    }>;
    planPluginUninstall(packageName: string): Promise<{
        packageName: string;
        instanceKey: string;
        installed: boolean;
        declared: boolean;
        hasConfig: boolean;
        restartRequired: boolean;
    }>;
    uninstallPlugin(packageName: string, expectedRevision?: string): Promise<{
        success: boolean;
        plan: Awaited<ReturnType<ConsoleTransport["planPluginUninstall"]>>;
        restartRequired: boolean;
    }>;
    planPluginUpdate(packageName: string, targetVersion: string): Promise<{
        packageName: string;
        instanceKey: string;
        currentVersion: string | null;
        targetVersion: string;
        installed: boolean;
        declared: boolean;
        alreadyCurrent: boolean;
        restartRequired: boolean;
    }>;
    updatePlugin(packageName: string, targetVersion: string, expectedRevision?: string): Promise<{
        success: boolean;
        plan: Awaited<ReturnType<ConsoleTransport["planPluginUpdate"]>>;
        installedVersion: string;
        restartRequired: boolean;
    }>;
    validatePluginConfig(pluginName: string, data: unknown): Promise<{
        valid: boolean;
        errors: Array<{
            path: string;
            message: string;
        }>;
        missingEnv: string[];
    }>;
    diagnosePlugin(pluginName: string): Promise<{
        pluginName: string;
        plan: unknown;
        validation: {
            valid: boolean;
            errors: Array<{
                path: string;
                message: string;
            }>;
            missingEnv: string[];
        };
    }>;
    setPluginEnabled(instanceKey: string, enabled: boolean): Promise<{
        success: boolean;
        instanceKey: string;
        enabled: boolean;
        disabled: string[];
        restartRequired: boolean;
        message: string;
    }>;
    listPlugins(): Promise<Record<string, unknown>[]>;
    searchMarketplace(query?: {
        keyword?: string;
        category?: string;
        official?: boolean;
        page?: number;
        pageSize?: number;
    }): Promise<unknown>;
    getMarketplacePlugin(packageName: string): Promise<unknown>;
    getPluginUpdates(): Promise<Record<string, unknown>[]>;
    testEndpoint(adapter: string, endpointKey: string): Promise<{
        reachable: boolean;
        connected: boolean;
        status?: "online" | "offline";
        phase: string;
        pendingLogin?: boolean;
        latencyMs: number;
        message: string;
    }>;
    setConfig(pluginName: string, config: unknown): Promise<{
        success?: boolean;
        reloaded?: boolean;
        message?: string;
    }>;
    getSchema(pluginName: string): Promise<unknown>;
    getAllConfigs(): Promise<Record<string, unknown>>;
    getAllSchemas(): Promise<Record<string, unknown>>;
    getConfigSource(): Promise<ConsoleConfigSource>;
    replaceConfigSource(source: string, expectedRevision: string): Promise<{
        success: boolean;
        revision: string;
        restartRequired: boolean;
        message?: string;
    }>;
    getEnvList(): Promise<{
        files: Array<{
            name: string;
            exists: boolean;
        }>;
    }>;
    getEnvFile(filename: string): Promise<{
        content: string;
    }>;
    saveEnvFile(filename: string, content: string): Promise<{
        success: boolean;
        message?: string;
    }>;
    getFileTree(): Promise<{
        tree: import("./types.js").FileTreeNode[];
    }>;
    readFile(filePath: string): Promise<{
        content: string;
        size: number;
    }>;
    saveFile(filePath: string, content: string): Promise<{
        success: boolean;
        message?: string;
    }>;
    getDbInfo(): Promise<import("./types.js").DatabaseInfo>;
    getDbTables(): Promise<{
        tables: import("./types.js").TableInfo[];
    }>;
    dbSelect(table: string, page?: number, pageSize?: number, where?: unknown): Promise<import("./types.js").SelectResult>;
    dbInsert(table: string, row: unknown): Promise<{
        success: boolean;
    }>;
    dbUpdate(table: string, row: unknown, where: unknown): Promise<{
        success: boolean;
        affected: number;
    }>;
    dbDelete(table: string, where: unknown): Promise<{
        success: boolean;
        deleted: number;
    }>;
    dbDropTable(table: string): Promise<{
        success: boolean;
    }>;
    kvGet(table: string, key: string): Promise<{
        key: string;
        value: unknown;
    }>;
    kvSet(table: string, key: string, value: unknown, ttl?: number): Promise<{
        success: boolean;
    }>;
    kvDelete(table: string, key: string): Promise<{
        success: boolean;
    }>;
    kvGetEntries(table: string): Promise<{
        entries: import("./types.js").KvEntry[];
    }>;
    private getRest;
    private setState;
    private handleBroadcast;
    private scheduleReconnect;
    private clearReconnectTimer;
    private assertActive;
    private isCurrentConnection;
}
//# sourceMappingURL=console-transport.d.ts.map