node-datachannel/dist/types/lib/index.d.ts

WebRTC For Node.js and Electron. libdatachannel node bindings.

import { LogLevel, SctpSettings, Direction, Channel, DescriptionType, LocalDescriptionInit, CertificateFingerprint, DataChannelInitConfig, RTCPeerConnectionState, RTCIceConnectionState, RTCSignalingState, RTCIceGatheringState, SelectedCandidateInfo, RtcConfig, IceUdpMuxRequest, NalUnitSeparator, ObuPacketization, WebSocketServerConfiguration } from './types.js';
export { IceServer, ProxyServer, ProxyServerType, RTCIceGathererState, RTCIceTransportState, RTCSdpType, RelayType, TransportPolicy } from './types.js';
import DataChannelStream$1 from './datachannel-stream.js';
import { WebSocketServer } from './websocket-server.js';
import { WebSocket } from './websocket.js';

declare function preload(): void;
declare function initLogger(level: LogLevel): void;
declare function cleanup(): void;
declare function setSctpSettings(settings: SctpSettings): void;
declare function getLibraryVersion(): string;
interface Audio {
    addAudioCodec(payloadType: number, codec: string, profile?: string): void;
    addOpusCodec(payloadType: number, profile?: string): string;
    direction(): Direction;
    generateSdp(eol: string, addr: string, port: number): string;
    mid(): string;
    setDirection(dir: Direction): void;
    description(): string;
    removeFormat(fmt: string): void;
    addSSRC(ssrc: number, name?: string, msid?: string, trackID?: string): void;
    removeSSRC(ssrc: number): void;
    replaceSSRC(oldSsrc: number, ssrc: number, name?: string, msid?: string, trackID?: string): void;
    hasSSRC(ssrc: number): boolean;
    getSSRCs(): number[];
    getCNameForSsrc(ssrc: number): string;
    setBitrate(bitRate: number): void;
    getBitrate(): number;
    hasPayloadType(payloadType: number): boolean;
    addRTXCodec(payloadType: number, originalPayloadType: number, clockRate: number): void;
    addRTPMap(): void;
    parseSdpLine(line: string): void;
}
declare const Audio: {
    new (mid: string, dir: Direction): Audio;
};
interface Video {
    addVideoCodec(payloadType: number, codec: string, profile?: string): void;
    addH264Codec(payloadType: number, profile?: string): void;
    addH265Codec(payloadType: number): void;
    addVP8Codec(payloadType: number): void;
    addVP9Codec(payloadType: number): void;
    addAV1Codec(payloadType: number): void;
    direction(): Direction;
    generateSdp(eol: string, addr: string, port: number): string;
    mid(): string;
    setDirection(dir: Direction): void;
    description(): string;
    removeFormat(fmt: string): void;
    addSSRC(ssrc: number, name?: string, msid?: string, trackID?: string): void;
    removeSSRC(ssrc: number): void;
    replaceSSRC(oldSsrc: number, ssrc: number, name?: string, msid?: string, trackID?: string): void;
    hasSSRC(ssrc: number): boolean;
    getSSRCs(): number[];
    getCNameForSsrc(ssrc: number): string;
    setBitrate(bitRate: number): void;
    getBitrate(): number;
    hasPayloadType(payloadType: number): boolean;
    addRTXCodec(payloadType: number, originalPayloadType: number, clockRate: number): void;
    addRTPMap(): void;
    parseSdpLine(line: string): void;
}
declare const Video: {
    new (mid: string, dir: Direction): Video;
};
interface Track {
    direction(): Direction;
    mid(): string;
    type(): string;
    close(): void;
    sendMessage(msg: string): boolean;
    sendMessageBinary(buffer: Buffer): boolean;
    isOpen(): boolean;
    isClosed(): boolean;
    bufferedAmount(): number;
    maxMessageSize(): number;
    requestBitrate(bitRate: number): boolean;
    setBufferedAmountLowThreshold(newSize: number): void;
    requestKeyframe(): boolean;
    setMediaHandler(handler: MediaHandler): void;
    onOpen(cb: () => void): void;
    onClosed(cb: () => void): void;
    onError(cb: (err: string) => void): void;
    onMessage(cb: (msg: Buffer) => void): void;
}
declare const Track: {
    new (): Track;
};
interface DataChannel extends Channel {
    getLabel(): string;
    getId(): number;
    getProtocol(): string;
    close(): void;
    sendMessage(msg: string): boolean;
    sendMessageBinary(buffer: Buffer | Uint8Array): boolean;
    isOpen(): boolean;
    bufferedAmount(): number;
    maxMessageSize(): number;
    setBufferedAmountLowThreshold(newSize: number): void;
    onOpen(cb: () => void): void;
    onClosed(cb: () => void): void;
    onError(cb: (err: string) => void): void;
    onBufferedAmountLow(cb: () => void): void;
    onMessage(cb: (msg: string | Buffer | ArrayBuffer) => void): void;
}
declare const DataChannel: {};
interface PeerConnection {
    close(): void;
    setLocalDescription(type?: DescriptionType, init?: LocalDescriptionInit): void;
    setRemoteDescription(sdp: string, type: DescriptionType): void;
    localDescription(): {
        type: DescriptionType;
        sdp: string;
    } | null;
    remoteDescription(): {
        type: DescriptionType;
        sdp: string;
    } | null;
    remoteFingerprint(): CertificateFingerprint;
    addRemoteCandidate(candidate: string, mid: string): void;
    createDataChannel(label: string, config?: DataChannelInitConfig): DataChannel;
    addTrack(media: Video | Audio): Track;
    hasMedia(): boolean;
    state(): RTCPeerConnectionState;
    iceState(): RTCIceConnectionState;
    signalingState(): RTCSignalingState;
    gatheringState(): RTCIceGatheringState;
    onLocalDescription(cb: (sdp: string, type: DescriptionType) => void): void;
    onLocalCandidate(cb: (candidate: string, mid: string) => void): void;
    onStateChange(cb: (state: string) => void): void;
    onIceStateChange(cb: (state: string) => void): void;
    onSignalingStateChange(cb: (state: string) => void): void;
    onGatheringStateChange(cb: (state: string) => void): void;
    onDataChannel(cb: (dc: DataChannel) => void): void;
    onTrack(cb: (track: Track) => void): void;
    bytesSent(): number;
    bytesReceived(): number;
    rtt(): number;
    getSelectedCandidatePair(): {
        local: SelectedCandidateInfo;
        remote: SelectedCandidateInfo;
    } | null;
    maxDataChannelId(): number;
    maxMessageSize(): number;
}
declare const PeerConnection: {
    new (peerName: string, config: RtcConfig): PeerConnection;
};
interface IceUdpMuxListener {
    address?: string;
    port: number;
    stop(): void;
    onUnhandledStunRequest(cb: (req: IceUdpMuxRequest) => void): void;
}
declare const IceUdpMuxListener: {
    new (port: number, address?: string): IceUdpMuxListener;
};
interface RtpPacketizationConfig {
    playoutDelayId: number;
    playoutDelayMin: number;
    playoutDelayMax: number;
    timestamp: number;
    get clockRate(): number;
}
declare const RtpPacketizationConfig: {
    new (ssrc: number, cname: string, payloadType: number, clockRate: number, videoOrientationId?: number): RtpPacketizationConfig;
};
interface MediaHandler {
    addToChain(handler: MediaHandler): void;
}
interface RtcpReceivingSession extends MediaHandler {
}
declare const RtcpReceivingSession: {
    new (): RtcpReceivingSession;
};
interface RtcpNackResponder extends MediaHandler {
}
declare const RtcpNackResponder: {
    new (maxSize?: number): RtcpNackResponder;
};
interface RtcpSrReporter extends MediaHandler {
    get rtpConfig(): RtpPacketizationConfig;
}
declare const RtcpSrReporter: {
    new (rtpConfig: RtpPacketizationConfig): RtcpSrReporter;
};
interface RtpPacketizer extends MediaHandler {
    get rtpConfig(): RtpPacketizationConfig;
}
declare const RtpPacketizer: {
    new (rtpConfig: RtpPacketizationConfig): RtpPacketizer;
};
interface H264RtpPacketizer extends RtpPacketizer {
}
declare const H264RtpPacketizer: {
    new (separator: NalUnitSeparator, rtpConfig: RtpPacketizationConfig, maxFragmentSize?: number): H264RtpPacketizer;
};
interface H265RtpPacketizer extends RtpPacketizer {
}
declare const H265RtpPacketizer: {
    new (separator: NalUnitSeparator, rtpConfig: RtpPacketizationConfig, maxFragmentSize?: number): H265RtpPacketizer;
};
interface AV1RtpPacketizer extends RtpPacketizer {
}
declare const AV1RtpPacketizer: {
    new (packetization: ObuPacketization, rtpConfig: RtpPacketizationConfig, maxFragmentSize?: number): AV1RtpPacketizer;
};

