import type { CleanupRecord } from '../backend-contract/errors.js';
import type { TrustedIpcSender } from '../backend-contract/electron.js';
import { type ElectronBleIpcEvent, type ElectronBleIpcResponse } from './protocol.js';
import { ElectronMainBleRouter } from './main-router.js';
/** Structural Electron main-process sender contract; importing Electron remains the host application's decision. */
export interface ElectronMainIpcSender {
    readonly mainFrame: ElectronMainFrameIdentity;
    send(channel: string, event: ElectronBleIpcEvent): void;
    isDestroyed?(): boolean;
    once(event: 'destroyed', listener: () => void): void;
    on: {
        (event: 'did-start-navigation', listener: ElectronNavigationStartListener): void;
        (event: 'did-redirect-navigation', listener: ElectronNavigationStartListener): void;
        (event: 'did-navigate', listener: () => void): void;
        (event: 'did-fail-load', listener: ElectronNavigationFailureListener): void;
        (event: 'did-fail-provisional-load', listener: ElectronNavigationFailureListener): void;
        (event: 'render-process-gone', listener: () => void): void;
    };
    removeListener: {
        (event: 'destroyed', listener: () => void): void;
        (event: 'did-start-navigation', listener: ElectronNavigationStartListener): void;
        (event: 'did-redirect-navigation', listener: ElectronNavigationStartListener): void;
        (event: 'did-navigate', listener: () => void): void;
        (event: 'did-fail-load', listener: ElectronNavigationFailureListener): void;
        (event: 'did-fail-provisional-load', listener: ElectronNavigationFailureListener): void;
        (event: 'render-process-gone', listener: () => void): void;
    };
}
interface ElectronMainFrameIdentity {
    readonly processId: number;
    readonly routingId: number;
}
/** Structural invoke event contract accepted from `ipcMain.handle`. */
export interface ElectronMainIpcEvent<Sender extends ElectronMainIpcSender> {
    readonly frameId: number;
    readonly processId: number;
    readonly sender: Sender;
    readonly senderFrame?: {
        readonly url: string;
    } | null;
}
/** Narrow structural IPC-main contract. It deliberately avoids an Electron runtime dependency. */
export interface ElectronMainIpcPort<Sender extends ElectronMainIpcSender> {
    handle(channel: string, listener: (event: ElectronMainIpcEvent<Sender>, request: unknown) => Promise<ElectronBleIpcResponse<string, string>>): void;
    removeHandler(channel: string): void;
}
export interface ElectronMainBleBindingOptions<Sender extends ElectronMainIpcSender> {
    readonly router: ElectronMainBleRouter;
    readonly port: ElectronMainIpcPort<Sender>;
    /** Converts host-authenticated WebContents facts into the contract identity; it never reads renderer payload fields. */
    readonly authenticate: (event: ElectronMainIpcEvent<Sender>) => TrustedIpcSender<string, string>;
}
interface ElectronNavigationStartDetails {
    readonly url: string;
    readonly isSameDocument: boolean;
    readonly isMainFrame: boolean;
}
type ElectronNavigationStartListener = (details: ElectronNavigationStartDetails) => void;
type ElectronNavigationFailureListener = (event: object, errorCode: number, errorDescription: string, validatedUrl: string, isMainFrame: boolean, frameProcessId: number, frameRoutingId: number) => void;
/**
 * Installs the one IPC handler and binds router event delivery to authenticated
 * WebContents. A renderer can neither select a native backend nor impersonate a
 * different window/session/client identity.
 */
export declare class ElectronMainBleBinding<Sender extends ElectronMainIpcSender> {
    private readonly options;
    private readonly renderers;
    private readonly bootstrapAdmissionTails;
    private readonly navigationStates;
    private installed;
    private lifecycle;
    private destroyResult;
    constructor(options: ElectronMainBleBindingOptions<Sender>);
    install(): void;
    uninstall(): void;
    destroy(): Promise<CleanupRecord>;
    private destroyBinding;
    private handleIpcRequest;
    private failureResponse;
    private handle;
    private withBootstrapAdmission;
    private bootstrap;
    private navigationState;
    private assertMainFrame;
    private assertBootstrapSender;
    private assertTrustedSenderCurrent;
    private releaseRetiredSenderRenderers;
    private assertActiveLifecycle;
    private retireRenderer;
    private publish;
    private rendererBindingIsCurrent;
    private acknowledge;
    private reserveEvent;
    private dropEvent;
    private releaseRendererAuthoritatively;
    private scheduleRendererReleaseRetry;
    private releaseRenderer;
    private completeRendererRelease;
    private removeLifetimeListeners;
}
export {};
//# sourceMappingURL=main-binding.d.ts.map