import express from 'express';
import { Server } from 'node:http';
import { WebSocket } from 'ws';
import { DevToolsRole, DeviceMetadata, DeviceStatusPayload, ServerMessage, RefreshType, RefreshInitiator, RefreshRequestMessage, ExportSnapshotRequestMessage, SnapshotReadyMessage, RefreshErrorCode, TransactionStatusState, BeginTransactionRequestMessage, CommitTransactionRequestMessage, RollbackTransactionRequestMessage, WriteRequestMessage, TransactionAckMessage, WriteAckMessage } from './types/protocol.js';

type ConnectedClient = {
    socket: WebSocket;
    connectionId: string;
    role: DevToolsRole;
    deviceId?: string;
    metadata?: DeviceMetadata;
    connectedAt: number;
    lastPongAt: number;
};
type RegisterClientInput = {
    socket: WebSocket;
    role: DevToolsRole;
    deviceId?: string;
    metadata?: DeviceMetadata;
};
declare class ConnectionManager {
    private readonly clients;
    add(input: RegisterClientInput): ConnectedClient;
    remove(socket: WebSocket): ConnectedClient | undefined;
    getBySocket(socket: WebSocket): ConnectedClient | undefined;
    getByConnectionId(connectionId: string): ConnectedClient | undefined;
    getByDeviceId(deviceId: string): ConnectedClient | undefined;
    getByRole(role: DevToolsRole): ConnectedClient[];
    updateLastPong(socket: WebSocket): void;
    getAll(): ConnectedClient[];
}

declare class DeviceRegistry {
    private readonly connectionManager;
    constructor(connectionManager: ConnectionManager);
    snapshot(): DeviceStatusPayload;
}

type OutboundMessage = ServerMessage;
declare class MessageRouter {
    private readonly connectionManager;
    private readonly deviceRegistry;
    constructor(connectionManager: ConnectionManager, deviceRegistry: DeviceRegistry);
    sendToSocket(socket: WebSocket, message: OutboundMessage): void;
    sendToBrowser(connectionId: string, message: OutboundMessage): void;
    sendToMobile(deviceId: string, message: OutboundMessage): void;
    broadcastToBrowsers(message: OutboundMessage): void;
    broadcastToMobiles(message: OutboundMessage): void;
    broadcastToAll(message: OutboundMessage): void;
    broadcast(message: unknown, target?: 'browsers' | 'mobiles' | 'all'): void;
    broadcastDeviceStatus(): void;
}

declare class Heartbeat {
    private readonly connectionManager;
    private readonly router;
    private interval;
    constructor(connectionManager: ConnectionManager, router: MessageRouter);
    start(): void;
    stop(): void;
    private pingAll;
    private removeStaleConnections;
}

type PendingRefresh = {
    deviceId: string;
    refreshType: RefreshType;
    startedAt: number;
    initiator: RefreshInitiator;
    browserConnectionId?: string;
    notifyAllBrowsers?: boolean;
};
declare class PendingRefreshStore {
    private readonly pendingByDevice;
    create(input: PendingRefresh): void;
    get(deviceId: string): PendingRefresh | undefined;
    has(deviceId: string): boolean;
    remove(deviceId: string): void;
    getExpired(now?: number): PendingRefresh[];
}

type DatabaseManifestEntry = {
    id: string;
    label: string;
    relativePath: string;
    source: 'active' | 'device';
    deviceId?: string;
    bundleId?: string;
    storageKey?: string;
    kind: string;
    mimeType: string;
    databaseName?: string;
    size: number;
    updatedAt: number;
};
type PersistDeviceSnapshotInput = {
    deviceId: string;
    bytes: Buffer;
    kind: string;
    mimeType: string;
    databaseName?: string;
    bundleId?: string;
};
type PersistDeviceSnapshotResult = {
    deviceRelativePath: string;
    exportedAt: number;
    size: number;
};

type ProjectDatabaseMeta = {
    exists: boolean;
    relativePath?: string;
    absolutePath?: string;
    kind?: string;
    mimeType?: string;
    databaseName?: string;
    size?: number;
    updatedAt?: number;
    source?: DatabaseManifestEntry['source'];
    deviceId?: string;
};
type ListedProjectDatabase = {
    id: string;
    label: string;
    relativePath: string;
    source: DatabaseManifestEntry['source'];
    deviceId?: string;
    bundleId?: string;
    storageKey?: string;
    databaseName?: string;
    size: number;
    updatedAt: number;
};
declare class SnapshotFileStore {
    private readonly dataDir;
    private readonly enabled;
    constructor(options?: {
        dataDir?: string;
        enabled?: boolean;
    });
    getDataDir(): string;
    isEnabled(): boolean;
    persistDeviceSnapshot(input: PersistDeviceSnapshotInput): Promise<PersistDeviceSnapshotResult | null>;
    reconcileOnMobileConnect(input: {
        deviceId: string;
        bundleId?: string;
    }): Promise<void>;
    readDeviceSnapshot(deviceId: string): Promise<Buffer | undefined>;
    readDeviceDatabase(deviceId: string): Promise<Buffer | undefined>;
    getDeviceDatabaseMeta(deviceId: string): Promise<ProjectDatabaseMeta>;
    listDeviceExports(): Promise<ListedProjectDatabase[]>;
    private reconcileLegacyExports;
    private pruneDeviceExports;
    private deleteEntryFiles;
    private manifestEntryToListed;
    private resolveDeviceDatabaseFile;
    /** @deprecated Proxies to the newest device export for backward-compatible API callers. */
    readActiveDatabase(): Promise<Buffer | undefined>;
    /** @deprecated Proxies to the newest device export for backward-compatible API callers. */
    getActiveDatabaseMeta(): Promise<ProjectDatabaseMeta>;
    listDatabases(): Promise<ListedProjectDatabase[]>;
    readDatabaseByRelativePath(relativePath: string): Promise<Buffer | undefined>;
    getDeviceDirectoryName(deviceId: string): string;
}