declare const DataChannelStream: typeof DataChannelStream$1;
declare const _default: {
    initLogger: typeof initLogger;
    cleanup: typeof cleanup;
    preload: typeof preload;
    setSctpSettings: typeof setSctpSettings;
    getLibraryVersion: typeof getLibraryVersion;
    RtcpReceivingSession: new () => RtcpReceivingSession;
    RtcpNackResponder: new (maxSize?: number) => RtcpNackResponder;
    RtcpSrReporter: new (rtpConfig: RtpPacketizationConfig) => RtcpSrReporter;
    RtpPacketizationConfig: new (ssrc: number, cname: string, payloadType: number, clockRate: number, videoOrientationId?: number) => RtpPacketizationConfig;
    RtpPacketizer: new (rtpConfig: RtpPacketizationConfig) => RtpPacketizer;
    H264RtpPacketizer: new (separator: NalUnitSeparator, rtpConfig: RtpPacketizationConfig, maxFragmentSize?: number) => H264RtpPacketizer;
    H265RtpPacketizer: new (separator: NalUnitSeparator, rtpConfig: RtpPacketizationConfig, maxFragmentSize?: number) => H265RtpPacketizer;
    AV1RtpPacketizer: new (packetization: ObuPacketization, rtpConfig: RtpPacketizationConfig, maxFragmentSize?: number) => AV1RtpPacketizer;
    Track: new () => Track;
    Video: new (mid: string, dir: Direction) => Video;
    Audio: new (mid: string, dir: Direction) => Audio;
    DataChannel: {};
    PeerConnection: new (peerName: string, config: RtcConfig) => PeerConnection;
    WebSocket: new (config?: WebSocketServerConfiguration) => WebSocket;
    WebSocketServer: typeof WebSocketServer;
    DataChannelStream: typeof DataChannelStream$1;
    IceUdpMuxListener: new (port: number, address?: string) => IceUdpMuxListener;
};

export { AV1RtpPacketizer, Audio, CertificateFingerprint, Channel, DataChannel, DataChannelInitConfig, DataChannelStream, DescriptionType, Direction, H264RtpPacketizer, H265RtpPacketizer, IceUdpMuxListener, IceUdpMuxRequest, LocalDescriptionInit, LogLevel, type MediaHandler, NalUnitSeparator, ObuPacketization, PeerConnection, RTCIceConnectionState, RTCIceGatheringState, RTCPeerConnectionState, RTCSignalingState, RtcConfig, RtcpNackResponder, RtcpReceivingSession, RtcpSrReporter, RtpPacketizationConfig, RtpPacketizer, SctpSettings, SelectedCandidateInfo, Track, Video, WebSocket, WebSocketServer, WebSocketServerConfiguration, cleanup, _default as default, getLibraryVersion, initLogger, preload, setSctpSettings };