@signalwire/js 1.3.0-dev.1 → 1.4.0

package/dist/esm/common/src/BrowserSession.js

@@ -18,175 +18,43 @@ var __rest = (this && this.__rest) || function (s, e) {
         }
     return t;
 };
+import logger from './util/logger';
 import BaseSession from './BaseSession';
-import { deRegister, registerOnce, trigger } from './services/Handler';
+import { registerOnce, trigger } from './services/Handler';
 import { SwEvent, SESSION_ID } from './util/constants';
-import { State, DeviceType, Notification } from './webrtc/constants';
-import { removeUnsupportedConstraints, getUserMedia, destructSubscribeResponse, destructConferenceState, mungeLayoutList } from './webrtc/helpers';
-import { getDevices, scanResolutions, checkDeviceIdConstraints, assureDeviceId } from './webrtc/deviceHelpers';
-import BaseRequest from './messages/verto/BaseRequest';
-import { Execute } from './messages/Blade';
-import { Unsubscribe, Subscribe, Broadcast, JSApi } from './messages/Verto';
+import { State, DeviceType } from './webrtc/constants';
+import { getDevices, scanResolutions, removeUnsupportedConstraints, checkDeviceIdConstraints, destructSubscribeResponse, getUserMedia, assureDeviceId } from './webrtc/helpers';
+import { findElementByType } from './util/helpers';
+import { Unsubscribe, Subscribe, Broadcast } from './messages/Verto';
 import { localStorage } from './util/storage/';
 import { stopStream } from './util/webrtc';
