@techsee/techsee-media-service 999.19.3-alphasap → 999.19.6-nodejs20

package/lib/MultiParty/opentok.d.ts

@@ -0,0 +1,463 @@
+declare namespace OT {
+    export type OTError = {
+        name: string;
+        message: string;
+    };
+
+    export type Dimensions = {
+        width: number;
+        height: number;
+    };
+
+    export type ScreenSharingCapabilityResponse = {
+        extensionInstalled?: boolean;
+        supported: boolean;
+        supportedSources: {
+            application?: boolean;
+            screen?: boolean;
+            window?: boolean;
+        };
+        extensionRequired?: string;
+        extensionRegistered?: boolean;
+    };
+
+    export function checkScreenSharingCapability(callback: (response: ScreenSharingCapabilityResponse) => void): void;
+
+    export function checkSystemRequirements(): number;
+
+    export type Device = {
+        kind: 'audioInput' | 'videoInput';
+        deviceId: string;
+        label: string;
+    };
+
+    export function getDevices(callback: (error: OTError | undefined, devices?: Device[]) => void): void;
+
+    export function setProxyUrl(proxyUrl: string): void;
+
+    export function getSupportedCodecs(): Promise<{
+        videoEncoders: ('H264' | 'VP8')[];
+        videoDecoders: ('H264' | 'VP8')[];
+    }>;
+
+    export type WidgetStyle = {
+        audioLevelDisplayMode: 'auto' | 'on' | 'off';
+        backgroundImageURI: string;
+        buttonDisplayMode: 'auto' | 'on' | 'off';
+        nameDisplayMode: 'auto' | 'on' | 'off';
+    };
+
+    export type WidgetProperties = {
+        fitMode?: 'cover' | 'contain';
+        insertDefaultUI?: boolean;
+        insertMode?: 'replace' | 'after' | 'before' | 'append';
+        showControls?: boolean;
+        width?: string | number;
+        height?: string | number;
+    };
+
+    export type PublisherStyle = WidgetStyle & {
+        archiveStatusDisplayMode: 'auto' | 'off';
+    };
+
+    export type GetUserMediaProperties = {
+        audioSource?: string | null | boolean | MediaStreamTrack;
+        disableAudioProcessing?: boolean;
+        echoCancellation?: boolean;
+        noiseSuppression?: boolean;
+        autoGainControl?: boolean;
+        facingMode?: 'user' | 'environment' | 'left' | 'right';
+        frameRate?: 30 | 15 | 7 | 1;
+        maxResolution?: Dimensions;
+        resolution?: '1280x960' | '1280x720' | '640x480' | '640x360' | '320x240' | '320x180';
+        videoSource?: string | null | boolean | MediaStreamTrack;
+    };
+
+    export type PublisherProperties = WidgetProperties &
+        GetUserMediaProperties & {
+            audioBitrate?: number;
+            audioFallbackEnabled?: boolean;
+            mirror?: boolean;
+            name?: string;
+            publishAudio?: boolean;
+            publishVideo?: boolean;
+            style?: Partial<PublisherStyle>;
+            videoFilter?: {type?: string; backgroundImgUrl?: string};
+        };
+
+    export type SubscriberStyle = WidgetStyle & {
+        videoDisabledDisplayMode: 'auto' | 'on' | 'off';
+        audioBlockedDisplayMode: 'auto' | 'on' | 'off';
+    };
+
+    export type SubscriberProperties = WidgetProperties & {
+        audioVolume?: number;
+        preferredFrameRate?: number;
+        preferredResolution?: Dimensions;
+        style?: Partial<SubscriberStyle>;
+        subscribeToAudio?: boolean;
+        subscribeToVideo?: boolean;
+        testNetwork?: boolean;
+    };
+
+    export type OpenTokVideoFilter = {
+        type?: string;
+        blurStrength?: string;
+        backgroundImgUrl?: string;
+    };
+
+    export class Connection {
+        connectionId: string;
+        creationTime: number;
+        data: string;
+    }
+
+    export class Stream {
+        connection: Connection;
+        creationTime: number;
+        frameRate: number;
+        hasAudio: boolean;
+        hasVideo: boolean;
+        name: string;
+        streamId: string;
+        videoDimensions: {
+            width: number;
+            height: number;
+        };
+        videoType: 'camera' | 'screen';
+    }
+
+    export type Event<Type, Target> = {
+        type: Type;
+        cancelable: boolean;
+        target: Target;
+
+        isDefaultPrevented(): boolean;
+        preventDefault(): void;
+    };
+
+    export type ExceptionEvent = Event<'exception', {}> & {
+        code: number;
+        message: string;
+        title: string;
+    };
+
+    export type VideoDimensionsChangedEvent<Target> = Event<'videoDimensionsChanged', Target> & {
+        oldValue: Dimensions;
+        newValue: Dimensions;
+    };
+
+    class OTEventEmitter<EventMap> {
+        on<EventName extends keyof EventMap>(
+            eventName: EventName,
+            callback: (event: EventMap[EventName]) => void,
+            context?: object
+        ): void;
+
+        on(eventName: string, callback: (event: Event<string, any>) => void, context?: object): void;
+
+        on(eventMap: object, context?: object): void;
+
+        once<EventName extends keyof EventMap>(
+            eventName: EventName,
+            callback: (event: EventMap[EventName]) => void,
+            context?: object
+        ): void;
+
+        once(eventName: string, callback: (event: Event<string, any>) => void, context?: object): void;
+
+        once(eventMap: object, context?: object): void;
+
+        off<EventName extends keyof EventMap>(
+            eventName?: EventName,
+            callback?: (event: EventMap[EventName]) => void,
+            context?: object
+        ): void;
+
+        off(eventName?: string, callback?: (event: Event<string, any>) => void, context?: object): void;
+
+        off(eventMap: object, context?: object): void;
+    }
+
+    export class Publisher extends OTEventEmitter<{
+        accessAllowed: Event<'accessAllowed', Publisher>;
+        accessDenied: Event<'accessDenied', Publisher>;
+        accessDialogClosed: Event<'accessDialogClosed', Publisher>;
+        accessDialogOpened: Event<'accessDialogOpened', Publisher>;
+
+        audioLevelUpdated: Event<'audioLevelUpdated', Publisher> & {
+            audioLevel: number;
+        };
+
+        destroyed: Event<'destroyed', Publisher>;
+
+        mediaStopped: Event<'mediaStopped', Publisher> & {
+            track: MediaStreamTrack | undefined;
+        };
+
+        streamCreated: Event<'streamCreated', Publisher> & {
+            stream: Stream;
+        };
+
+        streamDestroyed: Event<'streamDestroyed', Publisher> & {
+            stream: Stream;
+            reason: string;
+        };
+
+        videoDimensionsChanged: VideoDimensionsChangedEvent<Publisher>;
+
+        videoElementCreated: Event<'videoElementCreated', Publisher> & {
+            element: HTMLVideoElement | HTMLObjectElement;
+        };
+    }> {
+        accessAllowed: boolean;
+        element?: HTMLElement | undefined;
+        id?: string;
+        stream?: Stream;
+        session?: Session;
+
+        destroy(): void;
+        getImgData(): string | null;
+        getStats(callback: (error?: OTError, stats?: PublisherStatsArr) => void): void;
+        getRtcStatsReport(): Promise<PublisherRtcStatsReportArr>;
+        getStyle(): PublisherStyle;
+        publishAudio(value: boolean): void;
+        publishVideo(value: boolean): void;
+        cycleVideo(): Promise<{deviceId: string}>;
+        setAudioSource(audioSource: string | MediaStreamTrack): Promise<undefined>;
+        getAudioSource(): MediaStreamTrack;
+        setVideoSource(videoSourceId: string): Promise<undefined>;
+        getVideoSource(): {deviceId: string | null; type: string | null; track: MediaStreamTrack | null};
+        setStyle<Style extends keyof PublisherStyle>(style: Style, value: PublisherStyle[Style]): void;
+        videoWidth(): number | undefined;
+        videoHeight(): number | undefined;
+        clearVideoFilter(): Promise<void>;
+        applyVideoFilter(videoFilter?: {type: string; backgroundImgUrl?: string}): Promise<void>;
+        getVideoFilter(): OpenTokVideoFilter;
+    }
+
+    export function getUserMedia(properties?: GetUserMediaProperties): Promise<MediaStream>;
+
+    export function initPublisher(
+        targetElement?: HTMLElement | string,
+        properties?: PublisherProperties,
+        callback?: (error?: OTError) => void
+    ): Publisher;
+
+    export function log(message: string): void;
+
+    export function off(eventName?: 'exception', callback?: (event: ExceptionEvent) => void, context?: object): void;
+
+    export function on(eventName: 'exception', callback: (event: ExceptionEvent) => void, context?: object): void;
+
+    export function once(eventName: 'exception', callback: (event: ExceptionEvent) => void, context?: object): void;
+
+    export class Session extends OTEventEmitter<{
+        archiveStarted: Event<'archiveStarted', Session> & {
+            id: string;
+            name: string;
+        };
+
+        archiveStopped: Event<'archiveStopped', Session> & {
+            id: string;
+            name: string;
+        };
+
+        connectionCreated: Event<'connectionCreated', Session> & {
+            connection: Connection;
+        };
+
+        connectionDestroyed: Event<'connectionDestroyed', Session> & {
+            connection: Connection;
+            reason: string;
+        };
+
+        sessionConnected: Event<'sessionConnected', Session>;
+
+        sessionDisconnected: Event<'sessionDisconnected', Session> & {
+            reason: string;
+        };
+
+        sessionReconnected: Event<'sessionReconnected', Session>;
+        sessionReconnecting: Event<'sessionReconnecting', Session>;
+
+        signal: Event<'signal', Session> & {
+            type?: string;
+            data?: string;
+            from: Connection;
+        };
+
+        streamCreated: Event<'streamCreated', Session> & {
+            stream: Stream;
+        };
+
+        streamDestroyed: Event<'streamDestroyed', Session> & {
+            stream: Stream;
+            reason: string;
+        };
+
+        streamPropertyChanged: Event<'streamPropertyChanged', Session> & {
+            stream: Stream;
+        } & (
+                | {changedProperty: 'hasAudio'; oldValue: boolean; newValue: boolean}
+                | {changedProperty: 'hasVideo'; oldValue: boolean; newValue: boolean}
+                | {changedProperty: 'videoDimensions'; oldValue: Dimensions; newValue: Dimensions}
+            );
+    }> {
+        capabilities: {
+            forceDisconnect: number;
+            forceUnpublish: number;
+            publish: number;
+            subscribe: number;
+        };
+
+        connection?: Connection;
+        sessionId: string;
+
+        connect(token: string, callback: (error?: OTError) => void): void;
+        disconnect(): void;
+        forceDisconnect(connection: Connection, callback: (error?: OTError) => void): void;
+        forceUnpublish(stream: Stream, callback: (error?: OTError) => void): void;
+        getPublisherForStream(stream: Stream): Publisher | undefined;
+        getSubscribersForStream(stream: Stream): [Subscriber];
+        publish(publisher: Publisher, callback?: (error?: OTError) => void): Publisher;
+        publish(
+            targetElement: string | HTMLElement,
+            properties?: PublisherProperties,
+            callback?: (error?: OTError) => void
+        ): Publisher;
+
+        signal(signal: {type?: string; data?: string; to?: Connection}, callback: (error?: OTError) => void): void;
+
+        subscribe(
+            stream: Stream,
+            targetElement?: HTMLElement | string,
+            properties?: SubscriberProperties,
+            callback?: (error?: OTError) => void
+        ): Subscriber;
+
+        unpublish(publisher: Publisher): void;
+        unsubscribe(subscriber: Subscriber): void;
+    }
+
+    export function initSession(
+        partnerId: string,
+        sessionId: string,
+        options?: {
+            connectionEventsSuppressed?: boolean;
+            iceConfig?: {
+                includeServers: 'all' | 'custom';
+                transportPolicy: 'all' | 'relay';
+                customServers: {
+                    urls: string | string[];
+                    username?: string;
+                    credential?: string;
+                }[];
+            };
+            ipWhitelist?: boolean;
+        }
+    ): Session;
+
+    export type IncomingTrackStats = {
+        bytesReceived: number;
+        packetsLost: number;
+        packetsReceived: number;
+    };
+
+    export type OutgoingTrackStats = {
+        bytesSent: number;
+        packetsLost: number;
+        packetsSent: number;
+    };
+
+    export type SubscriberStats = {
+        audio: IncomingTrackStats;
+        video: IncomingTrackStats & {frameRate: number};
+        timestamp: number;
+    };
+
+    export type PublisherStats = {
+        audio: OutgoingTrackStats;
+        video: OutgoingTrackStats & {frameRate: number};
+        timestamp: number;
+    };
+
+    export type PublisherStatContainer = {
+        subscriberId?: string;
+        connectionId?: string;
+        stats: PublisherStats;
+    };
+
+    export type PublisherStatsArr = PublisherStatContainer[];
+
+    export type PublisherRtcStatsReportContainer = {
+        subscriberId?: string;
+        connectionId?: string;
+        rtcStatsReport: RTCStatsReport;
+    };
+
+    export type PublisherRtcStatsReportArr = PublisherRtcStatsReportContainer[];
+
+    export class Subscriber extends OTEventEmitter<{
+        audioLevelUpdated: Event<'audioLevelUpdated', Subscriber> & {
+            audioLevel: number;
+        };
+
+        connected: Event<'connected', Subscriber>;
+
+        destroyed: Event<'destroyed', Subscriber> & {
+            reason: string;
+        };
+
+        videoDimensionsChanged: VideoDimensionsChangedEvent<Subscriber>;
+
+        videoDisabled: Event<'videoDisabled', Subscriber> & {
+            reason: string;
+        };
+
+        videoDisableWarning: Event<'videoDisableWarning', Subscriber>;
+        videoDisableWarningLifted: Event<'videoDisableWarningLifted', Subscriber>;
+
+        videoElementCreated: Event<'videoElementCreated', Subscriber> & {
+            element: HTMLVideoElement | HTMLObjectElement;
+        };
+
+        videoEnabled: Event<'videoEnabled', Subscriber> & {
+            reason: string;
+        };
+    }> {
+        element?: HTMLElement;
+        id?: string;
+        stream?: Stream;
+
+        getAudioVolume(): number;
+        getImgData(): string | null;
+        getStats(callback: (error?: OTError, stats?: SubscriberStats) => void): void;
+        getRtcStatsReport(): Promise<RTCStatsReport>;
+        restrictFrameRate(value: boolean): void;
+        setAudioVolume(volume: number): void;
+        setPreferredFrameRate(frameRate: number): void;
+        setPreferredResolution(resolution: Dimensions): void;
+        subscribeToAudio(value: boolean): void;
+        subscribeToVideo(value: boolean): void;
+
+        setStyle<Style extends keyof SubscriberStyle>(style: Style, value: SubscriberStyle[Style]): void;
+
+        videoHeight(): number | undefined;
+        videoWidth(): number | undefined;
+    }
+
+    export function registerScreenSharingExtension(kind: string, id: string, version: number): void;
+
+    export function reportIssue(callback: (error?: OTError, reportId?: string) => void): void;
+
+    export function setLogLevel(level: number): void;
+
+    export function upgradeSystemRequirements(): void;
+
+    export function unblockAudio(): Promise<undefined>;
+}
+
+declare module '@opentok/client' {
+    export = OT;
+}

