import { RTCSession } from 'jssip';

/**
 * A tiny typed event emitter. We ship our own rather than depend on Node's
 * `events` module so the bundle stays browser-native and dependency-free (beyond
 * the bundled JsSIP). `Events` maps each event name to its payload type; `void`
 * marks a payload-less event.
 */
type Listener<T> = (payload: T) => void;
declare class Emitter<Events extends object> {
    private handlers;
    on<K extends keyof Events>(event: K, fn: Listener<Events[K]>): this;
    once<K extends keyof Events>(event: K, fn: Listener<Events[K]>): this;
    off<K extends keyof Events>(event: K, fn: Listener<Events[K]>): this;
    protected emit<K extends keyof Events>(event: K, payload?: Events[K]): void;
}

/** Public types shared across the SDK. */
type LogLevel = 'none' | 'error' | 'info' | 'debug';
/**
 * A custom log sink. Receives each emitted line (already filtered by
 * {@link PhoneOptions.logLevel}) with its level and arguments — `'none'` never
 * reaches it since nothing is emitted at that level.
 */
type LogSink = (level: 'error' | 'info' | 'debug', ...args: unknown[]) => void;
interface PhoneOptions {
    /**
     * Console log verbosity. Defaults to `'none'` — the SDK is silent unless you
     * opt in. `'error'` \| `'info'` \| `'debug'`, where `'debug'` also turns on
     * JsSIP's own wire-level tracing. All output goes to the browser DevTools
     * console, prefixed `[voice-sdk]`; nothing leaves the page.
     */
    logLevel?: LogLevel;
    /**
     * Custom log sink. When provided, emitted log lines (still gated by
     * `logLevel`) are handed to this callback **instead of** the console, so you
     * can route them into your own UI, log store, or telemetry. JsSIP's own
     * wire-level trace (at `logLevel: 'debug'`) still goes to the console.
     */
    onLog?: LogSink;
    /**
     * WSS endpoint the phone connects to. Must be the platform FQDN (its TLS
     * cert is issued for the name, not the bare IP). Defaults to production;
     * override only for testing.
     */
    wssUrl?: string;
    /** SIP realm / domain. Defaults to the production realm. */
    realm?: string;
    /**
     * Fallback ICE servers (STUN/TURN). In production the reliable, NAT-crossing
     * ICE config is delivered per-session in the mint response and passed to
     * {@link Phone.authenticate}; this option is only a default/override.
     */
    iceServers?: RTCIceServer[];
    /**
     * Max time (ms) to spend gathering ICE candidates before placing/answering a
     * call. Default 3000. On UDP-restricted networks, unreachable STUN/TURN-UDP
     * candidates otherwise stall gathering for ~39.5s (RFC 5389) before the call
     * proceeds; this cap sends the offer/answer with the candidates already
     * gathered (host + TCP/TLS relay), so calls connect in seconds. On good
     * networks gathering finishes well within the cap, so it costs nothing. Set to
     * 0 to disable and always wait for full gathering.
     */
    iceGatheringTimeout?: number;
}
/**
 * The credentials the developer's backend obtained from `POST
 * /api/phone-tokens/mint` and handed to the browser. `authenticate` also accepts
 * a bare token string when you have no per-session ICE config yet.
 */
interface AuthCredentials {
    /** The signed, short-lived phone token (JWT). */
    token: string;
    /** ICE servers for this session (from the mint response). */
    iceServers?: RTCIceServer[];
}
interface CallOptions {
    /**
     * Opaque developer metadata echoed back on every platform event for this
     * call. Max 500 characters (platform limit). Sent as the
     * `X-Sauti-Custom-Payload` INVITE header.
     */
    customPayload?: string;
}
/** Claims carried by a phone token (decoded locally, signature NOT verified). */
interface TokenClaims {
    /** SIP extension this token is scoped to. */
    sub: string;
    /** Account uuid. */
    acc: string;
    /** End-user uuid. */
    eu?: string;
    /** Max concurrent calls. */
    mc?: number;
    exp?: number;
    iat?: number;
    typ?: string;
}
interface MediaDevices {
    inputs: MediaDeviceInfo[];
    outputs: MediaDeviceInfo[];
}
/** Structured reason attached to `ended` / `failed` / `registrationFailed`. */
interface FailureReason {
    /** JsSIP's coarse cause string (e.g. `'Rejected'`, `'Canceled'`). */
    cause?: string;
    /** SIP status code, when the failure carried a response. */
    statusCode?: number;
    /** SIP reason phrase, when present. */
    reason?: string;
}

