@webex/jsdoctrinetest 3.0.0-bnr.5 → 3.0.0

package/dist/types/@webex/plugin-meetings/src/metrics/index.d.ts

@@ -1,160 +0,0 @@
-/**
- * @description Metrics handles all the call metrics events
- * @export
- * @class Metrics
- */
-declare class Metrics {
-    static instance: Metrics;
-    _events: any;
-    keys: any;
-    meetingCollection: any;
-    webex: any;
-    /**
-     * Create Metrics Object
-     * @constructor
-     * @public
-     * @memberof Meetings
-     */
-    constructor();
-    /**
-     * Initializes the Metrics singleton with a meeting Collection.
-     *
-     * @param {Object} meetingCollection meetings object
-     * @param {Object} webex  webex SDK object
-     *
-     * @returns {void}
-     */
-    initialSetup(meetingCollection: object, webex: object): void;
-    /**
-     * poste Meeting event metrics
-     * @param {object} options {meetingId/meeting} as a json object
-     * @param {Meeting} options.meeting Meeting object
-     * @param {String} options.meetingId
-     * @param {object} options.data
-     * @param {object} options.event
-     * @returns {object} null
-     */
-    postEvent(options: {
-        meeting?: any;
-        meetingId?: string;
-        data?: object;
-        event?: any;
-    } | any): void;
-    /**
-     *  Docs for Call analyzer metrics
-     *   https://sqbu-github.cisco.com/WebExSquared/call-analyzer/wiki
-     *   https://sqbu-github.cisco.com/WebExSquared/event-dictionary/blob/master/diagnostic-events.raml
-     */
-    initPayload(eventType: any, identifiers: any, options: any): any;
-    /**
-     * returns metrics friendly OS versions
-     * @param {String} osName Os name
-     * @returns {String}
-     * @private
-     * @memberof Metrics
-     */
-    private getOsName;
-    /**
-     * get the payload specific for a media quality event through call analyzer
-     * @param {String} eventType the event name
-     * @param {Object} identifiers contains the identifiers needed for CA
-     * @param {String} identifiers.correlationId
-     * @param {String} identifiers.locusUrl
-     * @param {String} identifiers.locusId
-     * @param {Object} options
-     * @param {Object} options.intervalData
-     * @param {String} options.clientType
-     * @returns {Object}
-     * @public
-     * @memberof Metrics
-     */
-    initMediaPayload(eventType: string, identifiers: {
-        correlationId: string;
-        locusUrl: string;
-        locusId: string;
-    }, options?: {
-        intervalData: object;
-        clientType: string;
-    } | any): {
-        eventId: any;
-        version: number;
-        origin: {
-            audioSetupDelay: any;
-            videoSetupDelay: any;
-            name: string;
-            networkType: any;
-            userAgent: string;
-            clientInfo: {
-                clientType: any;
-                clientVersion: string;
-                localNetworkPrefix: string;
-                os: any;
-                osVersion: any;
-                subClientType: any;
-                browser: any;
-                browserVersion: any;
-            };
-        };
-        originTime: {
-            triggered: string;
-        };
-        senderCountryCode: any;
-        event: {
-            name: string;
-            canProceed: boolean;
-            identifiers: {
-                correlationId: string;
-                locusUrl: string;
-                locusId: string;
-            };
-            intervals: any[];
-            joinTimes: any;
-            eventData: {
-                webClientDomain: any;
-            };
-            sourceMetadata: {
-                applicationSoftwareType: string;
-                applicationSoftwareVersion: any;
-                mediaEngineSoftwareType: any;
-                mediaEngineSoftwareVersion: any;
-                startTime: string;
-            };
-        };
-    };
-    /**
-     * This function Parses a Locus error and returns a diagnostic event payload.
-     * It should keep updating from:
-     * https://sqbu-github.cisco.com/WebExSquared/spark-client-framework/blob/master/spark-client-framework/Adapters/TelephonyAdapter/TelephonyAdapter.cpp#L920
-     *
-     * @param {Object} err the error Object from Locus response
-     * @param {boolean} showToUser true if a toast is shown to user
-     * @returns {{showToUser: boolean, category: string, errorDescription: string,
-     *  errorCode: number, errorData: *, fatal: boolean, name: string}}
-     */
-    parseLocusError(err: any, showToUser: boolean): any;
-    generateErrorPayload(errorCode: any, shownToUser: any, name: any, err: any): any;
-    /**
-     * Returns a formated string of the user agent.
-     *
-     * @returns {string} formatted user agent information
-     */
-    userAgentToString(): string;
-    /**
-     * Uploads given metric to the Metrics service as an Behavioral metric.
-     * Metadata about the environment such as browser, OS, SDK and their versions
-     * are automatically added when the metric is sent.
-     *
-     * The Metrics service will send an Behavioral metric to InfluxDB for
-     * aggregation.
-     * See https://confluence-eng-gpk2.cisco.com/conf/display/WBXT/Getting+started+with+Metrics+Service.
-     *
-     * @param {string} metricName  Name of the metric (measurement) to send
-     * @param {Object} metricFields  Key-valye pairs of data or values about this metric
-     * @param {Object} metricTags  Key-value pairs of metric metadata
-     *
-     * @returns {void}
-     */
-    sendBehavioralMetric(metricName: string, metricFields?: object, metricTags?: object): void;
-}
-declare const instance: Metrics;
-export default instance;

