import type { EventProtocol, Logger, Middleware } from './types';
/** Envelope produced from a raw incoming frame, ready to fan out to tabs. */
export interface IncomingEnvelope {
    event: string;
    data: unknown;
    /** Full deserialized frame (post-middleware) — for handlers needing top-level fields. */
    raw: unknown;
}
/**
 * Incoming frame pipeline — the mirror of FramePipeline. Turns a raw,
 * already-deserialized socket frame into an `{ event, data, raw }` envelope:
 *
 *   incoming middleware  →  extract event/data  →  per-event deserializer
 *
 * Runs on the leader (the tab that owns the socket); the envelope is then
 * broadcast to every tab for local fan-out. Extracted from SharedWebSocket so
 * the receive-side transform lives in one cohesive unit.
 */
export declare class IncomingPipeline {
    private readonly proto;
    private readonly log;
    private readonly middleware;
    private readonly deserializers;
    constructor(proto: EventProtocol, log: Logger);
    /** Register an incoming middleware. Return `null` from it to drop a frame. */
    use(fn: Middleware): void;
    /** Register a per-event deserializer, applied after global deserialize. */
    deserializer(event: string, fn: (data: unknown) => unknown): void;
    /**
     * Transform a raw frame into an envelope, or `null` if middleware dropped it.
     */
    process(raw: unknown): IncomingEnvelope | null;
}