@wazo/sdk 0.43.15 → 0.44.0

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@wazo/sdk",
-  "version": "0.43.15",
+  "version": "0.44.0",
   "description": "Wazo's JavaScript Software Development Kit.",
-  "main": "index.js",
-  "types": "lib/types/index.d.ts",
+  "main": "./dist/index.js",
+  "types": "./dist/types/index.d.ts",
   "author": "Wazo (http://wazo.io)",
   "maintainers": [
     "Wazo Team <dev@wazo.io> (https://github.com/wazo-platform)"
@@ -14,16 +14,12 @@
   "license": "MIT",
   "homepage": "https://github.com/wazo-platform/wazo-js-sdk",
   "files": [
-    "index.js",
-    "dist/*.js",
-    "src/**/*",
-    "esm/**/*",
-    "lib/**/*"
+    "dist"
   ],
   "exports": {
-    "import": "./esm/index.js",
+    "import": "./dist/index.mjs",
     "node": "./dist/wazo-sdk.js",
-    "require": "./lib/index.js"
+    "require": "./dist/index.js"
   },
   "repository": {
     "type": "git",
@@ -33,11 +29,9 @@
     "url": "https://github.com/wazo-platform/wazo-js-sdk/issues"
   },
   "scripts": {
-    "clean": "rimraf lib esm dist",
-    "build": "yarn clean && yarn build:esm && yarn build:cjs && yarn build:umd",
-    "build:umd": "rollup --config --extend --bundleConfigAsCjs",
-    "build:esm": "tsc -p ./tsconfig.esm.json",
-    "build:cjs": "tsc -p ./tsconfig.cjs.json",
+    "clean": "rimraf dist",
+    "build": "rslib build",
+    "build:watch": "rslib build --watch",
     "test": "jest && yarn lint && yarn typecheck && yarn checkbuild",
     "lint": "eslint src/",
     "jest": "jest src/",
@@ -65,11 +59,7 @@
     "@babel/core": "^7.24.4",
     "@babel/preset-env": "^7.24.4",
     "@babel/preset-typescript": "^7.24.1",
-    "@rollup/plugin-commonjs": "^25.0.7",
-    "@rollup/plugin-json": "^6.1.0",
-    "@rollup/plugin-node-resolve": "^15.2.3",
-    "@rollup/plugin-terser": "^0.4.4",
-    "@rollup/plugin-typescript": "^11.1.6",
+    "@rslib/core": "^0.3.1",
     "@types/events": "^3.0.3",
     "@types/jest": "^29.5.2",
     "@types/jsrsasign": "^10.5.8",
@@ -90,7 +80,6 @@
     "jsonlint": "^1.6.3",
     "prettier-eslint-cli": "^7.1.0",
     "rimraf": "^5.0.5",
-    "rollup": "^3.26.2",
     "ts-jest": "^29.1.2",
     "typescript": "^5.4.5"
   },

package/esm/__tests__/api-client.test.js

@@ -1,281 +0,0 @@
-import { Base64 } from 'js-base64';
-import WazoApiClient from '../api-client';
-import ServerError from '../domain/ServerError';
-import BadResponse from '../domain/BadResponse';
-import Session from '../domain/Session';
-const mockedResponse = {
-    data: {
-        token: 1,
-    },
-};
-const mockedNotFoundResponse = {
-    message: 'No such user voicemail',
-};
-const mockedTextErrorPayload = {
-    message: 'No such user voicemail',
-};
-const mockedJsonErrorPayload = {
-    timestamp: 1537529588.789515,
-    message: 'No such user voicemail',
-    error_id: 'no-such-user-voicemail',
-    details: {
-        user_uuid: 'xxx-xxx-xxx-xxx-xxxx',
-    },
-};
-const mockedTextError = {
-    ok: false,
-    text: () => Promise.resolve(mockedTextErrorPayload),
-    status: 500,
-    headers: {
-        get: () => 'text/plain',
-    },
-};
-const mockedJsonError = {
-    ok: false,
-    json: () => Promise.resolve(mockedJsonErrorPayload),
-    status: 500,
-    headers: {
-        get: () => 'application/json',
-    },
-};
-const mockedJson = {
-    ok: true,
-    json: () => Promise.resolve(mockedResponse),
-    headers: {
-        get: () => 'application/json',
-    },
-};
-const mockedUnAuthorized = {
-    text: () => Promise.resolve(mockedResponse),
-    ok: false,
-    status: 401,
-    headers: {
-        get: () => 'text/plain',
-    },
-};
-const mockedNotFound = {
-    json: () => Promise.resolve(mockedNotFoundResponse),
-    ok: false,
-    status: 404,
-    headers: {
-        get: () => 'application/json',
-    },
-};
-const server = 'localhost';
-const authVersion = '0.1';
-const username = 'wazo';
-const password = 'zowa';
-const token = '1234';
-const client = new WazoApiClient({
-    server,
-});
-client.setToken(token);
-describe('With correct API results', () => {
-    beforeEach(() => {
-        jest.resetModules();
-        Object.defineProperty(global, 'fetch', {
-            value: jest.fn(() => Promise.resolve(mockedJson)),
-        });
-    });
-    describe('logIn test', () => {
-        it('should retrieve user token', async () => {
-            const data = {
-                backend: 'wazo_user',
-                expiration: 3600,
-            };
-            const headers = {
-                Authorization: `Basic ${Base64.encode(`${username}:${password}`)}`,
-                'Content-Type': 'application/json',
-            };
-            const result = await client.auth.logIn({
-                username,
-                password,
-            });
-            expect(result).toBeInstanceOf(Session);
-            expect(result.token).toBe(1);
-            expect(global.fetch).toBeCalledWith(`https://${server}/api/auth/${authVersion}/token`, {
-                method: 'post',
-                body: JSON.stringify(data),
-                signal: expect.any(Object),
-                headers,
-                agent: null,
-            });
-        });
-    });
-    describe('samlLogIn test', () => {
-        it('should retrieve user token', async () => {
-            const samlSessionId = 'a1b2C3d4';
-            const result = await client.auth.samlLogIn(samlSessionId);
-            expect(result).toBeInstanceOf(Session);
-            expect(result?.token).toBe(1);
-            expect(global.fetch).toBeCalledWith(`https://${server}/api/auth/${authVersion}/token`, {
-                method: 'post',
-                body: JSON.stringify({ saml_session_id: samlSessionId }),
-                signal: expect.any(Object),
-                headers: {
-                    'Content-Type': 'application/json',
-                    Accept: 'application/json',
-                },
-                agent: null,
-            });
-        });
-    });
-    describe('samlLogIn mobile test', () => {
-        it('should retrieve user token', async () => {
-            Wazo.Auth.mobile = true;
-            const samlSessionId = 'a1b2C3d4';
-            const result = await client.auth.samlLogIn(samlSessionId);
-            expect(result).toBeInstanceOf(Session);
-            expect(result?.token).toBe(1);
-            expect(global.fetch).toBeCalledWith(`https://${server}/api/auth/${authVersion}/token`, {
-                method: 'post',
-                body: JSON.stringify({ saml_session_id: samlSessionId }),
-                signal: expect.any(Object),
-                headers: {
-                    'Content-Type': 'application/json',
-                    'Wazo-Session-Type': 'mobile',
-                    Accept: 'application/json',
-                },
-                agent: null,
-            });
-        });
-    });
-    describe('logOut test', () => {
-        it('should delete the specified token', async () => {
-            const oldToken = 123;
-            await client.auth.logOut(oldToken);
-            expect(global.fetch).toBeCalledWith(`https://${server}/api/auth/${authVersion}/token/${oldToken}`, {
-                method: 'delete',
-                body: null,
-                signal: expect.any(Object),
-                headers: {},
-                agent: null,
-            });
-        });
-    });
-});
-describe('initiateIdpAuthentication', () => {
-    it('should make a request to obtain an identity provider URL to redirect to', async () => {
-        const domain = 'example.com';
-        const redirectUrl = 'https://myapp.xyz';
-        await client.auth.initiateIdpAuthentication(domain, redirectUrl);
-        expect(global.fetch).toBeCalledWith(`https://${server}/api/auth/${authVersion}/saml/sso`, {
-            method: 'post',
-            body: JSON.stringify({
-                domain,
-                redirect_url: redirectUrl,
-            }),
-            signal: expect.any(Object),
-            headers: {
-                'Content-Type': 'application/json',
-                Accept: 'application/json',
-            },
-            agent: null,
-        });
-    });
-});
-describe('With unAuthorized API results', () => {
-    beforeEach(() => {
-        jest.resetModules();
-        Object.defineProperty(global, 'fetch', {
-            value: jest.fn(() => Promise.resolve(mockedUnAuthorized)),
-        });
-    });
-    describe('checkLogin test', () => {
-        it('should return false on 401 status', async () => {
-            const tokenToCheck = '123';
-            const result = await client.auth.checkToken(tokenToCheck);
-            expect(result).toBeFalsy();
-            expect(global.fetch).toBeCalledWith(`https://${server}/api/auth/${authVersion}/token/${tokenToCheck}`, {
-                method: 'head',
-                body: null,
-                signal: expect.any(Object),
-                headers: {},
-                agent: null,
-            });
-        });
-    });
-});
-describe('With not found API results', () => {
-    beforeEach(() => {
-        jest.resetModules();
-        Object.defineProperty(global, 'fetch', {
-            value: jest.fn(() => Promise.resolve(mockedNotFound)),
-        });
-    });
-    describe('fetchVoicemail test', () => {
-        it('should throw a BadResponse instance on 404 status', async () => {
-            let error = null;
-            try {
-                await client.calld.listVoicemails();
-            }
-            catch (e) {
-                error = e;
-            }
-            expect(error).not.toBeNull();
-            expect(error).toBeInstanceOf(BadResponse);
-            expect(error.message).toBe(mockedNotFoundResponse.message);
-            expect(error.status).toBe(404);
-            expect(global.fetch).toBeCalledWith(`https://${server}/api/calld/1.0/users/me/voicemails`, {
-                method: 'get',
-                body: null,
-                signal: expect.any(Object),
-                headers: {
-                    'X-Auth-Token': token,
-                    'Content-Type': 'application/json',
-                    Accept: 'application/json',
-                },
-                agent: null,
-            });
-        });
-    });
-});
-describe('With erroneous text API results', () => {
-    beforeEach(() => {
-        jest.resetModules();
-        Object.defineProperty(global, 'fetch', {
-            value: jest.fn(() => Promise.resolve(mockedTextError)),
-        });
-    });
-    it('throw an exception when the response is >= 500', async () => {
-        let error = null;
-        try {
-            await client.auth.logIn({
-                username,
-                password,
-            });
-        }
-        catch (e) {
-            error = e;
-        }
-        expect(error).not.toBeNull();
-        expect(error).toBeInstanceOf(ServerError);
-        expect(error.message).toBe(mockedTextErrorPayload.message);
-        expect(error.status).toBe(500);
-    });
-});
-describe('With erroneous json API results', () => {
-    beforeEach(() => {
-        jest.resetModules();
-        Object.defineProperty(global, 'fetch', {
-            value: jest.fn(() => Promise.resolve(mockedJsonError)),
-        });
-    });
-    it('throw an exception when the response is >= 500', async () => {
-        let error = null;
-        try {
-            await client.auth.logIn({
-                username,
-                password,
-            });
-        }
-        catch (e) {
-            error = e;
-        }
-        expect(error).not.toBeNull();
-        expect(error).toBeInstanceOf(ServerError);
-        expect(error.message).toBe(mockedJsonErrorPayload.message);
-        expect(error.timestamp).toBe(mockedJsonErrorPayload.timestamp);
-        expect(error.status).toBe(500);
-    });
-});

package/esm/__tests__/web-rtc-client.test.js

@@ -1,192 +0,0 @@
-import WebRTCClient from '../web-rtc-client';
-jest.mock('sip.js/lib/platform/web/transport');
-jest.mock('sip.js/lib/api/user-agent', () => ({
-    start: () => { },
-    UserAgent: class UserAgent {
-        static makeURI = () => null;
-        start = () => { };
-        transport = {};
-    },
-}));
-const client = new WebRTCClient({}, undefined, undefined);
-describe('WebRTC client', () => {
-    it('should compute muted/unmuted state', async () => {
-        const mutedSession = {
-            sessionDescriptionHandler: {
-                peerConnection: {
-                    getSenders: () => [{
-                            track: {
-                                kind: 'audio',
-                                enabled: false,
-                            },
-                        }],
-                },
-            },
-        };
-        const unMutedSession = {
-            sessionDescriptionHandler: {
-                peerConnection: {
-                    getSenders: () => [{
-                            track: {
-                                kind: 'audio',
-                                enabled: true,
-                            },
-                        }],
-                },
-            },
-        };
-        const oldKindMuted = {
-            sessionDescriptionHandler: {
-                peerConnection: {
-                    getLocalStreams: () => [{
-                            getAudioTracks: () => [{
-                                    enabled: false,
-                                }],
-                        }],
-                },
-            },
-        };
-        const oldKindUnmuted = {
-            sessionDescriptionHandler: {
-                peerConnection: {
-                    getLocalStreams: () => [{
-                            getAudioTracks: () => [{
-                                    enabled: true,
-                                }],
-                        }],
-                },
-            },
-        };
-        expect(client.isAudioMuted(mutedSession)).toBeTruthy();
-        expect(client.isAudioMuted(oldKindMuted)).toBeTruthy();
-        expect(client.isAudioMuted(unMutedSession)).toBeFalsy();
-        expect(client.isAudioMuted(oldKindUnmuted)).toBeFalsy();
-    });
-});
-describe('changeAudioInputDevice', () => {
-    const defaultId = 'default';
-    const deviceId = 'device1';
-    const constraints = {
-        audio: {
-            deviceId: {
-                exact: defaultId,
-            },
-        },
-        video: null,
-    };
-    const session = {
-        sessionDescriptionHandler: {
-            peerConnection: {
-                getSenders: () => [{
-                        track: {
-                            kind: 'audio',
-                            enabled: true,
-                        },
-                    }],
-            },
-        },
-    };
-    const stream = {};
-    const getAudioTracksMock = jest.fn(() => []);
-    Object.defineProperty(stream, 'getAudioTracks', {
-        value: getAudioTracksMock,
-    });
-    const getUserMediaMock = jest.fn(async () => {
-        return new Promise(resolve => {
-            resolve(stream);
-        });
-    });
-    const devices = [{
-            deviceId: 'default',
-            kind: 'audioinput',
-            label: 'Default - Fake Microphone',
-            groupId: 'fak3Gr0up3',
-        }, {
-            deviceId: 'fak3d3v1c3',
-            kind: 'audioinput',
-            label: 'Fake Microphone',
-            groupId: 'fak3Gr0up3',
-        }];
-    const enumerateDevicesMock = jest.fn(async () => {
-        return new Promise(resolve => {
-            resolve(devices);
-        });
-    });
-    Object.defineProperty(global.navigator, 'mediaDevices', {
-        value: {
-            getUserMedia: getUserMediaMock,
-            enumerateDevices: enumerateDevicesMock,
-        },
-    });
-    it('should change the audio input track if the provided id is different', async () => {
-        client.setMediaConstraints(constraints);
-        expect(client.getAudioDeviceId()).toBe(defaultId);
-        const result = await client.changeAudioInputDevice(deviceId, session);
-        expect(result).toBeTruthy();
-    });
-    it('should NOT change the audio input track if the provided id is the same', async () => {
-        client.setMediaConstraints(constraints);
-        expect(client.getAudioDeviceId()).toBe(defaultId);
-        const result = await client.changeAudioInputDevice(defaultId, session);
-        expect(result).toBeFalsy();
-    });
-    it('should change the audio input track if the provided id is the same and force param is TRUE', async () => {
-        client.setMediaConstraints(constraints);
-        expect(client.getAudioDeviceId()).toBe(defaultId);
-        const result = await client.changeAudioInputDevice(defaultId, session, true);
-        expect(result).toBeTruthy();
-    });
-    describe('setVideoInputDevice', () => {
-        it('should retain its original video values', () => {
-            const video = {
-                height: {
-                    min: 480,
-                    max: 720,
-                },
-                width: {
-                    min: 640,
-                    max: 1280,
-                },
-            };
-            client.video = video;
-            client.setVideoInputDevice(deviceId);
-            expect(client.video).toEqual({ ...video,
-                deviceId: {
-                    exact: deviceId,
-                },
-            });
-        });
-        it('should set deviceId when video\'s original value is true', () => {
-            client.video = true;
-            client.setVideoInputDevice(deviceId);
-            expect(client.video).toEqual({
-                deviceId: {
-                    exact: deviceId,
-                },
-            });
-        });
-        it('should set deviceId when video\'s original value is not set', () => {
-            client.video = undefined;
-            client.setVideoInputDevice(deviceId);
-            expect(client.video).toEqual({
-                deviceId: {
-                    exact: deviceId,
-                },
-            });
-        });
-        it('should NOT set deviceId when its value does not change', () => {
-            client.video = {
-                deviceId: {
-                    exact: deviceId,
-                },
-            };
-            const result = client.setVideoInputDevice(deviceId);
-            expect(result).toEqual(null);
-            expect(client.video).toEqual({
-                deviceId: {
-                    exact: deviceId,
-                },
-            });
-        });
-    });
-});

package/esm/api/agentd.js

@@ -1,23 +0,0 @@
-import ApiRequester from '../utils/api-requester';
-import Agent from '../domain/Agent';
-export default ((client, baseUrl) => ({
-    getAgent: (agentId) => client.get(`${baseUrl}/agents/by-id/${agentId}`, null).then(Agent.parse),
-    login: (agentNumber, context, extension) => client.post(`${baseUrl}/agents/by-number/${agentNumber}/login`, {
-        context,
-        extension,
-    }, null, ApiRequester.successResponseParser),
-    loginWithLineId: (lineId) => client.post(`${baseUrl}/users/me/agents/login`, {
-        line_id: lineId,
-    }, null, ApiRequester.successResponseParser),
-    logout: (agentNumber) => client.post(`${baseUrl}/agents/by-number/${agentNumber}/logoff`, null, null, ApiRequester.successResponseParser),
-    pause: (agentNumber) => client.post(`${baseUrl}/agents/by-number/${agentNumber}/pause`, {
-        reason: 'songbird_reason',
-    }, null, ApiRequester.successResponseParser),
-    resume: (agentNumber) => client.post(`${baseUrl}/agents/by-number/${agentNumber}/unpause`, null, null, ApiRequester.successResponseParser),
-    getStatus: () => client.get(`${baseUrl}/users/me/agents`, null).then(Agent.parse),
-    staticLogout: () => client.post(`${baseUrl}/users/me/agents/logoff`, null, null, ApiRequester.successResponseParser),
-    staticPause: () => client.post(`${baseUrl}/users/me/agents/pause`, {
-        reason: 'songbird_reason',
-    }, null, ApiRequester.successResponseParser),
-    staticResume: () => client.post(`${baseUrl}/users/me/agents/unpause`, null, null, ApiRequester.successResponseParser),
-}));

package/esm/api/amid.js

@@ -1,17 +0,0 @@
-export default ((client, baseUrl) => ({
-    action: (action, args = {}) => client.post(`${baseUrl}/action/${action}`, args),
-    getAors: async (endpoint) => {
-        try {
-            const rawEvents = await client.post(`${baseUrl}/action/PJSIPShowEndpoint`, {
-                Endpoint: endpoint,
-            }) || [];
-            if (!rawEvents) {
-                return [];
-            }
-            return rawEvents.filter((event) => event.Event === 'ContactStatusDetail');
-        }
-        catch {
-            return [];
-        }
-    },
-}));

package/esm/api/application.js

@@ -1,63 +0,0 @@
-/* eslint-disable camelcase */
-import ApiRequester from '../utils/api-requester';
-export default ((client, baseUrl) => ({
-    bridgeCall(applicationUuid, callId, context, exten, autoanswer, displayed_caller_id_number) {
-        const url = `${baseUrl}/${applicationUuid}/nodes`;
-        const body = {
-            calls: [{
-                    id: callId,
-                }],
-        };
-        return client.post(url, body, null, (res) => res.json().then((response) => response.uuid)).then((nodeUuid) => client.post(`${url}/${nodeUuid}/calls`, {
-            context,
-            exten,
-            autoanswer,
-            displayed_caller_id_number,
-        }).then((data) => ({
-            nodeUuid,
-            data,
-        })));
-    },
-    answerCall: (applicationUuid, callId) => client.put(`${baseUrl}/${applicationUuid}/calls/${callId}/answer`, {}, null, ApiRequester.successResponseParser),
-    calls: (applicationUuid) => client.get(`${baseUrl}/${applicationUuid}/calls`),
-    hangupCall: (applicationUuid, callId) => client.delete(`${baseUrl}/${applicationUuid}/calls/${callId}`),
-    startPlaybackCall: (applicationUuid, callId, language, uri) => client.post(`${baseUrl}/${applicationUuid}/calls/${callId}/playbacks`, {
-        language,
-        uri,
-    }),
-    stopPlaybackCall: (applicationUuid, playbackUuid) => client.delete(`${baseUrl}/${applicationUuid}/playbacks/${playbackUuid}`),
-    startProgressCall: (applicationUuid, callId) => client.put(`${baseUrl}/${applicationUuid}/calls/${callId}/progress/start`, {}, null, ApiRequester.successResponseParser),
-    stopProgressCall: (applicationUuid, callId) => client.put(`${baseUrl}/${applicationUuid}/calls/${callId}/progress/stop`, {}, null, ApiRequester.successResponseParser),
-    startMohCall: (applicationUuid, callId, mohUuid) => client.put(`${baseUrl}/${applicationUuid}/calls/${callId}/moh/${mohUuid}/start`, {}, null, ApiRequester.successResponseParser),
-    stopMohCall: (applicationUuid, callId) => client.put(`${baseUrl}/${applicationUuid}/calls/${callId}/moh/stop`, {}, null, ApiRequester.successResponseParser),
-    startHoldCall: (applicationUuid, callId) => client.put(`${baseUrl}/${applicationUuid}/calls/${callId}/hold/start`, {}, null, ApiRequester.successResponseParser),
-    stopHoldCall: (applicationUuid, callId) => client.put(`${baseUrl}/${applicationUuid}/calls/${callId}/hold/stop`, {}, null, ApiRequester.successResponseParser),
-    startMuteCall: (applicationUuid, callId) => client.put(`${baseUrl}/${applicationUuid}/calls/${callId}/mute/start`, {}, null, ApiRequester.successResponseParser),
-    stopMuteCall: (applicationUuid, callId) => client.put(`${baseUrl}/${applicationUuid}/calls/${callId}/mute/stop`, {}, null, ApiRequester.successResponseParser),
-    sendDTMFCall: (applicationUuid, callId, digits) => client.put(`${baseUrl}/${applicationUuid}/calls/${callId}/dtmf`, {
-        digits,
-    }, null, ApiRequester.successResponseParser),
-    addCallNodes: (applicationUuid, nodeUuid, callId) => client.put(`${baseUrl}/${applicationUuid}/nodes/${nodeUuid}/calls/${callId}`, {}, null, ApiRequester.successResponseParser),
-    createNewNodeWithCall: (applicationUuid, calls) => client.post(`${baseUrl}/${applicationUuid}/nodes`, {
-        calls,
-    }),
-    addNewCallNodes: (applicationUuid, nodeUuid, context, exten, autoanswer) => client.post(`${baseUrl}/${applicationUuid}/nodes/${nodeUuid}/calls`, {
-        context,
-        exten,
-        autoanswer,
-    }),
-    listCallsNodes: (applicationUuid, nodeUuid) => client.get(`${baseUrl}/${applicationUuid}/nodes/${nodeUuid}`),
-    listNodes: (applicationUuid) => client.get(`${baseUrl}/${applicationUuid}/nodes`),
-    removeNode: (applicationUuid, nodeUuid) => client.delete(`${baseUrl}/${applicationUuid}/nodes/${nodeUuid}`),
-    removeCallNodes: (applicationUuid, nodeUuid, callId) => client.delete(`${baseUrl}/${applicationUuid}/nodes/${nodeUuid}/calls/${callId}`),
-    listSnoop: (applicationUuid) => client.get(`${baseUrl}/${applicationUuid}/snoops`),
-    removeSnoop: (applicationUuid, snoopUuid) => client.delete(`${baseUrl}/${applicationUuid}/snoops/${snoopUuid}`),
-    viewSnoop: (applicationUuid, snoopUuid) => client.get(`${baseUrl}/${applicationUuid}/snoops/${snoopUuid}`),
-    createSnoop: (applicationUuid, callId, snoopingCallId, whisperMode) => client.post(`${baseUrl}/${applicationUuid}/calls/${callId}/snoops`, {
-        snooping_call_id: snoopingCallId,
-        whisper_mode: whisperMode,
-    }),
-    updateSnoop: (applicationUuid, snoopUuid, whisperMode) => client.put(`${baseUrl}/${applicationUuid}/snoops/${snoopUuid}`, {
-        whisper_mode: whisperMode,
-    }, null, ApiRequester.successResponseParser),
-}));