package/lib/MultiParty/types.d.ts

@@ -0,0 +1,33 @@
+import { MediaServiceType, MultiPartyCameraTypes } from '../MediaConstants';
+import { VideoFilterType } from '@techsee/techsee-common/lib/constants/account.constants';
+export declare type Credentials = {
+    apiKey: string;
+    sessionId: string;
+    token: string;
+};
+export declare type BrandingSettings = {
+    backgroundImageURI?: string;
+};
+export declare type VideoSettings = {
+    selectedCamera: MultiPartyCameraTypes;
+    cameraEnabled: boolean;
+    startWithAudioMuted: boolean;
+    videoFilter?: VideoFilterType;
+    backgroundReplacementImg?: string;
+};
+export declare type SessionSettings = {
+    videoSettings: VideoSettings;
+    isScreenSharingCapabilitiesEnabled?: boolean;
+    mediaServiceType: MediaServiceType;
+    branding?: BrandingSettings;
+    ipWhitelist?: boolean;
+};
+export interface ClientWebRtcInfo {
+    isWebRTCSupported: boolean;
+    isWebsiteHasWebcamPermissions: boolean;
+    isWebsiteHasMicrophonePermissions: boolean;
+    isGetUserMediaSupported: boolean;
+    isApplyConstraintsSupported: boolean;
+}
+export { ExceptionEvent } from '@opentok/client';
+//# sourceMappingURL=types.d.ts.map

