@wazo/sdk 0.43.15 → 0.44.1

package/src/__tests__/api-client.test.ts

@@ -1,315 +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) as any),
-    });
-  });
-
-  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,
-      } as any) as any;
-      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 as any);
-      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) as any),
-    });
-  });
-
-  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) as any),
-    });
-  });
-
-  describe('fetchVoicemail test', () => {
-    it('should throw a BadResponse instance on 404 status', async () => {
-      let error = null;
-
-      try {
-        await client.calld.listVoicemails();
-      } catch (e: any) {
-        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) as any),
-    });
-  });
-
-  it('throw an exception when the response is >= 500', async () => {
-    let error = null;
-
-    try {
-      await client.auth.logIn({
-        username,
-        password,
-      } as any);
-    } catch (e: any) {
-      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) as any),
-    });
-  });
-
-  it('throw an exception when the response is >= 500', async () => {
-    let error = null;
-
-    try {
-      await client.auth.logIn({
-        username,
-        password,
-      } as any);
-    } catch (e: any) {
-      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/src/__tests__/web-rtc-client.test.ts

@@ -1,198 +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 = () => null;
-
-    start = () => {};
-
-    transport = {};
-  },
-}));
-
-const client = new WebRTCClient({} as any, 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 as any)).toBeTruthy();
-    expect(client.isAudioMuted(oldKindMuted as any)).toBeTruthy();
-    expect(client.isAudioMuted(unMutedSession as any)).toBeFalsy();
-    expect(client.isAudioMuted(oldKindUnmuted as any)).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 as any);
-    expect(client.getAudioDeviceId()).toBe(defaultId);
-    const result = await client.changeAudioInputDevice(deviceId, session as any);
-    expect(result).toBeTruthy();
-  });
-  it('should NOT change the audio input track if the provided id is the same', async () => {
-    client.setMediaConstraints(constraints as any);
-    expect(client.getAudioDeviceId()).toBe(defaultId);
-    const result = await client.changeAudioInputDevice(defaultId, session as any);
-    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 as any);
-    expect(client.getAudioDeviceId()).toBe(defaultId);
-    const result = await client.changeAudioInputDevice(defaultId, session as any, 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/src/api/agentd.ts

@@ -1,37 +0,0 @@
-import ApiRequester from '../utils/api-requester';
-import Agent from '../domain/Agent';
-
-export interface AgentD {
-  getAgent: (agentId: string) => Promise<Agent>;
-  login: (agentNumber: string, context: string, extension: string) => Promise<boolean>;
-  loginWithLineId: (lineId: number) => Promise<boolean>;
-  logout: (agentNumber: string) => Promise<boolean>;
-  pause: (agentNumber: string) => Promise<boolean>;
-  resume: (agentNumber: string) => Promise<boolean>;
-  getStatus: () => Promise<Agent>;
-  staticLogout: () => Promise<boolean>;
-  staticPause: () => Promise<boolean>;
-  staticResume: () => Promise<boolean>;
-}
-
-export default ((client: ApiRequester, baseUrl: string): AgentD => ({
-  getAgent: (agentId: string): Promise<Agent> => client.get(`${baseUrl}/agents/by-id/${agentId}`, null).then(Agent.parse),
-  login: (agentNumber: string, context: string, extension: string) => client.post(`${baseUrl}/agents/by-number/${agentNumber}/login`, {
-    context,
-    extension,
-  }, null, ApiRequester.successResponseParser),
-  loginWithLineId: (lineId: number) => client.post(`${baseUrl}/users/me/agents/login`, {
-    line_id: lineId,
-  }, null, ApiRequester.successResponseParser),
-  logout: (agentNumber: string) => client.post(`${baseUrl}/agents/by-number/${agentNumber}/logoff`, null, null, ApiRequester.successResponseParser),
-  pause: (agentNumber: string) => client.post(`${baseUrl}/agents/by-number/${agentNumber}/pause`, {
-    reason: 'songbird_reason',
-  }, null, ApiRequester.successResponseParser),
-  resume: (agentNumber: string) => client.post(`${baseUrl}/agents/by-number/${agentNumber}/unpause`, null, null, ApiRequester.successResponseParser),
-  getStatus: (): Promise<Agent> => 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/src/api/amid.ts

@@ -1,25 +0,0 @@
-import ApiRequester from '../utils/api-requester';
-
-export interface AmiD {
-  action: (action: string, args: Record<string, any>) => Promise<string>;
-  getAors: (endpoint: string) => Promise<any[]>;
-}
-
-export default ((client: ApiRequester, baseUrl: string): AmiD => ({
-  action: (action: string, args: Record<string, any> = {}): Promise<string> => client.post(`${baseUrl}/action/${action}`, args),
-  getAors: async (endpoint: string) => {
-    try {
-      const rawEvents = await client.post(`${baseUrl}/action/PJSIPShowEndpoint`, {
-        Endpoint: endpoint,
-      }) || [];
-
-      if (!rawEvents) {
-        return [];
-      }
-
-      return rawEvents.filter((event: Record<string, any>) => event.Event === 'ContactStatusDetail');
-    } catch {
-      return [];
-    }
-  },
-}));

package/src/api/application.ts

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