package/dist/types/@webex/plugin-meetings/src/multistream/mediaRequestManager.d.ts

@@ -1,51 +0,0 @@
-import { MediaRequest as WcmeMediaRequest } from '@webex/internal-media-core';
-import { ReceiveSlot } from './receiveSlot';
-export interface ActiveSpeakerPolicyInfo {
-    policy: 'active-speaker';
-    priority: number;
-    crossPriorityDuplication: boolean;
-    crossPolicyDuplication: boolean;
-    preferLiveVideo: boolean;
-}
-export interface ReceiverSelectedPolicyInfo {
-    policy: 'receiver-selected';
-    csi: number;
-}
-export type PolicyInfo = ActiveSpeakerPolicyInfo | ReceiverSelectedPolicyInfo;
-export interface H264CodecInfo {
-    codec: 'h264';
-    maxFs?: number;
-    maxFps?: number;
-    maxMbps?: number;
-    maxWidth?: number;
-    maxHeight?: number;
-}
-export type CodecInfo = H264CodecInfo;
-export interface MediaRequest {
-    policyInfo: PolicyInfo;
-    receiveSlots: Array<ReceiveSlot>;
-    codecInfo?: CodecInfo;
-}
-export type MediaRequestId = string;
-type DegradationPreferences = {
-    maxMacroblocksLimit: number;
-};
-type SendMediaRequestsCallback = (mediaRequests: WcmeMediaRequest[]) => void;
-export declare class MediaRequestManager {
-    private sendMediaRequestsCallback;
-    private counter;
-    private clientRequests;
-    private slotsActiveInLastMediaRequest;
-    private degradationPreferences;
-    private sourceUpdateListener;
-    constructor(degradationPreferences: DegradationPreferences, sendMediaRequestsCallback: SendMediaRequestsCallback);
-    private resetInactiveReceiveSlots;
-    setDegradationPreferences(degradationPreferences: DegradationPreferences): void;
-    private getDegradedClientRequests;
-    private sendRequests;
-    addRequest(mediaRequest: MediaRequest, commit?: boolean): MediaRequestId;
-    cancelRequest(requestId: MediaRequestId, commit?: boolean): void;
-    commit(): void;
-    reset(): void;
-}
-export {};

package/dist/types/@webex/plugin-meetings/src/multistream/receiveSlot.d.ts