package/lib/MultiParty/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/MultiParty/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,gBAAgB,EAAE,qBAAqB,EAAC,MAAM,mBAAmB,CAAC;AAC1E,OAAO,EAAC,eAAe,EAAC,MAAM,yDAAyD,CAAC;AAExF,oBAAY,WAAW,GAAG;IACtB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF,oBAAY,gBAAgB,GAAG;IAC3B,kBAAkB,CAAC,EAAE,MAAM,CAAC;CAC/B,CAAC;AAEF,oBAAY,aAAa,GAAG;IACxB,cAAc,EAAE,qBAAqB,CAAC;IACtC,aAAa,EAAE,OAAO,CAAC;IACvB,mBAAmB,EAAE,OAAO,CAAC;IAC7B,WAAW,CAAC,EAAE,eAAe,CAAC;IAC9B,wBAAwB,CAAC,EAAE,MAAM,CAAC;CACrC,CAAC;AAEF,oBAAY,eAAe,GAAG;IAC1B,aAAa,EAAE,aAAa,CAAC;IAC7B,kCAAkC,CAAC,EAAE,OAAO,CAAC;IAC7C,gBAAgB,EAAE,gBAAgB,CAAC;IACnC,QAAQ,CAAC,EAAE,gBAAgB,CAAC;IAC5B,WAAW,CAAC,EAAE,OAAO,CAAC;CACzB,CAAC;AAEF,MAAM,WAAW,gBAAgB;IAC7B,iBAAiB,EAAE,OAAO,CAAC;IAC3B,6BAA6B,EAAE,OAAO,CAAC;IACvC,iCAAiC,EAAE,OAAO,CAAC;IAC3C,uBAAuB,EAAE,OAAO,CAAC;IACjC,2BAA2B,EAAE,OAAO,CAAC;CACxC;AAED,OAAO,EAAC,cAAc,EAAC,MAAM,iBAAiB,CAAC"}

