@observertc/observer-js/lib/ObservedPeerConnection.d.ts

Server Side NodeJS Library for processing ObserveRTC Samples

/// <reference types="node" />
import { EventEmitter } from 'events';
import { ObservedClient } from './ObservedClient';
import { OutboundTrackSample, PeerConnectionSample } from './schema/ClientSample';
import { ObservedInboundRtp } from './ObservedInboundRtp';
import { ObservedOutboundRtp } from './ObservedOutboundRtp';
import { ObservedCertificate } from './ObservedCertificate';
import { ObservedCodec } from './ObservedCodec';
import { ObservedDataChannel } from './ObservedDataChannel';
import { ObservedIceCandidate } from './ObservedIceCandidate';
import { ObservedIceCandidatePair } from './ObservedIceCandidatePair';
import { ObservedIceTransport } from './ObservedIceTransport';
import { ObservedMediaSource } from './ObservedMediaSource';
import { ObservedPeerConnectionTransport } from './ObservedPeerConnectionTransport';
import { ObservedMediaPlayout } from './ObservedMediaPlayout';
import { ObservedRemoteInboundRtp } from './ObservedRemoteInboundRtp';
import { ObservedRemoteOutboundRtp } from './ObservedRemoteOutboundRtp';
import { ObservedInboundTrack } from './ObservedInboundTrack';
import { ObservedOutboundTrack } from './ObservedOutboundTrack';
import { CalculatedScore } from './scores/CalculatedScore';
import { ObservedTurnServer } from './ObservedTurnServer';
export type ObservedPeerConnectionEvents = {
    iceconnectionstatechange: [
        {
            state: string;
        }
    ];
    icegatheringstatechange: [
        {
            state: string;
        }
    ];
    connectionstatechange: [
        {
            state: string;
        }
    ];
    selectedcandidatepair: [];
    'added-certificate': [ObservedCertificate];
    'added-codec': [ObservedCodec];
    'added-data-channel': [ObservedDataChannel];
    'added-ice-candidate': [ObservedIceCandidate];
    'added-ice-candidate-pair': [ObservedIceCandidatePair];
    'added-ice-transport': [ObservedIceTransport];
    'added-inbound-rtp': [ObservedInboundRtp];
    'added-inbound-track': [ObservedInboundTrack];
    'added-media-playout': [ObservedMediaPlayout];
    'added-media-source': [ObservedMediaSource];
    'added-outbound-rtp': [ObservedOutboundRtp];
    'added-outbound-track': [ObservedOutboundTrack];
    'added-peer-connection-transport': [ObservedPeerConnectionTransport];
    'added-remote-inbound-rtp': [ObservedRemoteInboundRtp];
    'added-remote-outbound-rtp': [ObservedRemoteOutboundRtp];
    'removed-certificate': [ObservedCertificate];
    'removed-codec': [ObservedCodec];
    'removed-data-channel': [ObservedDataChannel];
    'removed-ice-candidate': [ObservedIceCandidate];
    'removed-ice-candidate-pair': [ObservedIceCandidatePair];
    'removed-ice-transport': [ObservedIceTransport];
    'removed-inbound-rtp': [ObservedInboundRtp];
    'removed-inbound-track': [ObservedInboundTrack];
    'removed-media-playout': [ObservedMediaPlayout];
    'removed-media-source': [ObservedMediaSource];
    'removed-outbound-rtp': [ObservedOutboundRtp];
    'removed-outbound-track': [ObservedOutboundTrack];
    'removed-peer-connection-transport': [ObservedPeerConnectionTransport];
    'removed-remote-inbound-rtp': [ObservedRemoteInboundRtp];
    'removed-remote-outbound-rtp': [ObservedRemoteOutboundRtp];
    'updated-inbound-rtp': [ObservedInboundRtp];
    'updated-outbound-rtp': [ObservedOutboundRtp];
    'updated-inbound-track': [ObservedInboundTrack];
    'updated-outbound-track': [ObservedOutboundTrack];
    'updated-ice-candidate-pair': [ObservedIceCandidatePair];
    'updated-ice-transport': [ObservedIceTransport];
    'updated-peer-connection-transport': [ObservedPeerConnectionTransport];
    'updated-media-source': [ObservedMediaSource];
    'updated-media-playout': [ObservedMediaPlayout];
    'updated-data-channel': [ObservedDataChannel];
    'updated-ice-candidate': [ObservedIceCandidate];
    'updated-certificate': [ObservedCertificate];
    'updated-codec': [ObservedCodec];
    'updated-remote-inbound-rtp': [ObservedRemoteInboundRtp];
    'updated-remote-outbound-rtp': [ObservedRemoteOutboundRtp];
    'muted-inbound-track': [ObservedInboundTrack];
    'muted-outbound-track': [ObservedOutboundTrack];
    'unmuted-inbound-track': [ObservedInboundTrack];
    'unmuted-outbound-track': [ObservedOutboundTrack];
    'update': [];
    close: [];
};
export declare interface ObservedPeerConnection {
    on<U extends keyof ObservedPeerConnectionEvents>(event: U, listener: (...args: ObservedPeerConnectionEvents[U]) => void): this;
    off<U extends keyof ObservedPeerConnectionEvents>(event: U, listener: (...args: ObservedPeerConnectionEvents[U]) => void): this;
    once<U extends keyof ObservedPeerConnectionEvents>(event: U, listener: (...args: ObservedPeerConnectionEvents[U]) => void): this;
    emit<U extends keyof ObservedPeerConnectionEvents>(event: U, ...args: ObservedPeerConnectionEvents[U]): boolean;
}
export declare class ObservedPeerConnection extends EventEmitter {
    readonly peerConnectionId: string;
    readonly client: ObservedClient;
    private _visited;
    appData?: Record<string, unknown>;
    readonly calculatedScore: CalculatedScore;
    closed: boolean;
    openedAt?: number;
    closedAt?: number;
    updated: number;
    connectionState?: string;
    iceConnectionState?: string;
    iceGatheringState?: string;
    availableIncomingBitrate: number;
    availableOutgoingBitrate: number;
    totalInboundPacketsLost: number;
    totalInboundPacketsReceived: number;
    totalOutboundPacketsSent: number;
    totalDataChannelBytesSent: number;
    totalDataChannelBytesReceived: number;
    totalDataChannelMessagesSent: number;
    totalDataChannelMessagesReceived: number;
    totalSentAudioBytes: number;
    totalSentVideoBytes: number;
    totalSentAudioPackets: number;
    totalSentVideoPackets: number;
    totalReceivedAudioPacktes: number;
    totalReceivedVideoPackets: number;
    totalReceivedAudioBytes: number;
    totalReceivedVideoBytes: number;
    deltaInboundPacketsLost: number;
    deltaInboundPacketsReceived: number;
    deltaOutboundPacketsSent: number;
    deltaDataChannelBytesSent: number;
    deltaDataChannelBytesReceived: number;
    deltaDataChannelMessagesSent: number;
    deltaDataChannelMessagesReceived: number;
    deltaInboundReceivedBytes: number;
    deltaOutboundSentBytes: number;
    deltaReceivedAudioBytes: number;
    deltaReceivedVideoBytes: number;
    deltaReceivedAudioPackets: number;
    deltaReceivedVideoPackets: number;
    deltaSentAudioBytes: number;
    deltaSentVideoBytes: number;
    deltaTransportSentBytes: number;
    deltaTransportReceivedBytes: number;
    receivingPacketsPerSecond: number;
    sendingPacketsPerSecond: number;
    sendingAudioBitrate: number;
    sendingVideoBitrate: number;
    receivingAudioBitrate: number;
    receivingVideoBitrate: number;
    currentRttInMs?: number;
    currentJitter?: number;
    usingTCP: boolean;
    usingTURN: boolean;
    observedTurnServer?: ObservedTurnServer;
    readonly observedCertificates: Map<string, ObservedCertificate>;
    readonly observedCodecs: Map<string, ObservedCodec>;
    readonly observedDataChannels: Map<string, ObservedDataChannel>;
    readonly observedIceCandidates: Map<string, ObservedIceCandidate>;
    readonly observedIceCandidatesPair: Map<string, ObservedIceCandidatePair>;
    readonly observedIceTransports: Map<string, ObservedIceTransport>;
    readonly observedInboundRtps: Map<number, ObservedInboundRtp>;
    readonly observedInboundTracks: Map<string, ObservedInboundTrack>;
    readonly observedMediaPlayouts: Map<string, ObservedMediaPlayout>;
    readonly observedMediaSources: Map<string, ObservedMediaSource>;
    readonly observedOutboundRtps: Map<number, ObservedOutboundRtp>;
    readonly observedOutboundTracks: Map<string, ObservedOutboundTrack>;
    readonly observedPeerConnectionTransports: Map<string, ObservedPeerConnectionTransport>;
    readonly observedRemoteInboundRtps: Map<number, ObservedRemoteInboundRtp>;
    readonly observedRemoteOutboundRtps: Map<number, ObservedRemoteOutboundRtp>;
    constructor(peerConnectionId: string, client: ObservedClient);
    get score(): number | undefined;
    get visited(): boolean;
    get codecs(): ObservedCodec[];
    get inboundRtps(): ObservedInboundRtp[];
    get remoteOutboundRtps(): ObservedRemoteOutboundRtp[];
    get outboundRtps(): ObservedOutboundRtp[];
    get remoteInboundRtps(): ObservedRemoteInboundRtp[];
    get mediaSources(): ObservedMediaSource[];
    get mediaPlayouts(): ObservedMediaPlayout[];
    get dataChannels(): ObservedDataChannel[];
    get peerConnectionTransports(): ObservedPeerConnectionTransport[];
    get iceTransports(): ObservedIceTransport[];
    get iceCandidates(): ObservedIceCandidate[];
    get iceCandidatePairs(): ObservedIceCandidatePair[];
    get certificates(): ObservedCertificate[];
    get selectedIceCandidatePairs(): ObservedIceCandidatePair[];
    get selectedIceCandiadtePairForTurn(): ObservedIceCandidatePair[];
    close(): void;
    accept(sample: PeerConnectionSample): void;
    private _checkVisited;
    private _updateCertificateStats;
    private _updateCodecStats;
    private _updateDataChannelStats;
    private _updateIceCandidateStats;
    private _updateIceCandidatePairStats;
    private _updateIceTransportStats;
    private _updateInboundRtpStats;
    private _updateInboundTrackSample;
    private _updateMediaPlayoutStats;
    private _updateMediaSourceStats;
    private _updateOutboundRtpStats;
    _updateOutboundTrackSample(stats: OutboundTrackSample): void | ObservedOutboundTrack;
    private _updatePeerConnectionTransportStats;
    private _updateRemoteInboundRtpStats;
    private _updateRemoteOutboundRtpStats;
}
//# sourceMappingURL=ObservedPeerConnection.d.ts.map