-import laChannelHandler from './webrtc/LaChannelHandler';
-import modChannelHandler from './webrtc/ModChannelHandler';
-import infoChannelHandler from './webrtc/InfoChannelHandler';
-import ConferenceListChannelHandler, { publicConferenceListMethods } from './webrtc/ConferenceListChannelHandler';
-import Conference from './webrtc/Conference';
 export default class BrowserSession extends BaseSession {
     constructor() {
         super(...arguments);
         this.calls = {};
-        this.conferences = {};
-        this.channelToCallIds = new Map();
         this.autoRecoverCalls = true;
-        this.incognito = false;
         this._iceServers = [];
         this._localElement = null;
         this._remoteElement = null;
         this._jwtAuth = true;
+        this._devices = {};
         this._audioConstraints = true;
         this._videoConstraints = false;
         this._speaker = null;
-        this._purgeTimeout = null;
-        this._experimental = false;
-        this.watchVertoConferences = (params) => __awaiter(this, void 0, void 0, function* () {
-            this.conferences = {};
-            const currentConfList = yield this.vertoConferenceList(params);
-            currentConfList.forEach(row => {
-                this.conferences[row.uuid] = new Conference(this, row);
-            });
-            const infoChannel = 'conference-info';
-            const laChannel = 'conference-liveArray';
-            const modChannel = 'conference-mod';
-            const channels = [infoChannel, laChannel, modChannel];
-            this._detachChannels(channels);
-            const result = yield this.vertoSubscribe({
-                nodeId: this.nodeid,
-                channels,
-            });
-            const { subscribed = [], alreadySubscribed = [] } = destructSubscribeResponse(result);
-            const all = subscribed.concat(alreadySubscribed);
-            if (all.includes(laChannel)) {
-                this._addSubscription(this.relayProtocol, laChannelHandler.bind(this, this), laChannel);
-            }
-            if (all.includes(infoChannel)) {
-                this.off('signalwire.notification', this._watchRoomsNotificationHandler);
-                this.on('signalwire.notification', this._watchRoomsNotificationHandler);
-                this._addSubscription(this.relayProtocol, infoChannelHandler.bind(this, this), infoChannel);
-            }
-            if (all.includes(modChannel)) {
-                this._addSubscription(this.relayProtocol, modChannelHandler.bind(this, this), modChannel);
-            }
-            return currentConfList;
-        });
-        this._watchRoomsNotificationHandler = (event) => {
-            if (event.type !== 'conferenceUpdate') {
-                return;
-            }
-            switch (event.action) {
-                case 'clear':
-                    Object.keys(this.conferences).forEach(uuid => {
-                        if (this.conferences[uuid].confName === event.confName) {
-                            delete this.conferences[uuid];
-                        }
-                    });
-                    break;
-                case 'conferenceInfo':
-                    const conferenceState = event.conferenceState;
-                    const { uuid, running } = conferenceState;
-                    if (running) {
-                        const params = destructConferenceState(conferenceState);
-                        this.conferences[uuid] = new Conference(this, params);
-                    }
-                    else {
-                        delete this.conferences[uuid];
-                    }
-                    break;
-            }
-        };
-        this.unwatchVertoConferences = () => __awaiter(this, void 0, void 0, function* () {
-            this.conferences = {};
-            const infoChannel = 'conference-info';
-            const laChannel = 'conference-liveArray';
-            const modChannel = 'conference-mod';
-            const channels = [infoChannel, laChannel, modChannel];
-            this._detachChannels(channels);
-            yield this.vertoUnsubscribe({
-                nodeId: this.nodeid,
-                channels,
-            });
-        });
-        this._detachChannels = (channels) => {
-            channels.forEach(channel => {
-                deRegister(this.relayProtocol, null, channel);
-                this._removeSubscription(this.relayProtocol, channel);
-            });
-        };
-        this.watchVertoConferenceList = () => __awaiter(this, void 0, void 0, function* () {
-            this.conferences = {};
-            const listChannel = 'conference-list';
-            const channels = [listChannel];
-            this._detachChannels(channels);
-            const result = yield this.vertoSubscribe({
-                nodeId: this.nodeid,
-                channels,
-            });
-            const { subscribed = [], alreadySubscribed = [] } = destructSubscribeResponse(result);
-            const all = subscribed.concat(alreadySubscribed);
-            if (all.includes(listChannel)) {
-                this._addSubscription(this.relayProtocol, ConferenceListChannelHandler.bind(this, this), listChannel);
-                const listObject = {
-                    session: this,
-                    nodeId: this.nodeid,
-                    channel: listChannel,
-                };
-                Object.keys(publicConferenceListMethods).forEach(method => {
-                    Object.defineProperty(this, method, {
-                        configurable: true,
-                        writable: true,
-                        value: publicConferenceListMethods[method].bind(listObject)
-                    });
-                });
-                this.conferenceListBootstrap();
-            }
-        });
-        this.unwatchVertoConferenceList = () => __awaiter(this, void 0, void 0, function* () {
-            const listChannel = 'conference-list';
-            const channels = [listChannel];
-            this._detachChannels(channels);
-            yield this.vertoUnsubscribe({
-                nodeId: this.nodeid,
-                channels,
-            });
-        });
-    }
-    get callIds() {
-        return Object.keys(this.calls);
-    }
-    addChannelCallIdEntry(channel, callId) {
-        const current = this.channelToCallIds.get(channel) || [];
-        const filtered = current.filter(id => id !== callId);
-        filtered.push(callId);
-        this.channelToCallIds.set(channel, filtered);
-    }
-    removeChannelCallIdEntry(channel, callId) {
-        const current = this.channelToCallIds.get(channel) || [];
-        const filtered = current.filter(id => id !== callId);
-        this.channelToCallIds.set(channel, filtered);
     }
     get reconnectDelay() {
         return 1000;
     }
+    _handleBladeConnectResponse(response) {
+        const { ice_servers = [] } = response;
+        this.iceServers = ice_servers;
+    }
     connect() {
         const _super = Object.create(null, {
             connect: { get: () => super.connect }
         });
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.incognito) {
-                this.sessionid = yield localStorage.getItem(SESSION_ID);
-            }
+            this.sessionid = yield localStorage.getItem(SESSION_ID);
             _super.connect.call(this);
         });
     }
@@ -202,19 +70,17 @@ export default class BrowserSession extends BaseSession {
             }
         });
     }