declare class Logger {
    private sink?;
    private threshold;
    constructor(level?: LogLevel, sink?: LogSink | undefined);
    setLevel(level: LogLevel): void;
    private write;
    error(...args: unknown[]): void;
    info(...args: unknown[]): void;
    debug(...args: unknown[]): void;
}

/**
 * Owns the single hidden `<audio>` element that plays far-end audio, plus the
 * operator's device preferences (mic in, speaker out, volume). Kept in one place
 * so the {@link Phone} and every {@link Call} share the same sink and settings.
 */
declare class MediaController {
    private log;
    private audio;
    private inputDeviceId?;
    private outputDeviceId?;
    private volume;
    constructor(log: Logger);
    private element;
    /** Route a remote media stream to the speaker. */
    attachStream(stream: MediaStream): void;
    /** Stop playing far-end audio (call ended). */
    detach(): void;
    setVolume(value: number): void;
    setInputDevice(deviceId: string): void;
    setOutputDevice(deviceId: string): Promise<void>;
    /** `getUserMedia` constraints honouring the chosen microphone. */
    audioConstraints(): MediaStreamConstraints;
    listDevices(): Promise<MediaDevices>;
}

/** Events a {@link Call} emits. */
interface CallEvents {
    /** Remote party is ringing / early media. */
    ringing: {
        statusCode?: number;
    };
    /** The call was answered (media flowing). */
    accepted: void;
    /** The call ended after being established. */
    ended: FailureReason;
    /** The call never established (rejected, busy, no answer, error…). */
    failed: FailureReason;
    hold: void;
    unhold: void;
    muted: void;
    unmuted: void;
}
/**
 * One call leg. Wraps a JsSIP `RTCSession` and exposes the phone controls a UI
 * needs, plus rich *local* events. Platform-truth events — call cost, recording
 * ready, billing — are delivered to your backend by webhook, not to the browser.
 */
declare class Call extends Emitter<CallEvents> {
    private session;
    private media;
    private log;
    private pcConfig;
    private iceGatheringTimeout;
    /** `'incoming'` or `'outgoing'`. */
    readonly direction: 'incoming' | 'outgoing';
    /** The far party's SIP URI, best-effort. */
    readonly remoteIdentity: string;
    constructor(session: RTCSession, media: MediaController, log: Logger, pcConfig: RTCConfiguration, iceGatheringTimeout: number);
    /**
     * Send the offer/answer as soon as we have a usable candidate, instead of
     * waiting for ICE gathering to fully complete — which on UDP-restricted
     * networks means the full ~39.5s RFC 5389 STUN timeout.
     *
     * JsSIP's `icecandidate` event hands us a `ready()` that ends gathering early.
     * We call it the instant a TURN **relay** candidate appears: a relay is a
     * guaranteed connectivity path, and by the time it's gathered the faster
     * server-reflexive (direct) candidate is almost always already in the pool
     * too — so the offer still carries the direct path when one exists. This
     * connects in ~the TURN-allocate time (sub-second when the relay is nearby)
     * rather than a fixed cap. `iceGatheringTimeout` is only the fallback for when
     * no relay ever arrives (e.g. TURN misconfigured); on good networks JsSIP's own
     * gathering-complete fires first and this never matters.
     */
    private capIceGathering;
    private wire;
    private attachPeer;
    /** Answer an incoming call. */
    answer(): void;
    /** Decline an incoming call (SIP 486 Busy Here). */
    reject(): void;
    /** Hang up an active or outgoing call. */
    hangup(): void;
    hold(): void;
    unhold(): void;
    /** Mute the local microphone (audio only). */
    mute(): void;
    unmute(): void;
    /** Send a DTMF tone (e.g. navigating an IVR). */
    sendDigit(tone: string): void;
    get isOnHold(): boolean;
    get isMuted(): boolean;
}

