import { type Logger } from 'zapo-js';
import { proto } from 'zapo-js/proto';
import { type BinaryNode } from 'zapo-js/transport';
import type { NodeInfo, PeerVideoStateChange, RelayEndpoint, WaVoipDeps, WaVoipStores } from '../types.js';
export declare function encodeWAMessage(message: Parameters<typeof proto.Message.encode>[0]): Promise<Uint8Array>;
export declare function generateCallId(): string;
export declare function generateCallStanzaId(): string;
export declare function extractNodeInfo(node: BinaryNode): NodeInfo | null;
/**
 * `state` of a `<video>` message. The number on the wire **is** this ordinal - no
 * separate wire enum, no translation table.
 *
 * Two disjoint families share the tag, because two senders emit it: one announces the
 * video of a call that already has it, the other negotiates the upgrade. That is why a
 * capture of a camera turning on emits `6` then `4` without contradicting itself - `6` is
 * `Stopped`, never "enabled".
 */
export declare const WA_VIDEO_STATE: Readonly<{
    readonly Disabled: 0;
    readonly Enabled: 1;
    readonly Paused: 2;
    /** Upgrade request of a **group** call; 1:1 uses {@link UpgradeRequestV2}. */
    readonly UpgradeRequest: 3;
    /** The upgrade is on: the sender is about to put video on the wire. */
    readonly UpgradeAccept: 4;
    /** The peer refused the upgrade; distinct from either side timing out. */
    readonly UpgradeReject: 5;
    readonly Stopped: 6;
    /** The *receiver* of a request never answered it and gave up waiting. */
    readonly UpgradeRejectByTimeout: 7;
    /** The *requester* withdrew its request before it was answered. */
    readonly UpgradeCancel: 8;
    /** The *requester* withdrew its request because its own timer expired. */
    readonly UpgradeCancelByTimeout: 9;
    readonly UnknownPeer: 10;
    /** Upgrade request of a 1:1 call, which is the only kind this package places. */
    readonly UpgradeRequestV2: 11;
    readonly Xr2dCodecAvatarEnabled: 12;
    readonly Error: 20;
}>;
/**
 * How long a sent upgrade request waits before the requester gives up. Same value as the
 * peer's own guard timer, so neither side believes in an upgrade the other dropped.
 */
export declare const WA_VIDEO_UPGRADE_TIMEOUT_MS = 5000;
/**
 * How an upgrade request this side sent ended. `TimedOut` is the odd one out: this side
 * gave up with nothing coming back, so unlike the others it says nothing about whether
 * the peer ever saw the request.
 */
export declare const WA_VIDEO_UPGRADE_RESULT: Readonly<{
    /** The peer answered `UpgradeAccept`; video may now be sent. */
    readonly Accepted: "accepted";
    /** The peer answered `UpgradeReject`: it declined. */
    readonly Rejected: "rejected";
    /** The peer answered `UpgradeRejectByTimeout`: nobody there answered it. */
    readonly RejectedByTimeout: "rejected_by_timeout";
    /** The peer answered `Error`: it agreed to upgrade and could not. */
    readonly Failed: "error";
    /** Nothing came back before the guard timer expired. */
    readonly TimedOut: "timeout";
    /** This side withdrew the request before it was answered. */
    readonly Cancelled: "cancelled";
}>;
/** One of the values of {@link WA_VIDEO_UPGRADE_RESULT}. */
export type WaVideoUpgradeResult = (typeof WA_VIDEO_UPGRADE_RESULT)[keyof typeof WA_VIDEO_UPGRADE_RESULT];
/**
 * The `dec` this package announces: H.264 only, which is what every current client
 * decodes. The `enc_supported` bitmask carries the same fact as an integer and is
 * deliberately not sent - the string is what a capture of the official client shows.
 */
