@signalwire/js 1.3.0-dev.1 → 1.4.0

package/dist/esm/common/src/webrtc/helpers.js

@@ -7,23 +7,11 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-var __rest = (this && this.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-};
 import logger from '../util/logger';
 import * as WebRTC from '../util/webrtc';
-import { roundToFixed } from '../util/helpers';
-import { assureDeviceId } from './deviceHelpers';
+import { isDefined } from '../util/helpers';
 import { DeviceType } from './constants';
-export const getUserMedia = (constraints) => __awaiter(void 0, void 0, void 0, function* () {
+const getUserMedia = (constraints) => __awaiter(void 0, void 0, void 0, function* () {
     logger.info('RTCService.getUserMedia', constraints);
     const { audio, video } = constraints;
     if (!audio && !video) {
@@ -37,15 +25,58 @@ export const getUserMedia = (constraints) => __awaiter(void 0, void 0, void 0, f
         throw error;
     }
 });
-export const removeUnsupportedConstraints = (constraints) => {
-    const supported = WebRTC.getSupportedConstraints();
-    Object.keys(constraints).map(key => {
-        if (!supported.hasOwnProperty(key) || constraints[key] === null || constraints[key] === undefined) {
-            delete constraints[key];
+const _constraintsByKind = (kind = null) => {
+    return {
+        audio: !kind || kind === DeviceType.AudioIn,
+        video: !kind || kind === DeviceType.Video
+    };
+};
+const getDevices = (kind = null, fullList = false) => __awaiter(void 0, void 0, void 0, function* () {
+    let devices = yield WebRTC.enumerateDevices().catch(error => []);
+    if (kind) {
+        devices = devices.filter((d) => d.kind === kind);
+    }
+    const valid = devices.length && devices.every((d) => (d.deviceId && d.label));
+    if (!valid) {
+        const stream = yield WebRTC.getUserMedia(_constraintsByKind(kind));
+        WebRTC.stopStream(stream);
+        return getDevices(kind);
+    }
+    if (fullList === true) {
+        return devices;
+    }
+    const found = [];
+    devices = devices.filter(({ kind, groupId }) => {
+        if (!groupId) {
+            return true;
         }
+        const key = `${kind}-${groupId}`;
+        if (!found.includes(key)) {
+            found.push(key);
+            return true;
+        }
+        return false;
     });
-};
-export const getMediaConstraints = (options) => __awaiter(void 0, void 0, void 0, function* () {
+    return devices;
+});
+const resolutionList = [[320, 240], [640, 360], [640, 480], [1280, 720], [1920, 1080]];
+const scanResolutions = (deviceId) => __awaiter(void 0, void 0, void 0, function* () {
+    const supported = [];
+    const stream = yield getUserMedia({ video: { deviceId: { exact: deviceId } } });
+    const videoTrack = stream.getVideoTracks()[0];
+    for (let i = 0; i < resolutionList.length; i++) {
+        const [width, height] = resolutionList[i];
+        const success = yield videoTrack.applyConstraints({ width: { exact: width }, height: { exact: height } })
+            .then(() => true)
+            .catch(() => false);
+        if (success) {
+            supported.push({ resolution: `${width}x${height}`, width, height });
+        }
+    }
+    WebRTC.stopStream(stream);
+    return supported;
+});
+const getMediaConstraints = (options) => __awaiter(void 0, void 0, void 0, function* () {
     let { audio = true, micId } = options;
     const { micLabel = '' } = options;
     if (micId) {
@@ -70,7 +101,85 @@ export const getMediaConstraints = (options) => __awaiter(void 0, void 0, void 0
     }
     return { audio, video };
 });
-export const destructSubscribeResponse = (response) => {
+const assureDeviceId = (id, label, kind) => __awaiter(void 0, void 0, void 0, function* () {
+    const devices = yield getDevices(kind, true);
+    for (let i = 0; i < devices.length; i++) {
+        const { deviceId, label: deviceLabel } = devices[i];
+        if (id === deviceId || label === deviceLabel) {
+            return deviceId;
+        }
+    }
+    return null;
+});
+const removeUnsupportedConstraints = (constraints) => {
+    const supported = WebRTC.getSupportedConstraints();
+    Object.keys(constraints).map(key => {
+        if (!supported.hasOwnProperty(key) || constraints[key] === null || constraints[key] === undefined) {
+            delete constraints[key];
+        }
+    });
+};
+const checkDeviceIdConstraints = (id, label, kind, constraints) => __awaiter(void 0, void 0, void 0, function* () {
+    const { deviceId } = constraints;
+    if (!isDefined(deviceId) && (id || label)) {
+        const deviceId = yield assureDeviceId(id, label, kind).catch(error => null);
+        if (deviceId) {
+            constraints.deviceId = { exact: deviceId };
+        }
+    }
+    return constraints;
+});
+const sdpStereoHack = (sdp) => {
+    const endOfLine = '\r\n';
+    const sdpLines = sdp.split(endOfLine);
+    const opusIndex = sdpLines.findIndex(s => /^a=rtpmap/.test(s) && /opus\/48000/.test(s));
+    if (opusIndex < 0) {
+        return sdp;
+    }
+    const getCodecPayloadType = (line) => {
+        const pattern = new RegExp('a=rtpmap:(\\d+) \\w+\\/\\d+');
+        const result = line.match(pattern);
+        return result && result.length == 2 ? result[1] : null;
+    };
+    const opusPayload = getCodecPayloadType(sdpLines[opusIndex]);
+    const pattern = new RegExp(`a=fmtp:${opusPayload}`);
+    const fmtpLineIndex = sdpLines.findIndex(s => pattern.test(s));
+    if (fmtpLineIndex >= 0) {
+        if (!/stereo=1;/.test(sdpLines[fmtpLineIndex])) {
+            sdpLines[fmtpLineIndex] += '; stereo=1; sprop-stereo=1';
+        }
+    }
+    else {
+        sdpLines[opusIndex] += `${endOfLine}a=fmtp:${opusPayload} stereo=1; sprop-stereo=1`;
+    }
+    return sdpLines.join(endOfLine);
+};
+const _isAudioLine = (line) => /^m=audio/.test(line);
+const _isVideoLine = (line) => /^m=video/.test(line);
+const sdpMediaOrderHack = (answer, localOffer) => {
+    const endOfLine = '\r\n';
+    const offerLines = localOffer.split(endOfLine);
+    const offerAudioIndex = offerLines.findIndex(_isAudioLine);
+    const offerVideoIndex = offerLines.findIndex(_isVideoLine);
+    if (offerAudioIndex < offerVideoIndex) {
+        return answer;
+    }
+    const answerLines = answer.split(endOfLine);
+    const answerAudioIndex = answerLines.findIndex(_isAudioLine);
+    const answerVideoIndex = answerLines.findIndex(_isVideoLine);
+    const audioLines = answerLines.slice(answerAudioIndex, answerVideoIndex);
+    const videoLines = answerLines.slice(answerVideoIndex, (answerLines.length - 1));
+    const beginLines = answerLines.slice(0, answerAudioIndex);
+    return [...beginLines, ...videoLines, ...audioLines, ''].join(endOfLine);
+};
+const checkSubscribeResponse = (response, channel) => {
+    if (!response) {
+        return false;
+    }
+    const { subscribed, alreadySubscribed } = destructSubscribeResponse(response);
+    return subscribed.includes(channel) || alreadySubscribed.includes(channel);
+};
+const destructSubscribeResponse = (response) => {
     const tmp = {
         subscribed: [],
         alreadySubscribed: [],
@@ -81,15 +190,47 @@ export const destructSubscribeResponse = (response) => {
     Object.keys(tmp).forEach(k => { tmp[k] = response[`${k}Channels`] || []; });
     return tmp;
 };
+const enableAudioTracks = (stream) => {
+    _updateMediaStreamTracks(stream, 'audio', true);
+};
+const disableAudioTracks = (stream) => {
+    _updateMediaStreamTracks(stream, 'audio', false);
+};
+const toggleAudioTracks = (stream) => {
+    _updateMediaStreamTracks(stream, 'audio', null);
+};
+const enableVideoTracks = (stream) => {
+    _updateMediaStreamTracks(stream, 'video', true);
+};
+const disableVideoTracks = (stream) => {
+    _updateMediaStreamTracks(stream, 'video', false);
+};
+const toggleVideoTracks = (stream) => {
+    _updateMediaStreamTracks(stream, 'video', null);
+};
 const _updateMediaStreamTracks = (stream, kind = null, enabled = null) => {
     if (!WebRTC.streamIsValid(stream)) {
         return null;
     }
-    const _updateTrack = (track) => {
+    let tracks = [];
+    switch (kind) {
+        case 'audio':
+            tracks = stream.getAudioTracks();
+            break;
+        case 'video':
+            tracks = stream.getVideoTracks();
+            break;
+        default:
+            tracks = stream.getTracks();
+            break;
+    }
+    tracks.forEach((track) => {
         switch (enabled) {
+            case 'on':
             case true:
                 track.enabled = true;
                 break;
+            case 'off':
             case false:
                 track.enabled = false;
                 break;
@@ -97,145 +238,32 @@ const _updateMediaStreamTracks = (stream, kind = null, enabled = null) => {
                 track.enabled = !track.enabled;
                 break;
         }
-    };
-    switch (kind) {
-        case 'audio':
-            return stream.getAudioTracks().forEach(_updateTrack);
-        case 'video':
-            return stream.getVideoTracks().forEach(_updateTrack);
-        default:
-            return stream.getTracks().forEach(_updateTrack);
-    }
-};
-export const enableAudioTracks = (stream) => _updateMediaStreamTracks(stream, 'audio', true);
-export const disableAudioTracks = (stream) => _updateMediaStreamTracks(stream, 'audio', false);
-export const toggleAudioTracks = (stream) => _updateMediaStreamTracks(stream, 'audio', null);
-export const enableVideoTracks = (stream) => _updateMediaStreamTracks(stream, 'video', true);
-export const disableVideoTracks = (stream) => _updateMediaStreamTracks(stream, 'video', false);
-export const toggleVideoTracks = (stream) => _updateMediaStreamTracks(stream, 'video', null);
-export const mutateCanvasInfoData = (canvasInfo) => {
-    const { canvasID, layoutFloorID, scale, canvasLayouts } = canvasInfo, rest = __rest(canvasInfo, ["canvasID", "layoutFloorID", "scale", "canvasLayouts"]);
-    const layouts = [];
-    let layoutOverlap = false;
-    for (let i = 0; i < canvasLayouts.length; i++) {
-        const layout = canvasLayouts[i];
-        const { memberID = 0, audioPOS, xPOS, yPOS } = layout, rest = __rest(layout, ["memberID", "audioPOS", "xPOS", "yPOS"]);
-        layoutOverlap = layoutOverlap || Boolean(layout.overlap === 1 && layout.layerOccupied);
-        layouts.push(Object.assign({ startX: `${roundToFixed((layout.x / scale) * 100)}%`, startY: `${roundToFixed((layout.y / scale) * 100)}%`, percentageWidth: `${roundToFixed((layout.scale / scale) * 100)}%`, percentageHeight: `${roundToFixed((layout.hscale / scale) * 100)}%`, participantId: String(memberID), audioPos: audioPOS, xPos: xPOS, yPos: yPOS }, rest));
-    }
-    return Object.assign(Object.assign({}, rest), { canvasId: canvasID, layoutFloorId: layoutFloorID, scale, canvasLayouts: layouts, layoutOverlap });
-};
-export const checkIsDirectCall = ({ variables }) => {
-    return typeof variables === 'object' && 'verto_svar_direct_call' in variables;
-};
-export const destructConferenceState = (confState) => {
-    const { variables = {}, flags = {} } = confState;
-    const suffix = `${confState.md5}@${confState.domain}`;
-    const confName = confState.displayName || confState.name;
-    let customCanvas = [];
-    let customEmpty = [];
-    let customAlone = [];
-    try {
-        customCanvas = JSON.parse(variables.custom_canvas);
-        customEmpty = JSON.parse(variables.custom_empty);
-        customAlone = JSON.parse(variables.custom_alone);
-    }
-    catch (error) {
-        logger.warn('Invalid conferenceState vars', error);
-    }
-    return {
-        uuid: confState.uuid,
-        md5: confState.md5,
-        domain: confState.domain,
-        running: Boolean(confState.running),
-        laName: confState.name,
-        laChannel: `conference-liveArray.${suffix}`,
-        infoChannel: `conference-info.${suffix}`,
-        modChannel: `conference-mod.${suffix}`,
-        chatChannel: `conference-chat.${suffix}`,
-        confName,
-        numMembers: Number(confState.members) || 0,
-        isPrivate: variables.is_private === 'true',
-        mohPlaying: Boolean(confState.mohPlaying),
-        filesPlaying: Boolean(confState.filesPlaying),
-        filesRole: confState.filesRole || null,
-        filePlaybackRole: confState.filePlaybackRole || null,
-        filesPlayingName: confState.filesPlayingName || null,
-        filesPlayingVolume: Number(confState.filesPlayingVolume) || 0,
-        filesPlayingPaused: Boolean(confState.filesPlayingPaused),
-        filesSeekable: Boolean(confState.filesSeekable),
-        asyncFilesPlaying: Boolean(confState.asyncFilesPlaying),
-        asyncFilesRole: confState.asyncFilesRole || null,
-        asyncFilesPlayingName: confState.asyncFilesPlayingName || null,
-        asyncFilesPlayingVolume: Number(confState.asyncFilesPlayingVolume) || 0,
-        asyncFilesPlayingPaused: Boolean(confState.asyncFilesPlayingPaused),
-        asyncFilesSeekable: Boolean(confState.asyncFilesSeekable),
-        performerDelay: confState.performerDelay,
-        volAudience: confState['vol-audience'],
-        filesFullScreen: Boolean(confState.filesFullScreen),
-        vidFloorRole: confState.vidFloorRole || null,
-        motionQuality: confState.motionQuality || 1,
-        motionQualityInbound: confState.motionQualityIn || 1,
-        videoShuffle: confState.videoShuffle || 0,
-        zones: confState.zones || [],
-        maxVisible: confState === null || confState === void 0 ? void 0 : confState.maxVisible,
-        silentMode: flags['silent-mode'] || false,
-        blindMode: flags['blind-mode'] || false,
-        meetingMode: flags['meeting-mode'] || false,
-        vidMuteHide: flags['vid-mute-hide'] || false,
-        personalCanvas: Boolean(flags.personalCanvas),
-        personalCanvasTP: flags.personalCanvasTP || null,
-        locked: Boolean(flags.locked),
-        recording: Boolean(flags.recording),
-        liveMusic: Boolean(flags.liveMusic),
-        logosVisible: Boolean(flags['logos-visible']),
-        handraiseOnscreen: Boolean(flags['handraise-onscreen']),
-        publicClipeeze: variables.public_clipeeze === 'true',
-        confQuality: variables.conf_quality,
-        accessPin: variables.access_pin || null,
-        moderatorPin: variables.moderator_pin || null,
-        speakerHighlight: variables.speaker_highlight === 'true',
-        disableIntercom: variables.disable_intercom === true,
-        lastSnapshot: variables.lastSnapshot,
-        lastLayoutGroup: variables.lastLayoutGroup,
-        lastLayout: variables.lastLayout,
-        userRecordFile: variables.user_record_file || null,
-        podcastMode: variables.podcast_mode === 'true',
-        publicDisableChat: variables.public_disable_chat === 'true',
-        chatOneWay: variables.chat_one_way === 'true',
-        bannerDisplayOption: variables.banner_display_option,
-        defaultPlayVolume: Number(variables.default_play_volume) || 0,
-        hasSms: Boolean(variables.has_sms),
-        autoOpenNav: Boolean(variables.auto_open_nav),
-        customCanvas,
-        customEmpty,
-        customAlone,
-    };
+    });
 };
-const _layoutReducer = (result, layout) => {
-    const { type, name, displayName, resIDS = [] } = layout;
-    const label = displayName || name.replace(/[-_]/g, ' ');
-    return result.concat({ id: name, label, type, reservationIds: resIDS, belongsToAGroup: false });
-};
-function _layoutCompare(prev, next) {
-    const prevLabel = prev.label.toLowerCase();
-    const nextLabel = next.label.toLowerCase();
-    if (prevLabel > nextLabel) {
-        return 1;
-    }
-    else if (prevLabel < nextLabel) {
-        return -1;
-    }
-    return 0;
-}
-export const mungeLayoutList = (layouts, layoutGroups) => {
-    const layoutsPartOfGroup = layoutGroups.reduce((cumulative, layout) => {
-        return cumulative.concat(layout.groupLayouts || []);
-    }, []);
-    const normalList = layouts.reduce(_layoutReducer, []);
-    normalList.forEach((layout) => {
-        layout.belongsToAGroup = layoutsPartOfGroup.includes(layout.id);
+const sdpBitrateHack = (sdp, max, min, start) => {
+    const endOfLine = '\r\n';
+    const lines = sdp.split(endOfLine);
+    lines.forEach((line, i) => {
+        if (/^a=fmtp:\d*/.test(line)) {
+            lines[i] += `;x-google-max-bitrate=${max};x-google-min-bitrate=${min};x-google-start-bitrate=${start}`;
+        }
+        else if (/^a=mid:(1|video)/.test(line)) {
+            lines[i] += `\r\nb=AS:${max}`;
+        }
     });
-    const groupList = layoutGroups.reduce(_layoutReducer, []);
-    return groupList.concat(normalList).sort(_layoutCompare);
+    return lines.join(endOfLine);
+};
+const filterIceServers = (servers, options = { disableUdpIceServers: false }) => {
+    const { disableUdpIceServers = false } = options;
+    const filterNonTransportTCP = (urls) => {
+        const transportParam = 'transport=tcp';
+        if (urls instanceof Array) {
+            return urls.filter(url => url.includes(transportParam));
+        }
+        else {
+            return urls.includes(transportParam) ? urls : '';
+        }
+    };
+    return servers.map(server => (Object.assign(Object.assign({}, server), { urls: disableUdpIceServers ? filterNonTransportTCP(server.urls) : server.urls })));
 };
+export { getUserMedia, getDevices, scanResolutions, getMediaConstraints, assureDeviceId, removeUnsupportedConstraints, checkDeviceIdConstraints, sdpStereoHack, sdpMediaOrderHack, sdpBitrateHack, checkSubscribeResponse, destructSubscribeResponse, enableAudioTracks, disableAudioTracks, toggleAudioTracks, enableVideoTracks, disableVideoTracks, toggleVideoTracks, filterIceServers };

package/dist/esm/common/src/webrtc/interfaces.d.ts

@@ -20,33 +20,63 @@ export interface CallOptions {
     camId?: string;
     camLabel?: string;
     speakerId?: string;
-    userVariables?: {
-        [key: string]: any;
-    };
+    userVariables?: Object;
     screenShare?: boolean;
-    secondSource?: boolean;
-    recoverCall?: boolean;
-    skipNotifications?: boolean;
-    skipLiveArray?: boolean;
     onNotification?: Function;
     googleMaxBitrate?: number;
     googleMinBitrate?: number;
     googleStartBitrate?: number;
-    negotiateAudio?: boolean;
-    negotiateVideo?: boolean;
-    sfu?: boolean;
-    simulcast?: boolean;
-    msStreamsNumber?: number;
-    requestTimeout?: number;
-    shakenCheck?: string;
-    shakenResult?: string;
-    experimental?: boolean;
-    autoApplyMediaParams?: boolean;
-    rtcPeerConfig?: {
-        [key: string]: any;
-    };
-    iceGatheringTimeout?: number;
-    maxIceGatheringTimeout?: number;
+    iceTransportPolicy?: RTCConfiguration['iceTransportPolicy'];
+    disableUdpIceServers?: boolean;
+}
+export interface IWebRTCCall {
+    id: string;
+    state: string;
+    prevState: string;
+    direction: string;
+    options: CallOptions;
+    cause: string;
+    causeCode: number;
+    channels: string[];
+    role: string;
+    extension: string;
+    localStream: MediaStream;
+    remoteStream: MediaStream;
+    invite: () => void;
+    answer: (params?: {
+        iceTransportPolicy?: RTCConfiguration['iceTransportPolicy'];
+    }) => void;
+    hangup: (params: any, execute: boolean) => void;
+    transfer: (destination: string) => void;
+    replace: (replaceCallID: string) => void;
+    hold: () => void;
+    unhold: () => void;
+    toggleHold: () => void;
+    dtmf: (dtmf: string) => void;
+    message: (to: string, body: string) => void;
+    muteAudio: () => void;
+    unmuteAudio: () => void;
+    toggleAudioMute: () => void;
+    setAudioInDevice: (deviceId: string) => Promise<void>;
+    muteVideo: () => void;
+    unmuteVideo: () => void;
+    toggleVideoMute: () => void;
+    setVideoDevice: (deviceId: string) => Promise<void>;
+    deaf: () => void;
+    undeaf: () => void;
+    toggleDeaf: () => void;
+    setState: (state: any) => void;
+    handleMessage: (msg: any) => void;
+    _addChannel: (laChannel: any) => void;
+    handleConferenceUpdate: (packet: any, pvtData: any) => Promise<string>;
+    startScreenShare?: (opts?: object) => Promise<IWebRTCCall>;
+    stopScreenShare?: () => void;
+    setAudioOutDevice?: (deviceId: string) => Promise<boolean>;
+    switchCamera?: () => void;
+    setSpeakerPhone?: (flag: boolean) => void;
+}
+export interface ICantinaAuthParams {
+    hostname?: string;
 }
 export interface ICantinaUser {
     first_name: string;
@@ -59,190 +89,3 @@ export interface ICantinaUser {
     scopes: string[];
     config?: object;
 }
-export interface VertoPvtData {
-    callID: string;
-    nodeId?: string;
-    action: string;
-    laChannel: string;
-    laName: string;
-    role: string;
-    chatID: string;
-    conferenceMemberID: number;
-    canvasCount: string;
-    modChannel: string;
-    chatChannel: string;
-    infoChannel: string;
-    conferenceName: string;
-    conferenceDisplayName: string;
-    conferenceMD5: string;
-    conferenceUUID: string;
-}
-export interface IVertoCanvasInfo {
-    canvasID: number;
-    totalLayers: number;
-    layersUsed: number;
-    layoutFloorID: number;
-    layoutName: string;
-    canvasLayouts: IVertoCanvasLayout[];
-    scale: number;
-}
-export interface IVertoCanvasLayout {
-    x: number;
-    y: number;
-    scale: number;
-    hscale: number;
-    zoom: number;
-    border: number;
-    floor: number;
-    overlap: number;
-    screenWidth: number;
-    screenHeight: number;
-    xPOS: number;
-    yPOS: number;
-    audioPOS: string;
-    memberID: number;
-    layerOccupied: boolean;
-}
-export interface ICanvasInfo {
-    canvasId: number;
-    totalLayers: number;
-    layersUsed: number;
-    layoutFloorId: number;
-    layoutName: string;
-    canvasLayouts: ICanvasLayout[];
-    scale: number;
-    layoutOverlap: boolean;
-}
-export interface ICanvasLayout {
-    x: number;
-    y: number;
-    startX: string;
-    startY: string;
-    percentageWidth: string;
-    percentageHeight: string;
-    scale: number;
-    hscale: number;
-    zoom: number;
-    border: number;
-    floor: number;
-    overlap: number;
-    screenWidth: number;
-    screenHeight: number;
-    xPos: number;
-    yPos: number;
-    audioPos: string;
-    participantId: string;
-}
-export interface IHangupParams {
-    code?: string;
-    cause?: string;
-    redirectDestination?: any;
-}
-export interface ICallParticipant {
-    id: string;
-    role: string;
-    layer: ICanvasLayout;
-    layerIndex: number;
-    isLayerBehind: boolean;
-}
-export interface IConferenceInfoMember {
-    participantId: string;
-    callId: string;
-    participantNumber: string;
-    participantName: string;
-}
-interface IConferenceZone {
-    id: string;
-    name: string;
-    extVol: number;
-}
-export interface IConferenceInfo {
-    uuid: string;
-    md5: string;
-    domain: string;
-    running: boolean;
-    laName: string;
-    laChannel: string;
-    infoChannel: string;
-    chatChannel: string;
-    modChannel: string;
-    confName: string;
-    numMembers: number;
-    isPrivate: boolean;
-    mohPlaying: boolean;
-    filePlaybackRole: string;
-    filesPlaying: boolean;
-    filesRole: string;
-    filesPlayingName: string;
-    filesPlayingVolume: number;
-    filesPlayingPaused: boolean;
-    filesSeekable: boolean;
-    asyncFilesPlaying: boolean;
-    asyncFilesRole: string;
-    asyncFilesPlayingName: string;
-    asyncFilesPlayingVolume: number;
-    asyncFilesPlayingPaused: boolean;
-    asyncFilesSeekable: boolean;
-    performerDelay: number;
-    volAudience: number;
-    filesFullScreen: boolean;
-    vidFloorRole: string;
-    motionQuality: number;
-    motionQualityInbound: number;
-    videoShuffle: number | string;
-    zones: IConferenceZone[];
-    maxVisible: number;
-    silentMode: boolean;
-    blindMode: boolean;
-    meetingMode: boolean;
-    locked: boolean;
-    recording: boolean;
-    personalCanvas: boolean;
-    personalCanvasTP: number;
-    liveMusic: boolean;
-    vidMuteHide: boolean;
-    logosVisible: boolean;
-    handraiseOnscreen: boolean;
-    publicClipeeze: boolean;
-    confQuality: string;
-    accessPin: string;
-    moderatorPin: string;
-    speakerHighlight: boolean;
-    disableIntercom: boolean;
-    lastSnapshot: string;
-    lastLayoutGroup: string;
-    lastLayout: string;
-    members?: IConferenceInfoMember[];
-    layouts?: any;
-    userRecordFile: string;
-    podcastMode: boolean;
-    publicDisableChat: boolean;
-    chatOneWay: boolean;
-    bannerDisplayOption: string;
-    defaultPlayVolume: number;
-    hasSms: boolean;
-    autoOpenNav: boolean;
-    customCanvas: string[];
-    customEmpty: string[];
-    customAlone: string[];
-}
-export interface ILayout {
-    id: string;
-    label: string;
-    type: string;
-    reservationIds: string[];
-    belongsToAGroup: boolean;
-}
-export interface IVertoLayout {
-    name: string;
-    displayName?: string;
-    type: string;
-    resIDS: string[];
-    groupLayouts?: string[];
-}
-export interface IVertoConferenceListParams {
-    showLayouts?: boolean;
-    showMembers?: boolean;
-    activeSession?: string;
-}
-export {};

package/dist/esm/common/src/webrtc/interfaces.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/js/index.d.ts

@@ -1,8 +1,6 @@
 import Relay from './src/SignalWire';
 import Verto from './src/Verto';
 import CantinaAuth from '../common/src/webrtc/CantinaAuth';
-export declare const VERSION = "1.3.0-dev.1";
+export declare const VERSION = "1.4.0";
 export { Relay, Verto, CantinaAuth };
-export * from '../common/src/webrtc/deviceHelpers';
 export * from '../common/src/util/interfaces';
-export * from '../common/src/webrtc/interfaces';