/** Events a {@link Phone} emits. */
interface PhoneEvents {
    /** Registered with the switch — ready to place/receive calls. */
    registered: {
        extension: string;
        account: string;
    };
    /** Unregistered (after {@link Phone.unregister} or the socket dropping). */
    unregistered: void;
    registrationFailed: FailureReason;
    /** WebSocket connected. */
    connected: void;
    /** WebSocket dropped (network lost, or the endpoint is unreachable). */
    disconnected: {
        reason?: string;
    };
    /** An inbound call is arriving — answer or reject the given {@link Call}. */
    incoming: Call;
}
/**
 * A browser softphone. Authenticate with an ephemeral token minted by your
 * backend, then place and receive real calls.
 *
 * @example
 * ```js
 * const phone = new VoiceSDK.Phone({ logLevel: 'info' });
 * await phone.authenticate(tokenFromYourBackend);
 * const call = await phone.call('+254711111111');
 * phone.on('incoming', (c) => c.answer());
 * ```
 */
declare class Phone extends Emitter<PhoneEvents> {
    private options;
    private ua;
    private log;
    private media;
    private claims;
    private iceServers;
    constructor(options?: PhoneOptions);
    /** The extension this phone is registered as, or `null` before auth. */
    get extension(): string | null;
    /** The account uuid this phone belongs to, or `null` before auth. */
    get account(): string | null;
    get isRegistered(): boolean;
    /**
     * Register the phone using an ephemeral token (or `{ token, iceServers }` from
     * your backend's mint call). Resolves once REGISTERED, rejects if registration
     * fails. The token is decoded locally only to build the SIP URI — never
     * verified here (the switch does that).
     */
    authenticate(auth: string | AuthCredentials): Promise<void>;
    /**
     * Place an outbound call. `destination` may be a bare extension/number
     * (`'2002'`, `'+254711111111'`) or a full SIP URI. Returns the {@link Call} to
     * wire events and controls onto.
     */
    call(destination: string, options?: CallOptions): Call;
    /** Unregister and close the connection. */
    unregister(): void;
    /** List available audio input/output devices. */
    listDevices(): Promise<MediaDevices>;
    /** Choose the microphone used for the next call. */
    setInputDevice(deviceId: string): void;
    /** Route call audio to a specific speaker (where the browser supports it). */
    setOutputDevice(deviceId: string): Promise<void>;
    /** Set output volume, 0–1. */
    setVolume(value: number): void;
    private peerConfig;
    private iceGatheringTimeout;
    private customPayloadHeaders;
    private bindUA;
}

/**
 * Decode a phone token's claims WITHOUT verifying the signature.
 *
 * Verification is the server's job — the platform validates the token on
 * registration. The SDK decodes it purely to read `sub` (the extension) and
 * `acc` (the account) so it can build the SIP URI, and to surface scope/expiry
 * to the caller. A tampered token simply fails at registration.
 *
 * Returns `null` if the string isn't a well-formed JWT.
 */
declare function decodeToken(token: string): TokenClaims | null;
/** True if the token's `exp` claim is in the past. */
declare function isExpired(claims: TokenClaims): boolean;

/**
 * A public ICE candidate (a server-reflexive candidate from STUN, or a relay
 * candidate from TURN) is REQUIRED for extension-to-extension calls: the
 * platform bridges two WebRTC legs and needs a routable candidate on each. With
 * host-only (private) candidates the bridge fails. TURN additionally covers
 * symmetric-NAT / mobile networks where a reflexive candidate isn't reachable.
 *
 * In production the platform delivers STUN + TURN with short-lived credentials
 * in the mint response, which you pass to `Phone.authenticate`. This public
 * STUN server is only a development fallback for when no ICE config has been
 * supplied yet.
 */
declare const DEFAULT_ICE_SERVERS: RTCIceServer[];

/** One-line human summary of a failure, e.g. `"403 Forbidden · cause=Rejected"`. */
declare function describeFailure(r: FailureReason): string;

export { type AuthCredentials, Call, type CallEvents, type CallOptions, DEFAULT_ICE_SERVERS, type FailureReason, type LogLevel, type LogSink, type MediaDevices, Phone, type PhoneEvents, type PhoneOptions, type TokenClaims, decodeToken, describeFailure, isExpired };