export declare const WA_VIDEO_DECODE_CAPABILITY = "H264";
/** Attributes of a `<video>` this side sends. */
export interface VideoStateStanzaOptions {
    /** One of {@link WA_VIDEO_STATE}, written to the wire as it is. */
    readonly state: number;
    /** Our own counter over the video states we have sent, starting at 1. */
    readonly transactionId: number;
    /** `dec`; defaults to {@link WA_VIDEO_DECODE_CAPABILITY}. */
    readonly decoderCodec?: string;
    /** `device_orientation`, 0 to 3; defaults to 0, upright. */
    readonly deviceOrientation?: number;
}
/**
 * Builds the `<call><video>` that announces a video state of our own, covering both
 * halves of the audio-to-video upgrade. `dec` rides on every message, not only the one
 * that concludes it: the peer's parser rejects a `<video>` carrying neither `enc` nor
 * `dec`.
 */
export declare function buildVideoStateStanza(peerDeviceJid: string, callId: string, callCreator: string, options: VideoStateStanzaOptions): BinaryNode;
/**
 * Reads the `<video>` the peer sends when its video state changes mid-call, which is also
 * how an audio call is upgraded: there is no separate upgrade stanza. Numbers are passed
 * through raw, see {@link PeerVideoStateChange}. Returns `null` when `state` is missing
 * or unreadable - without it there is no transition to report.
 */
export declare function parseVideoStateNode(innerNode: BinaryNode): PeerVideoStateChange | null;
export declare function extractRelayEndpoints(node: BinaryNode): RelayEndpoint[];
export declare function decryptCallKey(deps: WaVoipDeps, node: BinaryNode, peerJid: string, logger?: Logger): Promise<Uint8Array | undefined>;
export interface CallParticipantNodes {
    nodes: BinaryNode[];
    shouldIncludeDeviceIdentity: boolean;
}
export declare function buildCallParticipantNodes(deps: WaVoipDeps, devices: string[], callKey: Uint8Array): Promise<CallParticipantNodes>;
export declare function buildOfferStanza(deps: WaVoipDeps, stores: WaVoipStores, callId: string, callKey: Uint8Array, peerJid: string, isVideo: boolean, logger?: Logger): Promise<BinaryNode>;
/**
 * Builds the `<call><accept>` answer to an incoming offer.
 *
 * The accept carries no `<enc>` and no `<device-identity>`. Under the offer's
 * `encopt keygen='2'` the call key travels in the offer's `<enc>`, which the
 * callee decrypts, so the accept only confirms and has no key left to ship.
 * The server runs the encrypt-and-attach path for `offer` and `enc_rekey`
 * only and silently drops an accept that carries an `<enc>` child: no ack
 * comes back, the caller never learns the call was answered and keeps ringing
 * until its 90s timeout. Nothing is missing here, do not add crypto back.
 *
 * The accept carries no `<encopt>` either. A live call acked an accept whose
 * only children were `<audio>` and `<net>`, while the literal `encopt` is
 * absent from the WhatsApp Web bundle, which assembles this stanza inside its
 * WASM, so an accept-side `<encopt>` was never confirmed. Dropping it matches
 * that acked format. There is no evidence that an `<encopt>` child makes the
 * server discard the stanza, only that the server acks without it.
 *
 * `<audio>` and `<net>` are part of the real accept and stay.
 *
 * `peerJid` is addressed verbatim so a companion caller keeps its `:device`
 * suffix, matching the target `preaccept`, `transport` and `mute_v2` use.
 *
 * The video reply advertises H.264 because current mobile clients uplink
 * H.264: answering VP8 keeps signalling alive but yields no video RTP.
 *
 * The video node carries `dec` beside `enc`, each with the asymmetric spelling the peer
 * uses: `enc='h.264'`, `dec='H264'`. `dec` is how a peer picks what to encode for us and
 * this side is almost always the callee, so an accept without it leaves most calls
 * advertising no decoder. Our preaccept still carries no `<video>` node at all, for want
 * of a capture to copy.
 *
 * There is no call-key parameter: the decrypted offer key is not serialized
 * into this stanza, since it already reached both sides through the offer.
 */