package/lib/MultiParty/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/lib/MultiParty/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/MultiParty/types.ts"],"names":[],"mappings":""}

package/lib/MultiParty/utils.d.ts

@@ -0,0 +1,10 @@
+import { MultiPartyCameraTypes, SessionClientRole, VideoTypesEnum } from '../MediaConstants';
+interface IStreamIdentifiers {
+    connectionId: string;
+    videoType: VideoTypesEnum;
+}
+export declare function decodeClientRole(data: string): SessionClientRole;
+export declare function shouldMirrorCamera(isMobile: boolean, selectedCamera: MultiPartyCameraTypes): boolean;
+export declare function isSameStream(s1: IStreamIdentifiers, s2: IStreamIdentifiers): boolean;
+export {};
+//# sourceMappingURL=utils.d.ts.map

package/lib/MultiParty/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/MultiParty/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,qBAAqB,EAAE,iBAAiB,EAAE,cAAc,EAAC,MAAM,mBAAmB,CAAC;AAE3F,UAAU,kBAAkB;IACxB,YAAY,EAAE,MAAM,CAAC;IACrB,SAAS,EAAE,cAAc,CAAC;CAC7B;AAED,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,iBAAiB,CAEhE;AAED,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,OAAO,EAAE,cAAc,EAAE,qBAAqB,WAE1F;AAED,wBAAgB,YAAY,CAAC,EAAE,EAAE,kBAAkB,EAAE,EAAE,EAAE,kBAAkB,GAAG,OAAO,CAEpF"}

