import { type Logger } from 'zapo-js';
import { type BinaryNode } from 'zapo-js/transport';
/**
 * The configuration the server attaches to every call offer in the
 * `<voip_settings uncompressed='1'>` node, whose content is base64 of a JSON
 * document tens of KB long. It is the server telling this session how to
 * behave, per call.
 *
 * The node has two profiles, and the media type of the offer is what picks
 * between them. An audio offer, with no `<video>`, carries 20 sections and 510
 * leaf keys; an offer with `<video>` carries 22 sections and 678 leaf keys,
 * about 34 KB. Neither profile is a subset of the other: `rc.rtcp_interval_ms`
 * appears only in the audio one and `vid_rc.disable_rtcp_remb` only in the
 * video one, so every key applied here has to know what to do when the profile
 * at hand does not carry it.
 *
 * Every value arrives as a string, booleans and numbers included: `"1"`, `"0"`,
 * `"true"`, `"false"`, `"35000"`. Normalization happens on read, and a missing
 * key, a missing section or an unexpected type return the default instead of
 * throwing.
 *
 * Out of this catalogue this client applies two keys, and only those two:
 * `vid_rc.disable_rtcp_remb` and {@link rtcpIntervalMs}. All the others stay
 * readable through the generic accessors and change no behavior at all. The
 * whole node being absent has to leave the call exactly as it was before the
 * node existed.
 *
 * Ignoring the node has a measured cost, not a hypothetical one. RTCP REMB was
 * implemented and started going out on every interval while
 * `vid_rc.disable_rtcp_remb` was `"1"` in that very offer: the packet went out
 * correct and the peer did not process it, because the server had turned that
 * feedback transport off. In the same JSON, `vid_rc.minbwe` was 35000, the
 * exact number the peer bitrate kept pinning at, and the one that cost three
 * rounds of investigation to find.
 *
 * The parse runs once, when the offer arrives, and the result is kept on the
 * call. 34 KB of JSON per call is acceptable; per packet it would not be, so a
 * caller reading a gate on a hot path resolves the value once and keeps the
 * boolean.
 */
export declare class WaVoipSettings {
    private readonly root;
    private constructor();
    /**
     * An instance from the already decoded JSON. A root that is not an object
     * returns `null`, the same safe path as an absent node.
     *
     * @throws the `JSON.parse` error when the text is not JSON. The stanza
     * reader calls this from inside a try, logs the message and carries on with
     * the defaults: no failure from here reaches the call.
     */
    static fromJson(text: string): WaVoipSettings | null;
    /** How many top-level sections there are, useful for logging only. */
    get sectionCount(): number;
    /** The raw leaf value, unnormalized, or `undefined` when it does not exist. */
    private leaf;
    /**
     * The boolean gate of the section, or `fallback` when the section, the key
     * or the shape of the value is not there.
     */
    getFlag(section: string, key: string, fallback: boolean): boolean;
    /**
     * The numeric parameter of the section, or `fallback` when the section, the
     * key or the shape of the value is not there.
     */
    getNumber(section: string, key: string, fallback: number): number;
    /**
     * The textual value of the section exactly as the server wrote it, or
     * `fallback` when the section, the key or the type is not there. It
     * converts neither number nor boolean into text: a caller that wants the
     * normalized value uses the accessor for that type.
     */
    getText(section: string, key: string, fallback?: string | null): string | null;
    /**
     * `vid_rc.disable_rtcp_remb`. When it is `"1"`, the server has turned RTCP
     * REMB off, and a REMB emitted anyway is a packet the peer does not
     * process. When absent, the default is `false` and the behavior stays what
     * it was before this node was ever read.
     */
    get disableRtcpRemb(): boolean;
    /**
     * `rc.rtcp_interval_ms`: the interval between RTCP reports the server
     * orders this session to use, or `null` to keep the compiled interval. Only
     * a positive number is accepted: a zero would order a report on every
     * packet.
     *
     * The key exists in the audio profile only, where it is `"1500"`; the video profile lacks it,
     * so a video call, upgraded or not, runs on the media session's compiled 1000 ms.
     */
    get rtcpIntervalMs(): number | null;
}
/**
 * Reads the `<voip_settings>` out of a call stanza and returns the
 * configuration, or `null` when there is nothing usable in there.
 *
 * No failure from here may bring a call down: an absent node, an unknown
 * variant attribute, corrupted base64, invalid JSON and a root that is not an
 * object all land on the same `null`, and the caller carries on with the
 * compiled defaults. That is half the reason this function exists - the content
 * comes from the server and can change without notice.
 *
 * `uncompressed='1'` is the only value ever seen in the attribute. A different
 * value is a variant with no sample to decode, and the whole node is discarded
 * instead of the format being guessed.
 *
 * @param node the call stanza, its ack, or the `<voip_settings>` node itself.
 * The search covers the node, its children and its grandchildren, so it serves
 * both `<call><offer><voip_settings>` and `<call><voip_settings>`.
 */
export declare function parseVoipSettings(node: BinaryNode, logger?: Logger): WaVoipSettings | null;