/** A send whose (dedupe-scoped) digest was already recorded: it must not repeat. */
export declare class DuplicateSendError extends Error {
    readonly status: OwnerProactiveSend['status'];
    constructor(status: OwnerProactiveSend['status']);
}
/** Durable bounded dedupe containing wire IDs only — never message or reply plaintext. */
export declare class OwnerChannelState {
    private readonly path;
    private readonly limit;
    private handled;
    private readonly seen;
    constructor(path: string, limit?: number);
    has(wireId: string): boolean;
    remember(wireId: string): void;
}
export type OwnerConversationRouteBasis = 'last-inbound' | 'sole-owner' | 'source-wire';
interface OwnerProactiveSend {
    id: string;
    contact: string;
    digest: string;
    at: number;
    status: 'sending' | 'delivered' | 'uncertain';
}
/**
 * Durable destination history for unscoped owner messages. It stores only
 * authenticated CIDs, wire IDs, timestamps and content digests; never bodies,
 * filenames or display names. A pre-send marker prevents blind replay after a
 * crash or transport ambiguity.
 */
export declare class OwnerConversationState {
    private readonly path;
    private conversations;
    private routes;
    private sends;
    private corruptReason?;
    constructor(path: string);
    integrity(): {
        ok: boolean;
        error?: string;
    };
    recordInbound(contact: string, wireId: string, now?: number): void;
    remove(contact: string): void;
    route(effective: Set<string>): {
        contact: string;
        basis: OwnerConversationRouteBasis;
        replyToWireId?: string;
    };
    routeForWire(wireId: string, effective: Set<string>): {
        contact: string;
        basis: OwnerConversationRouteBasis;
    };
    beginSend(contact: string, digest: string, now?: number, minIntervalMs?: number, dedupe?: 'contact' | 'all'): OwnerProactiveSend;
    finishSend(id: string, status: 'delivered' | 'uncertain'): void;
    private mutate;
    private persist;
    private assertHealthy;
    private validConversation;
    private validRoute;
    private validSend;
}
export type OwnerSource = 'baseline' | 'dynamic';
export interface OwnerEntry {
    cid: string;
    source: OwnerSource;
    effective: boolean;
}
/**
 * Configured owners remain the declared baseline. This durable overlay adds
 * owners or revokes either source without rewriting fleet.yaml. A corrupt
 * overlay authorizes nobody and refuses mutation until the operator repairs or
 * removes the bad file; silently falling back could resurrect a revoked owner.
 */
export declare class OwnerAuthorizationState {
    private readonly path;
    private readonly baseline;
    private added;
    private revoked;
    private audit;
    private corruptReason?;
    constructor(path: string, baseline: string[]);
    integrity(): {
        ok: boolean;
        error?: string;
    };
    effective(): Set<string>;
    entries(): OwnerEntry[];
    authorize(cid: string): OwnerEntry;
    revoke(cid: string): OwnerEntry;
    private inBaseline;
    private hasCanonical;
    private deleteCanonical;
    private assertHealthy;
    private record;
    private snapshot;
    private restore;
    private persist;
}
export {};