export declare function buildAcceptStanza(deps: WaVoipDeps, callId: string, peerJid: string, callCreator: string, isVideo: boolean): Promise<BinaryNode>;
export declare function buildTerminateStanza(peerJid: string, callId: string, callCreator: string, audioDurationMs?: number, reason?: string): BinaryNode;
/**
 * The reject goes to the device that sent the offer, as the accept and the
 * terminate do. Addressed to the bare user instead, the server acknowledges it
 * and never delivers it to a companion caller, which keeps ringing; a phone,
 * device 0, is the same jid either way.
 */
export declare function buildRejectStanza(peerJid: string, callId: string, callCreator: string): BinaryNode;
export declare function buildPreacceptStanza(peerJid: string, callId: string, callCreator: string): BinaryNode;
export declare function buildRelayLatencyStanza(peerJid: string, callId: string, callCreator: string, relays: Array<{
    relayName: string;
    latency: number;
    addressBytes?: Uint8Array;
}>, destinationJids: string[], meId: string): BinaryNode;
export declare function buildTransportStanza(peerJid: string, callId: string, callCreator: string, meId: string, messageType?: string, p2pCandRound?: string): BinaryNode;
/**
 * Builds the `<call><mute_v2>` that announces our own microphone state: `mute-state` on
 * `mute_v2` itself, no child node. A statement, not a request - nothing comes back. Its
 * mutually exclusive `request-state` is deliberately not built: a group-call mechanism
 * WhatsApp's own clients drop on a 1:1 call, and never observed on the wire.
 */
export declare function buildMuteV2Stanza(peerDeviceJid: string, callId: string, callCreator: string, muted: boolean): BinaryNode;
export interface MuteV2Payload {
    /**
     * Microphone state the sender announced through `mute-state`. `null` when absent or
     * unrecognized, so an unknown state is never guessed into a boolean.
     */
    readonly muted: boolean | null;
    /** `true` when the stanza carries `request-state`: a request, not an announcement. */
    readonly isRequest: boolean;
}
/** Reads the state carried by an inbound `<mute_v2>` node. */
export declare function parseMuteV2(inner: BinaryNode): MuteV2Payload;
/**
 * Builds the `<call><user_action>` that announces the local raise-hand state: durable
 * per-participant state, which is why it travels over signalling rather than the media
 * path the reactions take.
 *
 * Every part is measured - the envelope rather than the bare stanza, `action` as the
 * string `raise_hand`, the hyphen in `raise-hand-state`, and `'0'` spelled out on
 * lowering rather than the attribute going away. `broadcast` is off by default: captures
 * of a live 1:1 raise hand carry it nowhere and the predicate that sets it is unknown.
 */
export declare function buildRaiseHandStanza(peerDeviceJid: string, callId: string, callCreator: string, raised: boolean, broadcast?: boolean): BinaryNode;
/**
 * Reads the raise-hand state an incoming stanza carries, or `null` when there is none.
 *
 * Both wire shapes are accepted, because the sender chooses between them with a gate this
 * side cannot see and both are live traffic: the `<user_action>` envelope, and a
 * top-level `<raise_hand>` that is a message type of its own, acked under its own tag.
 *
 * A `<user_action>` naming another action has no `<raise_hand>` child and so reads as
 * absent; anything other than `0` and `1` counts as absent too, never as a guess.
 */
export declare function parseRaiseHandState(node: BinaryNode): boolean | null;
export declare function buildAcceptReceiptStanza(peerDeviceJid: string, acceptMsgId: string, callId: string, callCreator: string, ourJid: string): BinaryNode;
export declare const ENCRYPTED_TAGS: readonly ["preaccept", "accept"];
export declare function needsDecryption(tag: string): boolean;