import type { Logger } from 'zapo-js';
import { type BinaryNode } from 'zapo-js/transport';
import { type WaCallMediaEvent, type WaCallMediaMessage, type WaCallReaction } from '@zapo-js/voip-media';
import { type PeerScreenShare } from '../signaling/screen-share.js';
import { type WaVideoUpgradeResult } from '../signaling/signaling.js';
import { type WaVoipSettings } from '../signaling/voip-settings.js';
import { EndCallReason, type InboundVideoFrame, type InboundVideoRtpPacket, type PeerVideoStateChange, type WaVoipDeps } from '../types.js';
import { type CallInfo } from './call-state.js';
import type { WaCallMediaLink, WaCallMediaLinkEvents } from './media-link.js';
export interface WaCallMediaSessionDelegate {
    emitState(call: CallInfo): void;
    emitIncoming(call: CallInfo): void;
    emitEnded(call: CallInfo): void;
    emitPeerMute(call: CallInfo, muted: boolean): void;
    emitInboundAudio(call: CallInfo, data: Float32Array): void;
    emitInboundVideoRtp(call: CallInfo, packet: InboundVideoRtpPacket): void;
    emitInboundVideo(call: CallInfo, frame: InboundVideoFrame): void;
    emitScreenShare(call: CallInfo, share: PeerScreenShare): void;
    emitPeerVideoState(call: CallInfo, change: PeerVideoStateChange): void;
    emitOutboundAudioFinished(call: CallInfo): void;
    emitHandRaise(call: CallInfo, participantJid: string, raised: boolean): void;
    /** One in-band emoji reaction, deduplicated: the sender repeats it, this fires once. */
    emitCallReaction?(call: CallInfo, reaction: WaCallReaction): void;
    /** A change to the media plan, for a host elsewhere to apply; remote media only. */
    emitMediaPlan?(call: CallInfo, message: WaCallMediaMessage): void;
    /** Ends the call through its owner, for a session that has to end itself. */
    endCall(call: CallInfo, reason: EndCallReason): void;
}
export interface WaCallMediaSessionOptions {
    readonly deps: WaVoipDeps;
    readonly logger: Logger;
    readonly info: CallInfo;
    readonly delegate: WaCallMediaSessionDelegate;
    /** Builds the link to wherever this call's media runs, in this process or elsewhere. */
    readonly createMediaLink: (events: WaCallMediaLinkEvents) => WaCallMediaLink;
    /** Monotonic clock the video hold is timed on, in ms; `performance.now` by default. */
    readonly now?: () => number;
}
/**
 * The signaling of one call, and the source of its media plan: what the stanzas teach the
 * media is derived into the plan and published on the media link.
 */