-    purge() {
-        Object.keys(this.calls).forEach(k => this.calls[k].setState(State.Purge));
-        this.calls = {};
+    logout() {
+        this.disconnect();
     }
     disconnect() {
         const _super = Object.create(null, {
             disconnect: { get: () => super.disconnect }
         });
         return __awaiter(this, void 0, void 0, function* () {
-            const promises = Object.keys(this.calls).map(k => this.calls[k].hangup());
-            yield Promise.all(promises);
-            this.purge();
-            return _super.disconnect.call(this);
+            Object.keys(this.calls).forEach(k => this.calls[k].setState(State.Purge));
+            this.calls = {};
+            yield _super.disconnect.call(this);
         });
     }
     speedTest(bytes) {
@@ -268,17 +134,52 @@ export default class BrowserSession extends BaseSession {
     validateDeviceId(id, label, kind) {
         return assureDeviceId(id, label, kind);
     }
-    validateVideoDevice(id, label) {
-        return assureDeviceId(id, label, 'videoinput');
-    }
-    validateAudioInDevice(id, label) {
-        return assureDeviceId(id, label, 'audioinput');
+    refreshDevices() {
+        return __awaiter(this, void 0, void 0, function* () {
+            logger.warn('This method has been deprecated. Use getDevices() instead.');
+            const cache = {};
+            ['videoinput', 'audioinput', 'audiooutput'].map((kind) => {
+                cache[kind] = {};
+                Object.defineProperty(cache[kind], 'toArray', {
+                    value: function () {
+                        return Object.keys(this).map(k => this[k]);
+                    }
+                });
+            });
+            const devices = yield this.getDevices();
+            devices.forEach((t) => {
+                if (cache.hasOwnProperty(t.kind)) {
+                    cache[t.kind][t.deviceId] = t;
+                }
+            });
+            this._devices = cache;
+            return this.devices;
+        });
     }
-    validateAudioOutDevice(id, label) {
-        return assureDeviceId(id, label, 'audiooutput');
+    get devices() {
+        return this._devices || {};
     }
     getDeviceResolutions(deviceId) {
-        return scanResolutions(deviceId);
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                return yield scanResolutions(deviceId);
+            }
+            catch (error) {
+                throw error;
+            }
+        });
+    }
+    get videoDevices() {
+        logger.warn('This property has been deprecated. Use getVideoDevices() instead.');
+        return this._devices.videoinput || {};
+    }
+    get audioInDevices() {
+        logger.warn('This property has been deprecated. Use getAudioInDevices() instead.');
+        return this._devices.audioinput || {};
+    }
+    get audioOutDevices() {
+        logger.warn('This property has been deprecated. Use getAudioOutDevices() instead.');
+        return this._devices.audiooutput || {};
     }
     get mediaConstraints() {
         return { audio: this._audioConstraints, video: this._videoConstraints };
@@ -294,8 +195,6 @@ export default class BrowserSession extends BaseSession {
         });
     }
     disableMicrophone() {
-        this.micId = null;
-        this.micLabel = null;
         this._audioConstraints = false;
     }
     enableMicrophone() {
@@ -312,8 +211,6 @@ export default class BrowserSession extends BaseSession {
         });
     }
     disableWebcam() {
-        this.camId = null;
-        this.camLabel = null;
         this._videoConstraints = false;
     }
     enableWebcam() {
@@ -337,226 +234,61 @@ export default class BrowserSession extends BaseSession {
         return this._speaker;
     }
     set localElement(tag) {
-        this._localElement = tag;
+        this._localElement = findElementByType(tag);
     }
     get localElement() {
         return this._localElement;
     }
     set remoteElement(tag) {
-        this._remoteElement = tag;
+        this._remoteElement = findElementByType(tag);
     }
     get remoteElement() {
         return this._remoteElement;
     }
-    vertoBroadcast({ nodeId, channel, data }) {
-        const msg = new Broadcast({ sessid: this.sessionid, eventChannel: channel, data });
+    vertoBroadcast({ nodeId, channel: eventChannel = '', data }) {
+        if (!eventChannel) {
+            throw new Error('Invalid channel for broadcast: ' + eventChannel);
+        }
+        const msg = new Broadcast({ sessid: this.sessionid, eventChannel, data });
         if (nodeId) {
             msg.targetNodeId = nodeId;
         }
-        return this.execute(msg);
+        this.execute(msg).catch(error => error);
     }
-    vertoSubscribe({ nodeId, channels, handler = null }) {
+    vertoSubscribe({ nodeId, channels: eventChannel = [], handler }) {
         return __awaiter(this, void 0, void 0, function* () {
-            const msg = new Subscribe({ sessid: this.sessionid, eventChannel: channels });
-            if (nodeId) {
-                msg.targetNodeId = nodeId;
-            }
-            try {
-                const response = yield this.execute(msg);
-                if (handler) {
-                    const { subscribed = [] } = destructSubscribeResponse(response);
-                    subscribed.forEach(channel => this._addSubscription(this.relayProtocol, handler, channel));
-                }
-                return response;
-            }
-            catch (error) {
-                throw error;
+            eventChannel = eventChannel.filter(channel => channel && !this._existsSubscription(this.relayProtocol, channel));
+            if (!eventChannel.length) {
+                return {};
             }
-        });
-    }
-    vertoUnsubscribe({ nodeId, channels, handler = null }) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const msg = new Unsubscribe({ sessid: this.sessionid, eventChannel: channels });
+            const msg = new Subscribe({ sessid: this.sessionid, eventChannel });
             if (nodeId) {
                 msg.targetNodeId = nodeId;
             }
-            try {
-                const response = yield this.execute(msg);
-                if (handler) {
-                    const { unsubscribed = [], notSubscribed = [] } = destructSubscribeResponse(response);
-                    unsubscribed.forEach(channel => this._removeSubscription(this.relayProtocol, channel));
-                    notSubscribed.forEach(channel => this._removeSubscription(this.relayProtocol, channel));
-                }
-                return response;
-            }
-            catch (error) {
-                throw error;
+            const response = yield this.execute(msg);
+            const { unauthorized = [], subscribed = [] } = destructSubscribeResponse(response);
+            if (unauthorized.length) {
+                unauthorized.forEach(channel => this._removeSubscription(this.relayProtocol, channel));
             }
+            subscribed.forEach(channel => this._addSubscription(this.relayProtocol, handler, channel));
+            return response;
         });
     }
-    listConf() {
-        const msg = new Execute({
-            protocol: this.relayProtocol,
-            method: 'conference.list',
-            params: {}
-        });
-        console.debug('Send confList', msg);
-        return this.execute(msg);
-    }
-    vertoConferenceList(params) {
+    vertoUnsubscribe({ nodeId, channels: eventChannel = [] }) {
         return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const rooms = [];
-                const response = yield this._jsApi({
-                    command: 'conference',
-                    data: Object.assign({ command: 'list' }, params),
-                });
-                response.conferences.forEach((conf) => {
-                    const { conferenceState, members = [], layouts = [] } = conf;
-                    const room = destructConferenceState(conferenceState);
-                    if (members.length) {
-                        room.members = members.filter(({ type }) => type === 'caller')
-                            .map((_a) => {
-                            var { id, uuid, caller_id_number, caller_id_name } = _a, rest = __rest(_a, ["id", "uuid", "caller_id_number", "caller_id_name"]);
-                            return Object.assign({ participantId: Number(id).toString(), callId: uuid, participantNumber: caller_id_number, participantName: caller_id_name }, rest);
-                        });
-                    }
-                    if (layouts.length) {
-                        const normal = layouts.filter(({ type }) => type === 'layout');
-                        const group = layouts.filter(({ type }) => type === 'layoutGroup');
-                        room.layouts = mungeLayoutList(normal, group);
-                    }
-                    rooms.push(room);
-                });
-                return rooms;
-            }
-            catch (error) {
-                console.error('vertoConferenceList error', error);
-                return [];
+            eventChannel = eventChannel.filter(channel => channel && this._existsSubscription(this.relayProtocol, channel));
+            if (!eventChannel.length) {
+                return {};
             }
-        });
-    }
-    vertoLayoutList(options = {}) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { fullList = false } = options;
-            try {
-                const { layouts: { layouts, groups } } = yield this._jsApi({
-                    command: 'conference',
-                    data: {
-                        command: 'listLayouts',
-                    },
-                });
-                const final = mungeLayoutList(layouts, groups)
-                    .map((layout) => {
-                    const { id, type } = layout;
-                    const prefix = type === 'group' ? 'group:' : '';
-                    return Object.assign(Object.assign({}, layout), { id: `${prefix}${id}` });
-                });
-                if (fullList) {
-                    return final;
-                }
-                return final.filter(layout => !layout.belongsToAGroup);
-            }
-            catch (error) {
-                console.error('vertoLayoutList error', error);
-                return [];
-            }
-        });
-    }
-    dispatchConferenceUpdate(params) {
-        const notification = Object.assign({ type: Notification.ConferenceUpdate }, params);
-        trigger(SwEvent.Notification, notification, this.uuid);
-    }
-    _jsApi(params = {}) {
-        const msg = new JSApi(Object.assign(Object.assign({}, params), { sessid: this.sessionid }));
-        return this.execute(msg);
-    }
-    _wrapInExecute(message) {
-        const params = {
-            message: message.request,
-            node_id: message.targetNodeId || undefined
-        };
-        return new Execute({ protocol: this.relayProtocol, method: 'message', params });
-    }
-    execute(message) {
-        if (message instanceof BaseRequest) {
-            message = this._wrapInExecute(message);
-        }
-        return super.execute(message);
-    }
-    _onSocketOpen() {
-        const _super = Object.create(null, {
-            _onSocketOpen: { get: () => super._onSocketOpen }
-        });
-        return __awaiter(this, void 0, void 0, function* () {
-            clearTimeout(this._purgeTimeout);
-            _super._onSocketOpen.call(this);
-        });
-    }
-    _onSocketCloseOrError(event) {
-        if (this._experimental) {
-            const waitFor = 10 * 1000;
-            this._purgeTimeout = setTimeout(() => {
-                this.purge();
-            }, waitFor);
-        }
-        else {
-            this.purge();
-        }
-        const channels = ['conference-info', 'conference-liveArray', 'conference-mod'];
-        this._detachChannels(channels);
-        super._onSocketCloseOrError(event);
-    }
-    vertoSubscribeToConference({ infoChannel, modChannel, laChannel }) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const channels = [
-                    infoChannel,
-                    modChannel,
-                    laChannel,
-                ].filter(Boolean);
-                if (!(channels === null || channels === void 0 ? void 0 : channels.length)) {
-                    return;
-                }
-                this._detachChannels(channels);
-                const result = yield this.vertoSubscribe({ channels });
-                const { subscribed = [], alreadySubscribed = [] } = destructSubscribeResponse(result);
-                const all = subscribed.concat(alreadySubscribed);
-                if (all.includes(infoChannel)) {
-                    this._addSubscription(this.relayProtocol, infoChannelHandler.bind(this, this), infoChannel);
-                }
-                if (all.includes(modChannel)) {
-                    this._addSubscription(this.relayProtocol, modChannelHandler.bind(this, this), modChannel);
-                }
-                if (all.includes(laChannel)) {
-                    this._addSubscription(this.relayProtocol, laChannelHandler.bind(this, this), laChannel);
-                }
-            }
-            catch (error) {
-                console.error('vertoSubscribeToConference error', error);
-            }
-        });
-    }
-    vertoUnsubscribeFromConference({ infoChannel, modChannel, laChannel }) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const channels = [
-                    infoChannel,
-                    modChannel,
-                    laChannel,
-                ].filter(Boolean);
-                if (!(channels === null || channels === void 0 ? void 0 : channels.length)) {
-                    return;
-                }
-                this._detachChannels(channels);
-                yield this.vertoUnsubscribe({
-                    nodeId: this.nodeid,
-                    channels
-                });
-            }
-            catch (error) {
-                console.error('vertoUnsubscribeFromConference error', error);
+            const msg = new Unsubscribe({ sessid: this.sessionid, eventChannel });
+            if (nodeId) {
+                msg.targetNodeId = nodeId;
             }
+            const response = yield this.execute(msg);
+            const { unsubscribed = [], notSubscribed = [] } = destructSubscribeResponse(response);
+            unsubscribed.forEach(channel => this._removeSubscription(this.relayProtocol, channel));
+            notSubscribed.forEach(channel => this._removeSubscription(this.relayProtocol, channel));
+            return response;
         });
     }
 }