type StoredSnapshot = {
    deviceId: string;
    bytes: Buffer;
    kind: string;
    mimeType: string;
    databaseName?: string;
    exportedAt: number;
};
declare class SnapshotStore {
    private readonly snapshots;
    set(deviceId: string, bytes: Buffer, metadata: {
        kind: string;
        mimeType: string;
        databaseName?: string;
    }): StoredSnapshot;
    get(deviceId: string): StoredSnapshot | undefined;
    getBytes(deviceId: string): Buffer | undefined;
}

declare class RefreshCoordinator {
    private readonly connectionManager;
    private readonly router;
    private readonly pending;
    private readonly snapshots;
    private readonly snapshotFiles?;
    constructor(connectionManager: ConnectionManager, router: MessageRouter, pending: PendingRefreshStore, snapshots: SnapshotStore, snapshotFiles?: SnapshotFileStore | undefined);
    handleRefreshRequest(browserSocket: WebSocket, message: RefreshRequestMessage): void;
    handleMobileExportRequest(mobileSocket: WebSocket, message: ExportSnapshotRequestMessage): void;
    handleSnapshotUpload(deviceId: string, body: Buffer, metadata?: {
        kind?: string;
        mimeType?: string;
        databaseName?: string;
    }): Promise<{
        ok: true;
        stored: SnapshotReadyMessage;
    } | {
        ok: false;
        code: RefreshErrorCode;
    }>;
    getSnapshot(deviceId: string): Buffer | undefined;
    getSnapshotAsync(deviceId: string): Promise<Buffer | undefined>;
    checkTimeouts(): void;
    private requestMobileUpload;
    private failRefresh;
    private failMobileExport;
    private sendRefreshStatus;
    private sendRefreshError;
    private sendExportSnapshotError;
}

type WriteSession = {
    transactionId: string;
    deviceId: string;
    browserConnectionId: string;
    state: TransactionStatusState;
    pendingWrites: number;
    createdAt: number;
};
declare class WriteSessionManager {
    private readonly sessions;
    private readonly activeByDevice;
    create(input: {
        transactionId: string;
        deviceId: string;
        browserConnectionId: string;
    }): WriteSession;
    get(transactionId: string): WriteSession | undefined;
    getActiveForDevice(deviceId: string): WriteSession | undefined;
    setState(transactionId: string, state: TransactionStatusState): WriteSession | undefined;
    incrementPendingWrites(transactionId: string): WriteSession | undefined;
    decrementPendingWrites(transactionId: string): WriteSession | undefined;
    remove(transactionId: string): void;
    getExpired(now?: number): WriteSession[];
    getByBrowserConnectionId(browserConnectionId: string): WriteSession[];
    getByDeviceId(deviceId: string): WriteSession[];
}

declare class WriteCoordinator {
    private readonly connectionManager;
    private readonly router;
    private readonly sessions;
    constructor(connectionManager: ConnectionManager, router: MessageRouter, sessions: WriteSessionManager);
    handleBeginTransactionRequest(browserSocket: WebSocket, message: BeginTransactionRequestMessage): void;
    handleCommitTransactionRequest(browserSocket: WebSocket, message: CommitTransactionRequestMessage): void;
    handleRollbackTransactionRequest(browserSocket: WebSocket, message: RollbackTransactionRequestMessage): void;
    handleWriteRequest(browserSocket: WebSocket, message: WriteRequestMessage): void;
    handleTransactionAck(message: TransactionAckMessage): void;
    handleWriteAck(message: WriteAckMessage): void;
    checkTimeouts(): void;
    rollbackSessionsOnBrowserDisconnect(browserConnectionId: string): void;
    rollbackSessionsForDevice(deviceId: string): void;
    private rollbackSession;
    private sendTransactionStatus;
    private sendWriteError;
}

type DevToolsServerOptions = {
    host?: string;
    port?: number;
    dataDir?: string;
    snapshotPersistence?: boolean;
    webDistPath?: string;
};
type DevToolsServerUrls = {
    httpUrl: string;
    wsUrl: string;
    webUiEnabled: boolean;
};
type DevToolsServer = {
    app: express.Express;
    httpServer: Server;
    connectionManager: ConnectionManager;
    deviceRegistry: DeviceRegistry;
    router: MessageRouter;
    heartbeat: Heartbeat;
    snapshotStore: SnapshotStore;
    snapshotFileStore: SnapshotFileStore;
    pendingRefreshStore: PendingRefreshStore;
    writeSessions: WriteSessionManager;
    refreshCoordinator: RefreshCoordinator;
    writeCoordinator: WriteCoordinator;
    urls: DevToolsServerUrls;
    close: () => Promise<void>;
};
declare function createDevToolsServer(options?: DevToolsServerOptions): Promise<DevToolsServer>;

export { type ConnectedClient as C, type DevToolsServer as D, Heartbeat as H, MessageRouter as M, type OutboundMessage as O, type PendingRefresh as P, RefreshCoordinator as R, SnapshotStore as S, ConnectionManager as a, type DevToolsServerOptions as b, DeviceRegistry as c, PendingRefreshStore as d, type StoredSnapshot as e, createDevToolsServer as f };