package/lib/MultiParty/utils.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSameStream = exports.shouldMirrorCamera = exports.decodeClientRole = void 0;
+var MediaConstants_1 = require("../MediaConstants");
+function decodeClientRole(data) {
+    return JSON.parse(data).clientRole || MediaConstants_1.SessionClientRole.USER;
+}
+exports.decodeClientRole = decodeClientRole;
+function shouldMirrorCamera(isMobile, selectedCamera) {
+    return !isMobile || selectedCamera !== MediaConstants_1.MultiPartyCameraTypes.BACK;
+}
+exports.shouldMirrorCamera = shouldMirrorCamera;
+function isSameStream(s1, s2) {
+    return s1.connectionId === s2.connectionId && s1.videoType === s2.videoType;
+}
+exports.isSameStream = isSameStream;
+//# sourceMappingURL=utils.js.map

package/lib/MultiParty/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../src/MultiParty/utils.ts"],"names":[],"mappings":";;;AAAA,oDAA2F;AAO3F,SAAgB,gBAAgB,CAAC,IAAY;IACzC,OAAO,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,UAAU,IAAI,kCAAiB,CAAC,IAAI,CAAC;AACjE,CAAC;AAFD,4CAEC;AAED,SAAgB,kBAAkB,CAAC,QAAiB,EAAE,cAAqC;IACvF,OAAO,CAAC,QAAQ,IAAI,cAAc,KAAK,sCAAqB,CAAC,IAAI,CAAC;AACtE,CAAC;AAFD,gDAEC;AAED,SAAgB,YAAY,CAAC,EAAsB,EAAE,EAAsB;IACvE,OAAO,EAAE,CAAC,YAAY,KAAK,EAAE,CAAC,YAAY,IAAI,EAAE,CAAC,SAAS,KAAK,EAAE,CAAC,SAAS,CAAC;AAChF,CAAC;AAFD,oCAEC"}

package/lib/TechseeMediaStream.d.ts

@@ -12,3 +12,4 @@ export declare class TechseeMediaStream {
     get mediaTrack(): MediaStreamTrack;
     get streamKind(): KnownMediaStreamKind;
 }
+//# sourceMappingURL=TechseeMediaStream.d.ts.map

