declare global {
    interface Console {
        log(message?: unknown, ...optionalParams: unknown[]): void;
        error(message?: unknown, ...optionalParams: unknown[]): void;
        warn(message?: unknown, ...optionalParams: unknown[]): void;
        info(message?: unknown, ...optionalParams: unknown[]): void;
        debug(message?: unknown, ...optionalParams: unknown[]): void;
    }
    var console: Console;
    function setTimeout(callback: () => void, ms?: number, ...args: unknown[]): number;
    function setInterval(callback: () => void, ms?: number, ...args: unknown[]): number;
    function setImmediate(callback: () => void, ...args: unknown[]): number;
    function clearTimeout(handle?: number): void;
    function clearInterval(handle?: number): void;
    function clearImmediate(handle?: number): void;
    function queueMicrotask(callback: () => void): void;
    function fetch(input: string | Request, init?: RequestInit): Promise<Response>;
    class Headers {
        constructor(init?: Record<string, string> | [string, string][]);
        append(name: string, value: string): void;
        get(name: string): string | null;
        has(name: string): boolean;
        set(name: string, value: string): void;
    }
    class Request {
        constructor(input: string | Request, init?: RequestInit);
        readonly url: string;
        readonly method: string;
        readonly headers: Headers;
    }
    interface RequestInit {
        method?: string;
        headers?: Record<string, string> | Headers;
        body?: string | FormData | Blob | ArrayBuffer;
        signal?: AbortSignal;
    }
    class Response {
        readonly ok: boolean;
        readonly status: number;
        readonly statusText: string;
        readonly headers: Headers;
        json(): Promise<unknown>;
        text(): Promise<string>;
        blob(): Promise<Blob>;
        arrayBuffer(): Promise<ArrayBuffer>;
    }
    class FormData {
        append(name: string, value: string | Blob, filename?: string): void;
    }
    class Blob {
        readonly size: number;
        readonly type: string;
        constructor(parts?: (string | ArrayBuffer | Blob)[], options?: {
            type?: string;
        });
        text(): Promise<string>;
        arrayBuffer(): Promise<ArrayBuffer>;
    }
    class URL {
        constructor(url: string, base?: string);
        readonly href: string;
        readonly origin: string;
        readonly protocol: string;
        readonly host: string;
        readonly hostname: string;
        readonly pathname: string;
        readonly search: string;
        readonly searchParams: URLSearchParams;
        toString(): string;
    }
    class URLSearchParams {
        constructor(init?: string | Record<string, string> | [string, string][]);
        append(name: string, value: string): void;
        get(name: string): string | null;
        has(name: string): boolean;
        set(name: string, value: string): void;
        toString(): string;
    }
    class TextEncoder {
        encode(input?: string): Uint8Array;
    }
    class TextDecoder {
        constructor(label?: string, options?: {
            fatal?: boolean;
        });
        decode(input?: ArrayBuffer | Uint8Array): string;
    }
    function btoa(data: string): string;
    function atob(data: string): string;
    class AbortController {
        readonly signal: AbortSignal;
        abort(reason?: unknown): void;
    }
    class AbortSignal {
        readonly aborted: boolean;
    }
    class WebSocket {
        static readonly CONNECTING: 0;
        static readonly OPEN: 1;
        static readonly CLOSING: 2;
        static readonly CLOSED: 3;
        constructor(url: string, protocols?: string | string[]);
        readonly readyState: number;
        send(data: string | ArrayBuffer | Uint8Array): void;
        close(code?: number, reason?: string): void;
        addEventListener(type: "open", listener: (event: Event) => void, options?: {
            once?: boolean;
        }): void;
        addEventListener(type: "close", listener: (event: CloseEvent) => void, options?: {
            once?: boolean;
        }): void;
        addEventListener(type: "message", listener: (event: MessageEvent) => void, options?: {
            once?: boolean;
        }): void;
        addEventListener(type: "error", listener: (event: Event) => void, options?: {
            once?: boolean;
        }): void;
    }
    interface MediaStreamTrack {
        readonly kind: string;
        readonly id: string;
        enabled: boolean;
        stop(): void;
        clone(): MediaStreamTrack;
        getConstraints(): MediaTrackConstraints;
    }
    interface MediaDeviceConstraintParameters {
        exact?: string | string[];
        ideal?: string | string[];
    }
    type MediaDeviceConstraint = string | string[] | MediaDeviceConstraintParameters;
    interface MediaTrackConstraints {
        deviceId?: MediaDeviceConstraint;
        echoCancellation?: boolean;
        noiseSuppression?: boolean;
        autoGainControl?: boolean;
        channelCount?: number | {
            exact?: number;
            ideal?: number;
        };
        sampleRate?: number | {
            exact?: number;
            ideal?: number;
        };
    }
    class MediaStream {
        constructor(tracks?: MediaStreamTrack[]);
        getTracks(): MediaStreamTrack[];
        getAudioTracks(): MediaStreamTrack[];
        addTrack(track: MediaStreamTrack): void;
    }
    /**
     * Minimal AnalyserNode declaration for the deprecated
     * `InputController.getAnalyser()` / `OutputController.getAnalyser()`
     * return types. On web this resolves to the full DOM AnalyserNode; on
     * other platforms the methods return `undefined`.
     */
    interface AnalyserNode {
        readonly frequencyBinCount: number;
        getByteFrequencyData(array: Uint8Array): void;
        getByteTimeDomainData(array: Uint8Array): void;
        getFloatFrequencyData(array: Float32Array): void;
    }
    interface Event {
        readonly type: string;
    }
    interface CloseEvent extends Event {
        readonly code: number;
        readonly reason: string;
        readonly wasClean: boolean;
    }
    interface MessageEvent<T = string> extends Event {
        readonly data: T;
    }
}
/**
 * Throws if any of the expected cross-platform globals are missing.
 * Call once at startup to surface environment issues early.
 */
export declare function assertRuntimeCompatibility(): void;
//# sourceMappingURL=runtime.d.ts.map