package/dist/esm/common/src/messages/Verto.d.ts

@@ -29,13 +29,4 @@ declare class Subscribe extends BaseRequest {
 declare class Unsubscribe extends BaseRequest {
     toString(): VertoMethod;
 }
-declare class JSApi extends BaseRequest {
-    toString(): VertoMethod;
-}
-declare class Stats extends BaseRequest {
-    toString(): VertoMethod;
-}
-declare class Ping extends BaseRequest {
-    toString(): VertoMethod;
-}
-export { Login, Invite, Answer, Attach, Bye, Modify, Info, Broadcast, Subscribe, Unsubscribe, Result, JSApi, Stats, Ping, };
+export { Login, Invite, Answer, Attach, Bye, Modify, Info, Broadcast, Subscribe, Unsubscribe, Result };

package/dist/esm/common/src/messages/Verto.js

@@ -47,19 +47,4 @@ class Unsubscribe extends BaseRequest {
         return VertoMethod.Unsubscribe;
     }
 }
-class JSApi extends BaseRequest {
-    toString() {
-        return VertoMethod.JsApi;
-    }
-}
-class Stats extends BaseRequest {
-    toString() {
-        return VertoMethod.Stats;
-    }
-}
-class Ping extends BaseRequest {
-    toString() {
-        return VertoMethod.Ping;
-    }
-}
-export { Login, Invite, Answer, Attach, Bye, Modify, Info, Broadcast, Subscribe, Unsubscribe, Result, JSApi, Stats, Ping, };
+export { Login, Invite, Answer, Attach, Bye, Modify, Info, Broadcast, Subscribe, Unsubscribe, Result };