@@ -1,66 +0,0 @@
-import { MediaType, ReceiveSlot as WcmeReceiveSlot, SourceState } from '@webex/internal-media-core';
-import EventsScope from '../common/events/events-scope';
-export declare const ReceiveSlotEvents: {
-    SourceUpdate: string;
-};
-export type { SourceState } from '@webex/internal-media-core';
-export type CSI = number;
-export type MemberId = string;
-export type ReceiveSlotId = string;
-export type FindMemberIdCallback = (csi: CSI) => MemberId | undefined;
-/**
- * Class representing a receive slot. A single receive slot is able to receive a single track
- * for example some participant's main video or audio
- */
-export declare class ReceiveSlot extends EventsScope {
-    #private;
-    private readonly mcReceiveSlot;
-    private readonly findMemberIdCallback;
-    readonly id: ReceiveSlotId;
-    readonly mediaType: MediaType;
-    /**
-     * constructor - don't use it directly, you should always use meeting.receiveSlotManager.allocateSlot()
-     * to create any receive slots
-     *
-     * @param {MediaType} mediaType
-     * @param {ReceiveSlot} mcReceiveSlot
-     * @param {FindMemberIdCallback} findMemberIdCallback callback for finding memberId for given CSI
-     */
-    constructor(mediaType: MediaType, mcReceiveSlot: WcmeReceiveSlot, findMemberIdCallback: FindMemberIdCallback);
-    /**
-     * Getter for memberId
-     */
-    get memberId(): string;
-    /**
-     * Getter for csi
-     */
-    get csi(): number;
-    /**
-     * Getter for sourceState
-     */
-    get sourceState(): SourceState;
-    /**
-     * registers event handlers with the underlying ReceiveSlot
-     */
-    private setupEventListeners;
-    /** Tries to find the member id for this receive slot if it hasn't got one */
-    findMemberId(): void;
-    /**
-     * The MediaStream object associated with this slot.
-     *
-     * @returns {MediaStream} The MediaStreamTrack.
-     */
-    get stream(): MediaStream;
-    /**
-     * The underlying WCME receive slot
-     */
-    get wcmeReceiveSlot(): WcmeReceiveSlot;
-    /**
-     * Resets the source state to the default 'no source' value.
-     * This function should be called on receive slots that are
-     * no longer part of a media request. It's needed because WCME
-     * does not send any more events on such slots, so the sourceState
-     * value would not represent the truth anymore.
-     */
-    resetSourceState(): void;
-}

package/dist/types/@webex/plugin-meetings/src/multistream/receiveSlotManager.d.ts

@@ -1,46 +0,0 @@
-import { MediaType } from '@webex/internal-media-core';
-import { ReceiveSlot } from './receiveSlot';
-/**
- * Manages all receive slots used by a meeting. WMCE receive slots cannot be ever deleted,
- * so this manager has a pool in order to re-use the slots that were released earlier.
- */
-export declare class ReceiveSlotManager {
-    private allocatedSlots;
-    private freeSlots;
-    private meeting;
-    /**
-     * Constructor
-     * @param {Meeting} meeting
-     */
-    constructor(meeting: any);
-    /**
-     * Creates a new receive slot or returns one from the existing pool of free slots
-     *
-     * @param {MediaType} mediaType
-     * @returns {Promise<ReceiveSlot>}
-     */
-    allocateSlot(mediaType: MediaType): Promise<ReceiveSlot>;
-    /**
-     * Releases the slot back to the pool so it can be re-used by others in the future
-     * @param {ReceiveSlot} slot
-     */
-    releaseSlot(slot: ReceiveSlot): void;
-    /**
-     * Resets the slot manager - this method should be called when the media connection is torn down
-     */
-    reset(): void;
-    /**
-     * Returns statistics about the managed slots
-     *
-     * @returns {Object}
-     */
-    getStats(): {
-        numAllocatedSlots: {};
-        numFreeSlots: {};
-    };
-    /**
-     * Tries to find the member id on all allocated receive slots
-     * This function should be called when new members are added to the meeting.
-     */
-    updateMemberIds(): void;
-}

package/dist/types/@webex/plugin-meetings/src/multistream/remoteMedia.d.ts