export declare class WaCallMediaSession {
    readonly info: CallInfo;
    private readonly deps;
    private readonly logger;
    private readonly delegate;
    private readonly media;
    private initialTransportSent;
    private outgoingPreacceptSent;
    /** Relays our own `<relaylatency>` already named; bounded by the relays the server lists. */
    private readonly announcedRelayNames;
    /** The peer's last `latency` per relay name, as sent; kept for the relay election, unused yet. */
    private readonly peerRelayLatencies;
    private peerRelayLatencyReports;
    /** The SSRC lists of the plan as last derived; published whole as `ssrcs` on any change. */
    private selfStreamSsrcs;
    private peerAudioSsrc;
    private peerStreamSsrcs;
    private peerVideoStreamSsrcs;
    /**
     * App-data SSRCs of the peer's devices: inbound app data is recognized by SSRC,
     * never by payload type, which nothing negotiates.
     */
    private readonly peerAppDataSsrcs;
    /** Bumped when the SRTP keys change, so the media rebuilds its contexts only then. */
    private keyEpoch;
    private lastKeys;
    /** Last value published per plan section, so an unchanged one is not sent again. */
    private readonly publishedSections;
    /**
     * Our own device jid, as the SSRC derivation takes it: an upgraded call derives a
     * video SSRC long after the jid was resolved.
     */
    private selfDeviceJid;
    /** Whether {@link ensureVideoReceivePath} ran; a call negotiated as video never sets it. */
    private videoReceivePathOpened;
    /**
     * Whether an accepted upgrade opened the local video sender on a call negotiated as
     * audio. Until it does the media drops every video frame: no video RTP leaves before
     * the peer has accepted.
     */
    private videoSendPathOpened;
    /**
     * Holds our video until the peer can take it: after an accepted peer upgrade, and from the
     * accept on a call born as video. Published as `video.sendHeld`.
     */
    private readonly peerVideoReadyGate;
    /** Whether the one post-active `<mute_v2>` declaration has gone out. */
    private initialMuteAnnounced;
    /**
     * Our counter behind `transaction-id` on the `<video>` messages we send. Starts at 0
     * so the first one sent is 1, the way the peer numbers its own.
     */
    private videoStateTransactionId;
    /** The upgrade request this side sent and is still waiting on, or `null`. */
    private pendingVideoUpgrade;
    /**
     * Whether the peer has an upgrade request outstanding against us, cleared by
     * anything that ends it, ours or its own.
     */
    private peerVideoUpgradeRequested;
    /**
     * Counts the `<video>` messages from the peer this session has acted on, so an answer
     * that fails to send can tell whether the request it was answering is still the peer's
     * latest word. Sending yields, and a withdrawal arriving in that gap must not be undone
     * by the rollback of the send it raced.
     */
    private peerVideoStateSeen;
    private acceptedByJid;
    /**
     * Off unless the call's profile turns it on, which is how the reference client reads
     * the same key: with it off a repeated transaction id is counted and logged, and the
     * message is then handled like any other.
     */
    private videoStateTxnEnforced;
    constructor(options: WaCallMediaSessionOptions);
    get callId(): string;
    /**
     * Drops an `accepted_elsewhere` from a peer device other than the one that answered a call
     * we placed. Never on an incoming call: there the caller sends it about our own devices.
     */
    shouldIgnoreTerminate(peerJid: string | undefined, reason: string | undefined): boolean;
    initMedia(selfLid: string, peerJid: string): Promise<void>;
    /**
     * Stores the configuration that came in the offer and hands the media what it
     * tunes: the REMB gate, the RTCP interval and the app-data SFrame flag. Called
     * again mid-call for the larger profile that rides an upgrade request.
     *
     * `null` is not an error, it is the common case of an absent or unreadable
     * node, and it leaves the call exactly as it was.
     */
    applyVoipSettings(settings: WaVoipSettings | null): void;
    resetOutgoingFlags(): void;
    acceptCall(): Promise<void>;
    rejectCall(reason?: EndCallReason): Promise<void>;
    endCall(reason?: EndCallReason): Promise<void>;
    /**
     * Mutes or unmutes our own capture and announces it to the peer.
     *
     * Muting stays local: the media keeps sending silence, so the stream and its SSRC
     * stay alive. A no-op toggle sends nothing; the once-per-call declaration a
     * starting call needs is {@link announceInitialMuteState}.
     */
    setMute(muted: boolean): void;
    /**
     * Announces this side's microphone state once, just after the call goes active.
     * Measured on the wire: both ends of a reference call send it. Without it the peer
     * has nothing to show for this side until the first toggle, which on a call that is
     * never muted never comes. Fire-and-forget, sent once.
     */
    private announceInitialMuteState;
    /**
     * Raises or lowers the local hand and announces it to the peer. Idempotent.
     *
     * The local state moves only after the stanza leaves, so a failed send cannot leave
     * this side believing the peer saw a hand that never arrived; the error is rethrown.
     */
    setHandRaised(raised: boolean): Promise<void>;
    /**
     * Starts or stops sharing the screen on this call, and tells the peer. The share is not
     * a stream of its own: the screen rides the video stream the call already has, so this
     * only changes what the peer is told the picture *is*, and switching the content is the
     * caller's job. Idempotent, and a no-op on an inactive call.
     *
     * @throws when the send fails, leaving the state untouched, and - starting a share
     * only - on a group call or on a call carrying no video yet
     * ({@link requestVideoUpgrade} first).
     */
    setScreenShare(sharing: boolean): Promise<void>;
    loadAudio(audioPath: string): Promise<void>;
    setExternalAudioMode(enabled: boolean): void;
    feedLiveAudio(data: Float32Array): number;
    feedLiveVideo(data: Uint8Array, timestampUs: number): number;
    getLiveBufferMs(): number;
    sendIncomingPreaccept(peerJid: string): Promise<void>;
    /**
     * One `<relaylatency>` per relay we dial, each once per call: every device of the peer
     * preaccepts, and a name is claimed before its send yields. Stops once the call has ended.
     */
    sendRelayLatency(): Promise<void>;
    /**
     * What `<te>` may say about our relays: only the ones we dial, once per name, with our
     * own latency and address. Naming another makes the peer elect a relay we are not on.
     */
    private dialableRelayLatencies;
    /**
     * On an incoming call only another device of this account can accept: that ends it while
     * ringing, as accepted elsewhere, sending nothing. An accept from any other account is dropped.
     */
    handleCallAccept(node: BinaryNode, peerJid: string): Promise<void>;
    handleCallPreaccept(node: BinaryNode, peerJid: string): Promise<void>;
    /**
     * Hands the relays a `<transport>` lists to the media. The media keeps dialling
     * nothing new while a leg is open, and dials them once the call has none.
     */
    handleCallTransport(_node: BinaryNode): Promise<void>;
    handleCallAck(node: BinaryNode): Promise<void>;
    /**
     * Records the peer's relay latencies and sends nothing back: answering every one made two
     * clients that both answer bounce it between them forever.
     */
    handleCallRelaylatency(node: BinaryNode, peerJid: string): void;
    handleRelayElection(node: BinaryNode): void;
    /**
     * Records the microphone state an inbound `<mute_v2>` announces, once per change.
     * Nothing goes back: it is an announcement, not a request.
     *
     * Two are dropped on purpose: one from another device of our own account, whose mute
     * state is not the peer's, and one carrying `request-state`, a group-call mechanism
     * WhatsApp's own clients drop on a 1:1 call.
     *
     * On a call born as video, the peer's first announcement after the accept is also
     * the sign that it can take our video; see {@link WaPeerVideoReadyGate}.
     */
    handleCallMuteV2(node: BinaryNode, peerJid: string): void;
    private isOwnAccountJid;
    /** The `<user_action>` envelope carries several actions; only raise hand is read. */
    handleCallUserAction(node: BinaryNode, peerJid: string): void;
    /**
     * Handles a top-level `<raise_hand>`: a message type of its own, not a variant of
     * `<user_action>`, and still sent by current clients. Dropping this handler routes
     * those stanzas to the router's default branch and loses the hand silently.
     */
    handleCallRaiseHand(node: BinaryNode, peerJid: string): void;
    /**
     * Records the state a stanza of either shape carried. Idempotent, as the sender is.
     *
     * A hand from another device of our own account is dropped, as `<mute_v2>` drops one:
     * the local hand is `stateData.handRaised`, and letting the echo in lists
     * this account among the remote participants holding one up.
     */
    private applyPeerRaiseHand;
    /**
     * Records the screen-share state a `screen_share` or `screen` stanza carried.
     *
     * Nothing extra goes back: the router already acked it and no screen-share tag
     * appears among the message types - by analogy with the video-state ack, not
     * confirmed. The picture itself arrives as ordinary H.264 on the sender's video
     * stream, which the receive path already handles.
     */
    handleCallScreenShare(node: BinaryNode): void;
    /**
     * Applies a `<video>` from the peer: a mid-call video state change, and with it the
     * audio-to-video upgrade, which has no stanza of its own.
     *
     * A message whose `transaction-id` does not advance past the last one from this peer is
     * a replay, and is dropped only on a call whose profile asks for that - otherwise it is
     * noted and handled like any other. The bridge's ack is transport only, not an
     * acceptance - that is a `<video state='4'>` coming the other way.
     */
    handleCallVideoState(node: BinaryNode): void;
    /**
     * Whether an inbound `<video>` repeats a transaction already seen.
     *
     * `transaction-id` is the sender's own counter and only ever advances, so every
     * message the peer sends - answers to our own included - carries a number above the
     * last one it sent. One that does not advance is a replay. The counter this side
     * stamps on what it sends is a separate one and is never compared against this.
     *
     * Saying so is not the same as acting on it: whether a replay is dropped is a key of
     * the negotiated profile, and the calls measured so far do not carry it. Answering
     * the question apart from enforcing the answer keeps the log honest on a call that
     * handles the message anyway.
     */
    private isStaleVideoState;
    /**
     * Moves the upgrade handshake on the state the peer just announced.
     *
     * The codes split by who they are about: a request is the peer opening a handshake
     * against us and is only recorded, because answering is the caller's decision, while
     * a terminal code settles a request *we* sent - the same code with nothing pending is
     * the peer closing its own, not an answer to us. Either way it clears the peer's
     * outstanding request: left set, a later {@link requestVideoUpgrade} takes the
     * crossing branch and opens our sender against a peer still on audio.
     */
    private applyPeerUpgradeState;
    /**
     * Asks the peer to turn this audio call into a video call, and resolves with how that
     * ended. **No video RTP leaves until the peer accepts**: the accept is what opens the
     * local sender. The request goes out as `UpgradeRequestV2`, the 1:1 code -
     * `UpgradeRequest` is the group one. A crossing request answers the peer's instead of
     * sending a second, and a second call while one is in flight joins it. Throws when the
     * call is not active or already carries video.
     *
     * Nothing has to be added to `<capability>`: the peer gates the upgrade on indices 4
     * and 11, which an audio offer already carries. Order derived, not captured.
     */
    requestVideoUpgrade(): Promise<WaVideoUpgradeResult>;
    /**
     * Accepts an upgrade the peer asked for, concluding the handshake and opening the
     * local video sender. No-op when the peer has nothing outstanding: accepting a
     * request never made would announce video on a call the peer thinks is audio.
     *
     * The camera is announced after the accept and after the sender is open, the order the
     * requesting side follows too: `Enabled` claims video is on the wire, so it may not
     * leave before there is a sender, and the sender may not open before the peer knows
     * the upgrade was accepted.
     *
     * Our frames are then held until the peer's camera is on, plus a guard, or three
     * seconds at most; see {@link WaPeerVideoReadyGate}. An upgrade we asked for is not held.
     */
    acceptVideoUpgrade(): Promise<void>;
    /** Declines an upgrade the peer asked for. No-op when it asked for none. */
    rejectVideoUpgrade(): Promise<void>;
    /**
     * Puts back the peer request an answer cleared, when that answer never left.
     *
     * Only when the peer has said nothing since: sending yields, and a withdrawal that
     * lands in that gap already cleared the request for good. Restoring it then would let
     * a later accept open the video sender against a peer back on audio - the same state
     * an unhandled `Disabled` used to leave behind.
     */
    private restorePeerRequest;
    /** Withdraws the request this side sent. No-op when nothing is in flight. */
    cancelVideoUpgrade(): Promise<void>;
    /**
     * Ends a request the peer never answered: this side stops waiting and the call stays
     * audio.
     *
     * The withdrawal travels as `Disabled`, **not** as `UpgradeCancelByTimeout`, whose
     * name invites exactly that swap: the peer's own timer runs a downgrade too, and the
     * cancel codes belong to a deliberate withdrawal ({@link cancelVideoUpgrade}).
     * Nothing is sent once the request is no longer outstanding.
     */
    private onVideoUpgradeTimeout;
    /**
     * Settles the request in flight, if any, and drops it. Every path that ends a
     * handshake goes through here, which is what keeps the resolver single-use.
     */
    private settleVideoUpgrade;
    /**
     * Sends one `<video>` of our own, numbered with the next id of our own counter.
     *
     * The counter belongs to this side alone and only advances; an id read off an inbound
     * `<video>` is never reused, since the peer numbers its messages on its own counter and
     * drops anything of ours that does not move past the last id we sent.
     */
    private sendVideoState;
    /**
     * Opens the local video sender on a call negotiated as audio, once both sides have
     * agreed the upgrade. Until it runs the media drops every video frame.
     *
     * Deliberately **not** merged into {@link ensureVideoReceivePath}: the receive path
     * costs nothing and may open on the first sign of peer video, while this one puts our
     * video on the wire and may only open on an agreement. It also has the media register
     * our video SSRCs with the relay, which an audio call never did, or the relay drops
     * what it does not know. Idempotent, and a no-op on a video call.
     */
    private openVideoSendPath;
    /**
     * Records that video is now live on this side, separately from the transport work
     * around it: this is the only part a call negotiated as video also needs.
     */
    private announceVideoLive;
    private get videoSendActive();
    /**
     * Opens the video receive path on a call negotiated as audio, so video the peer starts
     * halfway through has somewhere to land: the media subscribes the relay to the peer's
     * video streams and opens the video RTP session the key frame request and the
     * bandwidth estimate ride on. Without them an inbound stream stays a trickle with no
     * decodable start.
     *
     * The local sender stays off - that needs an agreement, {@link openVideoSendPath}.
     * Idempotent, and a no-op on a video call.
     */
    private ensureVideoReceivePath;
    /**
     * The media has no relay leg left, and nothing reopens one. What is left is a
     * call that is live to the manager and mute on the wire.
     *
     * The terminate that follows is the ordinary one, the same a hangup sends,
     * because leaving the peer on a call we cannot carry is that same call
     * seen from their side. Whether the official client terminates here, and
     * with which `reason` attribute, is not captured; if it carries one, that
     * is where it belongs.
     */
    private onRelayLost;
    /** Media is flowing: a call still connecting goes active and declares its mute state. */
    private onMediaActive;
    /** An event from the host that carries this call's media elsewhere. */
    handleMediaEvent(event: WaCallMediaEvent): void;
    /** The whole media plan as it stands, or `null` when the media runs in this process. */
    getMediaSnapshot(): WaCallMediaMessage | null;
    /**
     * `reason` is the `<terminate>` reason. Only an incoming call keeps the elsewhere reasons:
     * on an outgoing one `accepted_elsewhere` comes from the peer's companions.
     */
    handleCallTerminate(reason?: string): void;
    cleanup(): void;
    /**
     * Sends one emoji reaction in-band on the media socket. Returns whether the first
     * packet left; a `false` does not lose it, the retransmission carries it.
     */
    sendReaction(reaction: string): boolean;
    /**
     * Hands a plan change to the media, leaving out sections equal to the last published ones;
     * `relays` always goes, since resending it asks a leg-less media side to dial. Failures log.
     */
    private publish;
    private publishSsrcsAndKeys;
    /** Keeps the last epoch for unchanged keys, so the media's SRTP contexts keep their state. */
    private versionKeys;
    private buildSsrcs;
    private relaysSection;
    /**
     * What video may flow each way; a media host reads this, not the media type, to capture.
     * `sendHeld` is present only while the peer is not ready for our video.
     */
    private videoSection;
    /** Holds our video from the accept of a born-video call; published before media can flow. */
    private holdBornVideoSend;
    /** Lets our held video go, the gate having opened: the peer is ready, or never said so. */
    private releaseVideoSend;
    private get relaySlots();
    private ssrcOf;
    /** The audio and app-data streams of every device listed, each once. */
    private audioStreamsOf;
    /** The streams video adds to a device's registration: {@link VIDEO_ONLY_SSRC_SLOTS}. */
    private videoOnlyStreamsOf;
    /** The peer's three video streams, subscribed to once its video can arrive. */
    private peerVideoStreamsOf;
    private trackPeerAppDataSsrcs;
    private ensureDeviceJid;
    /** Device 0 travels both bare and as `:0`, so device jids compare in one form. */
    private isSameDevice;
    /**
     * The peer device that won a call we placed: the `<relay><participant>` of its `<accept>`
     * when it is a device of the called user, else the device the accept came from. `pid` is
     * the participant's, as on the wire. No pn/lid mapping: another domain falls back too.
     */
    private readAnsweringDevice;
    private isCalledUser;
    /** The form stanzas are addressed to and arrive from: device 0 bare. */
    private toAddressedJid;
    /**
     * Derives the SRTP keys from the call key: ours to send, the answering device's to receive.
     * `null` without a call key or on failure, leaving the media's keys as they were.
     */
    private deriveKeys;
}