package/dist/esm/common/src/messages/verto/Login.d.ts

@@ -1,18 +1,6 @@
 import BaseRequest from './BaseRequest';
-declare type LoginOptions = {
-    login: string;
-    passwd: string;
-    sessionid?: string;
-    userVariables?: {
-        [key: string]: any;
-    };
-    loginParams?: {
-        [key: string]: any;
-    };
-    callIds?: string[];
-};
 declare class Login extends BaseRequest {
     method: string;
-    constructor({ login, passwd, sessionid, userVariables, loginParams, callIds }: LoginOptions);
+    constructor(login: string, passwd: string, sessionid: string, userVariables?: Object);
 }
 export { Login };

package/dist/esm/common/src/messages/verto/Login.js

@@ -1,15 +1,12 @@
 import BaseRequest from './BaseRequest';
 class Login extends BaseRequest {
-    constructor({ login, passwd, sessionid, userVariables = {}, loginParams = {}, callIds = [] }) {
+    constructor(login, passwd, sessionid, userVariables = {}) {
         super();
         this.method = 'login';
-        const params = { login, passwd, userVariables, loginParams };
+        const params = { login, passwd, userVariables, loginParams: {} };
         if (sessionid) {
             params.sessid = sessionid;
         }
-        if (callIds === null || callIds === void 0 ? void 0 : callIds.length) {
-            params.callIds = callIds;
-        }
         this.buildRequest({ method: this.method, params });
     }
 }

package/dist/esm/common/src/services/BroadcastHandler.js

@@ -9,8 +9,9 @@ export default (session, broadcastParams) => {
     switch (event) {
         case 'queuing.relay.events':
             if (event_type === 'webrtc.message') {
-                params.params.nodeId = node_id;
-                VertoHandler(session, params.params);
+                const handler = new VertoHandler(session);
+                handler.nodeId = node_id;
+                handler.handleMessage(params.params);
             }
             else {
                 session.calling.notificationHandler(params);

package/dist/esm/common/src/services/Connection.d.ts

@@ -5,8 +5,8 @@ export default class Connection {
     private _wsClient;
     private _host;
     private _timers;
-    upDur: number;
-    downDur: number;
+    upDur: number | null;
+    downDur: number | null;
     constructor(session: BaseSession);
     get connected(): boolean;
     get connecting(): boolean;

package/dist/esm/common/src/services/Handler.d.ts

@@ -1,9 +1,8 @@
-declare const isQueued: (event: string, uniqueId?: string) => boolean;
-declare const queueLength: (event: string, uniqueId?: string) => number;
-declare const register: (event: string, callback: Function, uniqueId?: string) => void;
-declare const registerOnce: (event: string, callback: Function, uniqueId?: string) => void;
-declare const deRegister: (event: string, callback?: Function, uniqueId?: string) => boolean;
-declare const trigger: (event: string, data: any, uniqueId?: string, globalPropagation?: boolean) => boolean;
-declare const deRegisterAll: (event: string) => void;
-declare const clearQueue: () => void;
-export { trigger, register, registerOnce, deRegister, deRegisterAll, isQueued, queueLength, clearQueue };
+declare const isQueued: (eventName: string, uniqueId?: string) => boolean;
+declare const queueLength: (eventName: string, uniqueId?: string) => number;
+declare const register: (eventName: string, callback: Function, uniqueId?: string) => void;
+declare const registerOnce: (eventName: string, callback: Function, uniqueId?: string) => void;
+declare const deRegister: (eventName: string, callback?: Function | null, uniqueId?: string) => boolean;
+declare const trigger: (eventName: string, data: any, uniqueId?: string, globalPropagation?: boolean) => boolean;
+declare const deRegisterAll: (eventName: string) => void;
+export { trigger, register, registerOnce, deRegister, deRegisterAll, isQueued, queueLength };