@@ -1,93 +0,0 @@
-import { MediaType, SourceState } from '@webex/internal-media-core';
-import EventsScope from '../common/events/events-scope';
-import { MediaRequestManager } from './mediaRequestManager';
-import { CSI, ReceiveSlot } from './receiveSlot';
-export declare const RemoteMediaEvents: {
-    SourceUpdate: string;
-    Stopped: string;
-};
-export type RemoteVideoResolution = 'thumbnail' | 'very small' | 'small' | 'medium' | 'large' | 'best';
-/**
- * Converts pane size into h264 maxFs
- * @param {PaneSize} paneSize
- * @returns {number}
- */
-export declare function getMaxFs(paneSize: RemoteVideoResolution): number;
-type Options = {
-    resolution?: RemoteVideoResolution;
-};
-export type RemoteMediaId = string;
-/**
- * Class representing a remote audio/video stream.
- *
- * Internally it is associated with a specific receive slot
- * and a media request for it.
- */
-export declare class RemoteMedia extends EventsScope {
-    private receiveSlot?;
-    private readonly mediaRequestManager;
-    private readonly options;
-    private mediaRequestId?;
-    readonly id: RemoteMediaId;
-    /**
-     * Constructs RemoteMedia instance
-     *
-     * @param receiveSlot
-     * @param mediaRequestManager
-     * @param options
-     */
-    constructor(receiveSlot: ReceiveSlot, mediaRequestManager: MediaRequestManager, options?: Options);
-    /**
-     * Invalidates the remote media by clearing the reference to a receive slot and
-     * cancelling the media request.
-     * After this call the remote media is unusable.
-     *
-     * @param {boolean} commit - whether to commit the cancellation of the media request
-     * @internal
-     */
-    stop(commit?: boolean): void;
-    /**
-     * Sends a new media request. This method can only be used for receiver-selected policy,
-     * because only in that policy we have a 1-1 relationship between RemoteMedia and MediaRequest
-     * and the request id is then stored in this RemoteMedia instance.
-     * For active-speaker policy, the same request is shared among many RemoteMedia instances,
-     * so it's managed through RemoteMediaGroup
-     *
-     * @internal
-     */
-    sendMediaRequest(csi: CSI, commit: boolean): void;
-    /**
-     * @internal
-     */
-    cancelMediaRequest(commit: boolean): void;
-    /**
-     * registers event listeners on the receive slot and forwards all the events
-     */
-    private setupEventListeners;
-    /**
-     * Getter for mediaType
-     */
-    get mediaType(): MediaType;
-    /**
-     * Getter for memberId
-     */
-    get memberId(): string;
-    /**
-     * Getter for csi
-     */
-    get csi(): number;
-    /**
-     * Getter for source state
-     */
-    get sourceState(): SourceState;
-    /**
-     * Getter for remote media stream
-     */
-    get stream(): MediaStream;
-    /**
-     * @internal
-     * @returns {ReceiveSlot}
-     */
-    getUnderlyingReceiveSlot(): ReceiveSlot;
-}
-export {};

package/dist/types/@webex/plugin-meetings/src/multistream/remoteMediaGroup.d.ts

@@ -1,56 +0,0 @@
-import { RemoteMedia, RemoteVideoResolution } from './remoteMedia';
-import { MediaRequestManager } from './mediaRequestManager';
-import { CSI, ReceiveSlot } from './receiveSlot';
-type Options = {
-    resolution?: RemoteVideoResolution;
-    preferLiveVideo?: boolean;
-};
-export declare class RemoteMediaGroup {
-    private mediaRequestManager;
-    private priority;
-    private options;
-    private unpinnedRemoteMedia;
-    private mediaRequestId?;
-    private pinnedRemoteMedia;
-    constructor(mediaRequestManager: MediaRequestManager, receiveSlots: ReceiveSlot[], priority: number, commitMediaRequest: boolean, options?: Options);
-    /**
-     * Gets the array of remote media elements from the group
-     *
-     * @param {string} filter - 'all' (default) returns both pinned and unpinned
-     * @returns {Array<RemoteMedia>}
-     */
-    getRemoteMedia(filter?: 'all' | 'pinned' | 'unpinned'): RemoteMedia[];
-    /**
-     * Pins a specific remote media instance to a specfic CSI, so the media will
-     * no longer come from active speaker, but from that CSI.
-     * If no CSI is given, the current CSI value is used.
-     *
-     */
-    pin(remoteMedia: RemoteMedia, csi?: CSI): void;
-    /**
-     * Unpins a remote media instance, so that it will again provide media from active speakers
-     *
-     */
-    unpin(remoteMedia: RemoteMedia): void;
-    isPinned(remoteMedia: RemoteMedia): boolean;
-    private sendActiveSpeakerMediaRequest;
-    private cancelActiveSpeakerMediaRequest;
-    /**
-     * Invalidates the remote media group by clearing the references to the receive slots
-     * used by all remote media from that group and cancelling all media requests.
-     * After this call the remote media group is unusable.
-     *
-     * @param{boolean} commit whether to commit the cancellation of media requests
-     * @internal
-     */
-    stop(commit?: boolean): void;
-    /**
-     * Checks if a given RemoteMedia instance belongs to this group.
-     *
-     * @param remoteMedia RemoteMedia instance to check
-     * @param filter controls which remote media from the group to check
-     * @returns true if remote media is found
-     */
-    includes(remoteMedia: RemoteMedia, filter?: 'all' | 'pinned' | 'unpinned'): boolean;
-}
-export {};