import { type RedactableAction } from "./config";
export type NotificationEvent = ({
    type: "action_needed";
} & RedactableAction) | {
    type: "action_resolved";
    id: string;
    sessionId: string;
    resolvedBy?: string;
} | {
    type: "frame";
    sessionId: string;
    frame: Record<string, unknown>;
};
export interface NotificationReplyRoute {
    sessionId: string;
    actionId: string;
    answer: number | string | {
        selected?: Array<number | string>;
        custom?: string;
    };
}
export interface NotificationAdapterPayload {
    adapter: string;
    channelKey?: string;
    body: unknown;
    route?: Omit<NotificationReplyRoute, "answer">;
}
export interface NotificationPresentationAdapter {
    readonly kind: "telegram" | "discord" | "slack";
    render(event: NotificationEvent): NotificationAdapterPayload[];
    mapInbound(input: unknown): NotificationReplyRoute | undefined;
}
export interface EngineSessionSink {
    sendReply(route: NotificationReplyRoute): void;
}
export interface NotificationEngineOptions {
    redact: boolean;
}
/**
 * Shared presentation engine for managed notification clients.
 *
 * It owns fanout, redaction boundaries, pending-action routing, and reply
 * delivery into session sinks. Transport adapters stay pure: render an internal
 * event into a public-safe payload and map an inbound transport interaction
 * back into a session/action answer.
 */
export declare class NotificationPresentationEngine {
    private readonly opts;
    readonly adapters: readonly NotificationPresentationAdapter[];
    private readonly sessions;
    private readonly pending;
    constructor(adapters: readonly NotificationPresentationAdapter[], opts: NotificationEngineOptions);
    connectSession(sessionId: string, sink: EngineSessionSink): void;
    dropSession(sessionId: string): void;
    fanout(event: NotificationEvent): NotificationAdapterPayload[];
    routeInbound(adapterKind: NotificationPresentationAdapter["kind"], input: unknown): boolean;
    private redactEvent;
}