package/lib/TechseeMediaStream.d.ts.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/TechseeMediaStream.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,gBAAgB,EAAE,oBAAoB,EAAC,MAAM,kBAAkB,CAAC;AAGxE,qBAAa,kBAAkB;IAC3B,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAmB;IACrD,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAmB;IAC/C,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAU;IACpC,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAc;gBAElC,gBAAgB,EAAE,gBAAgB,EAAE,UAAU,EAAE,gBAAgB,EAAE,QAAQ,EAAE,OAAO;IAQ/F,IAAI,QAAQ,IAAI,OAAO,CAEtB;IAED,IAAI,QAAQ,IAAI,MAAM,CAErB;IAED,IAAI,UAAU,IAAI,gBAAgB,CAEjC;IAED,IAAI,WAAW,IAAI,WAAW,CAE7B;IAED,IAAI,UAAU,IAAI,gBAAgB,CAEjC;IAED,IAAI,UAAU,IAAI,oBAAoB,CAErC;CACJ","file":"TechseeMediaStream.d.ts","sourcesContent":["import {KnownMediaStream, KnownMediaStreamKind} from './MediaConstants';\n\n\nexport class TechseeMediaStream {\n    private readonly _mediaStreamTrack: MediaStreamTrack;\n    private readonly _streamType: KnownMediaStream;\n    private readonly _isRemote: boolean;\n    private readonly dedicatedStream: MediaStream;\n\n    constructor(mediaStreamTrack: MediaStreamTrack, streamType: KnownMediaStream, isRemote: boolean) {\n        this._isRemote = isRemote;\n        this._streamType = streamType;\n        this._mediaStreamTrack = mediaStreamTrack;\n\n        this.dedicatedStream = new MediaStream([mediaStreamTrack]);\n    }\n\n    get isRemote(): boolean {\n        return this._isRemote;\n    }\n\n    get streamId(): string {\n        return this._mediaStreamTrack.id;\n    }\n\n    get streamType(): KnownMediaStream {\n        return this._streamType;\n    }\n\n    get mediaStream(): MediaStream {\n        return this.dedicatedStream;\n    }\n\n    get mediaTrack(): MediaStreamTrack {\n        return this._mediaStreamTrack;\n    }\n\n    get streamKind(): KnownMediaStreamKind {\n        return this._mediaStreamTrack.kind as any;\n    }\n}\n"]}
+{"version":3,"file":"TechseeMediaStream.d.ts","sourceRoot":"","sources":["../src/TechseeMediaStream.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,gBAAgB,EAAE,oBAAoB,EAAC,MAAM,kBAAkB,CAAC;AAExE,qBAAa,kBAAkB;IAC3B,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAmB;IACrD,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAmB;IAC/C,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAU;IACpC,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAc;gBAElC,gBAAgB,EAAE,gBAAgB,EAAE,UAAU,EAAE,gBAAgB,EAAE,QAAQ,EAAE,OAAO;IAQ/F,IAAI,QAAQ,IAAI,OAAO,CAEtB;IAED,IAAI,QAAQ,IAAI,MAAM,CAErB;IAED,IAAI,UAAU,IAAI,gBAAgB,CAEjC;IAED,IAAI,WAAW,IAAI,WAAW,CAE7B;IAED,IAAI,UAAU,IAAI,gBAAgB,CAEjC;IAED,IAAI,UAAU,IAAI,oBAAoB,CAErC;CACJ"}

package/lib/TechseeMediaStream.js

@@ -1,8 +1,7 @@
 "use strict";
-
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TechseeMediaStream = void 0;
-var TechseeMediaStream = /** @class */function () {
+var TechseeMediaStream = (function () {
     function TechseeMediaStream(mediaStreamTrack, streamType, isRemote) {
         this._isRemote = isRemote;
         this._streamType = streamType;
@@ -10,50 +9,48 @@ var TechseeMediaStream = /** @class */function () {
         this.dedicatedStream = new MediaStream([mediaStreamTrack]);
     }
     Object.defineProperty(TechseeMediaStream.prototype, "isRemote", {
-        get: function get() {
+        get: function () {
             return this._isRemote;
         },
         enumerable: false,
         configurable: true
     });
     Object.defineProperty(TechseeMediaStream.prototype, "streamId", {
-        get: function get() {
+        get: function () {
             return this._mediaStreamTrack.id;
         },
         enumerable: false,
         configurable: true
     });
     Object.defineProperty(TechseeMediaStream.prototype, "streamType", {
-        get: function get() {
+        get: function () {
             return this._streamType;
         },
         enumerable: false,
         configurable: true
     });
     Object.defineProperty(TechseeMediaStream.prototype, "mediaStream", {
-        get: function get() {
+        get: function () {
             return this.dedicatedStream;
         },
         enumerable: false,
         configurable: true
     });
     Object.defineProperty(TechseeMediaStream.prototype, "mediaTrack", {
-        get: function get() {
+        get: function () {
             return this._mediaStreamTrack;
         },
         enumerable: false,
         configurable: true
     });
     Object.defineProperty(TechseeMediaStream.prototype, "streamKind", {
-        get: function get() {
+        get: function () {
             return this._mediaStreamTrack.kind;
         },
         enumerable: false,
         configurable: true
     });
     return TechseeMediaStream;
-}();
+}());
 exports.TechseeMediaStream = TechseeMediaStream;
-
-//# sourceMappingURL=TechseeMediaStream.js.map
-//# sourceMappingURL=TechseeMediaStream.js.map
+//# sourceMappingURL=TechseeMediaStream.js.map

package/lib/TechseeMediaStream.js.map

@@ -1 +1 @@
-{"version":3,"sources":["TechseeMediaStream.js","../src/TechseeMediaStream.ts"],"names":["Object","defineProperty","exports","value","TechseeMediaStream","mediaStreamTrack","streamType","isRemote","_isRemote","_streamType","_mediaStreamTrack","dedicatedStream","MediaStream","prototype","get","enumerable","configurable","id","kind"],"mappings":"AAAA;;AACAA,OAAOC,cAAP,CAAsBC,OAAtB,EAA+B,YAA/B,EAA6C,EAAEC,OAAO,IAAT,EAA7C;AACAD,QAAQE,kBAAR,GAA6B,KAAK,CAAlC;ACCA,IAAAA,qBAAA,aAAA,YAAA;AAMI,aAAAA,kBAAA,CAAYC,gBAAZ,EAAgDC,UAAhD,EAA8EC,QAA9E,EAA+F;AAC3F,aAAKC,SAAL,GAAiBD,QAAjB;AACA,aAAKE,WAAL,GAAmBH,UAAnB;AACA,aAAKI,iBAAL,GAAyBL,gBAAzB;AAEA,aAAKM,eAAL,GAAuB,IAAIC,WAAJ,CAAgB,CAACP,gBAAD,CAAhB,CAAvB;AACH;AAEDL,WAAAC,cAAA,CAAIG,mBAAAS,SAAJ,EAAI,UAAJ,EAAY;ADNRC,aCMJ,eAAA;AACI,mBAAO,KAAKN,SAAZ;AACH,SAFW;ADHRO,oBAAY,KCGJ;ADFRC,sBAAc;ACEN,KAAZ;AAIAhB,WAAAC,cAAA,CAAIG,mBAAAS,SAAJ,EAAI,UAAJ,EAAY;ADHRC,aCGJ,eAAA;AACI,mBAAO,KAAKJ,iBAAL,CAAuBO,EAA9B;AACH,SAFW;ADARF,oBAAY,KCAJ;ADCRC,sBAAc;ACDN,KAAZ;AAIAhB,WAAAC,cAAA,CAAIG,mBAAAS,SAAJ,EAAI,YAAJ,EAAc;ADAVC,aCAJ,eAAA;AACI,mBAAO,KAAKL,WAAZ;AACH,SAFa;ADGVM,oBAAY,KCHF;ADIVC,sBAAc;ACJJ,KAAd;AAIAhB,WAAAC,cAAA,CAAIG,mBAAAS,SAAJ,EAAI,aAAJ,EAAe;ADGXC,aCHJ,eAAA;AACI,mBAAO,KAAKH,eAAZ;AACH,SAFc;ADMXI,oBAAY,KCND;ADOXC,sBAAc;ACPH,KAAf;AAIAhB,WAAAC,cAAA,CAAIG,mBAAAS,SAAJ,EAAI,YAAJ,EAAc;ADMVC,aCNJ,eAAA;AACI,mBAAO,KAAKJ,iBAAZ;AACH,SAFa;ADSVK,oBAAY,KCTF;ADUVC,sBAAc;ACVJ,KAAd;AAIAhB,WAAAC,cAAA,CAAIG,mBAAAS,SAAJ,EAAI,YAAJ,EAAc;ADSVC,aCTJ,eAAA;AACI,mBAAO,KAAKJ,iBAAL,CAAuBQ,IAA9B;AACH,SAFa;ADYVH,oBAAY,KCZF;ADaVC,sBAAc;ACbJ,KAAd;AAGJ,WAAAZ,kBAAA;AArCA,CAAA,EAAA;AAAaF,QAAAE,kBAAA,GAAAA,kBAAA;;ADqDb","file":"TechseeMediaStream.js","sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.TechseeMediaStream = void 0;\nvar TechseeMediaStream = /** @class */ (function () {\n    function TechseeMediaStream(mediaStreamTrack, streamType, isRemote) {\n        this._isRemote = isRemote;\n        this._streamType = streamType;\n        this._mediaStreamTrack = mediaStreamTrack;\n        this.dedicatedStream = new MediaStream([mediaStreamTrack]);\n    }\n    Object.defineProperty(TechseeMediaStream.prototype, \"isRemote\", {\n        get: function () {\n            return this._isRemote;\n        },\n        enumerable: false,\n        configurable: true\n    });\n    Object.defineProperty(TechseeMediaStream.prototype, \"streamId\", {\n        get: function () {\n            return this._mediaStreamTrack.id;\n        },\n        enumerable: false,\n        configurable: true\n    });\n    Object.defineProperty(TechseeMediaStream.prototype, \"streamType\", {\n        get: function () {\n            return this._streamType;\n        },\n        enumerable: false,\n        configurable: true\n    });\n    Object.defineProperty(TechseeMediaStream.prototype, \"mediaStream\", {\n        get: function () {\n            return this.dedicatedStream;\n        },\n        enumerable: false,\n        configurable: true\n    });\n    Object.defineProperty(TechseeMediaStream.prototype, \"mediaTrack\", {\n        get: function () {\n            return this._mediaStreamTrack;\n        },\n        enumerable: false,\n        configurable: true\n    });\n    Object.defineProperty(TechseeMediaStream.prototype, \"streamKind\", {\n        get: function () {\n            return this._mediaStreamTrack.kind;\n        },\n        enumerable: false,\n        configurable: true\n    });\n    return TechseeMediaStream;\n}());\nexports.TechseeMediaStream = TechseeMediaStream;\n\n//# sourceMappingURL=TechseeMediaStream.js.map\n","import {KnownMediaStream, KnownMediaStreamKind} from './MediaConstants';\n\n\nexport class TechseeMediaStream {\n    private readonly _mediaStreamTrack: MediaStreamTrack;\n    private readonly _streamType: KnownMediaStream;\n    private readonly _isRemote: boolean;\n    private readonly dedicatedStream: MediaStream;\n\n    constructor(mediaStreamTrack: MediaStreamTrack, streamType: KnownMediaStream, isRemote: boolean) {\n        this._isRemote = isRemote;\n        this._streamType = streamType;\n        this._mediaStreamTrack = mediaStreamTrack;\n\n        this.dedicatedStream = new MediaStream([mediaStreamTrack]);\n    }\n\n    get isRemote(): boolean {\n        return this._isRemote;\n    }\n\n    get streamId(): string {\n        return this._mediaStreamTrack.id;\n    }\n\n    get streamType(): KnownMediaStream {\n        return this._streamType;\n    }\n\n    get mediaStream(): MediaStream {\n        return this.dedicatedStream;\n    }\n\n    get mediaTrack(): MediaStreamTrack {\n        return this._mediaStreamTrack;\n    }\n\n    get streamKind(): KnownMediaStreamKind {\n        return this._mediaStreamTrack.kind as any;\n    }\n}\n"]}
+{"version":3,"file":"TechseeMediaStream.js","sourceRoot":"","sources":["../src/TechseeMediaStream.ts"],"names":[],"mappings":";;;AAEA;IAMI,4BAAY,gBAAkC,EAAE,UAA4B,EAAE,QAAiB;QAC3F,IAAI,CAAC,SAAS,GAAG,QAAQ,CAAC;QAC1B,IAAI,CAAC,WAAW,GAAG,UAAU,CAAC;QAC9B,IAAI,CAAC,iBAAiB,GAAG,gBAAgB,CAAC;QAE1C,IAAI,CAAC,eAAe,GAAG,IAAI,WAAW,CAAC,CAAC,gBAAgB,CAAC,CAAC,CAAC;IAC/D,CAAC;IAED,sBAAI,wCAAQ;aAAZ;YACI,OAAO,IAAI,CAAC,SAAS,CAAC;QAC1B,CAAC;;;OAAA;IAED,sBAAI,wCAAQ;aAAZ;YACI,OAAO,IAAI,CAAC,iBAAiB,CAAC,EAAE,CAAC;QACrC,CAAC;;;OAAA;IAED,sBAAI,0CAAU;aAAd;YACI,OAAO,IAAI,CAAC,WAAW,CAAC;QAC5B,CAAC;;;OAAA;IAED,sBAAI,2CAAW;aAAf;YACI,OAAO,IAAI,CAAC,eAAe,CAAC;QAChC,CAAC;;;OAAA;IAED,sBAAI,0CAAU;aAAd;YACI,OAAO,IAAI,CAAC,iBAAiB,CAAC;QAClC,CAAC;;;OAAA;IAED,sBAAI,0CAAU;aAAd;YACI,OAAO,IAAI,CAAC,iBAAiB,CAAC,IAAW,CAAC;QAC9C,CAAC;;;OAAA;IACL,yBAAC;AAAD,CAAC,AArCD,IAqCC;AArCY,gDAAkB"}

package/lib/qos/raw-qos.d.ts

@@ -0,0 +1,29 @@
+export class RawQos {
+    VIDEO_CODECS: string[] | undefined;
+    rawQoSEntry: {} | undefined;
+    enableRawEntries: boolean | undefined;
+    bytesPrev: any;
+    timestampPrev: any;
+    startTimestamp: any;
+    parse(stats: any): {};
+    track: any;
+    _parseRelated(stats: any, stat: any, self: any): void;
+    _clearRaw(): void;
+    _addRaw(item: any): void;
+    _parseServerStats(result: any, parent: any, stats: any): void;
+    _parseCodec(result: any, parent: any): void;
+    _parseLocal(result: any, parent: any): void;
+    _parseRemote(result: any, parent: any): void;
+    _parseTrack(result: any, parent: any): void;
+    _parseOutStats(result: any, parent: any): void;
+    _parseVideoDuration(result: any, parent: any): void;
+    _parseInStats(result: any, parent: any): void;
+    _saveSomeMetrics(parent: any, result: any): void;
+    ssrcPrev: any;
+    framesDecodedPrev: any;
+    _parseOther(result: any, parent: any): void;
+    _parseBitrate(result: any, parent: any, bytes: any): void;
+    _parseFrameRate(result: any, parent: any, bytes: any): void;
+    _dumpItem(res: any): string;
+}
+//# sourceMappingURL=raw-qos.d.ts.map