@wazo/sdk 0.38.21 → 0.39.0-beta.1

package/src/api/application.ts

@@ -0,0 +1,96 @@
+/* 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),
+}));

package/src/api/auth.ts

@@ -0,0 +1,259 @@
+import ApiRequester from '../utils/api-requester';
+import type { User, Tenant, Token, UUID, LogoutResponse, ListTenantsResponse, RequestError, ListUsersResponse, ListGroupsResponse, ListPoliciesResponse, GetTenantResponse, GetUserResponse } from '../domain/types';
+import Session, { Response } from '../domain/Session';
+
+export const DEFAULT_BACKEND_USER = 'wazo_user';
+export const BACKEND_LDAP_USER = 'ldap_user';
+export const DETAULT_EXPIRATION = 3600;
+
+type LoginParams = {
+  username: string;
+  password: string;
+  backend: string;
+  expiration: number;
+  mobile?: boolean;
+  tenantId?: string;
+  domainName?: string;
+};
+
+type SendResetPasswordArgs = {
+  username: string,
+  email: string,
+};
+
+export interface AuthD {
+  checkToken: (token: Token) => Promise<boolean>;
+  authenticate: (token: Token) => Promise<Session | null | undefined>;
+  logIn(params: LoginParams): Promise<Session | null | undefined> ;
+  logOut: (token: Token) => Promise<LogoutResponse>;
+  refreshToken: (refreshToken: string, backend: string, expiration: number, isMobile?: boolean, tenantId?: string, domainName?: string) => Promise<Session | null | undefined>;
+  deleteRefreshToken: (clientId: string) => Promise<boolean>;
+  updatePassword: (userUuid: UUID, oldPassword: string, newPassword: string) => Promise<boolean>;
+  sendDeviceToken: (userUuid: UUID, deviceToken: string, apnsVoipToken: string | null | undefined, apnsNotificationToken: string | null | undefined) => Promise<void>;
+  getPushNotificationSenderId: (userUuid: UUID) => Promise<string>;
+  sendResetPasswordEmail: (params: SendResetPasswordArgs) => Promise<boolean>;
+  resetPassword: (userUuid: string, password: string) => Promise<boolean>;
+  removeDeviceToken: (userUuid: UUID) => Promise<void>;
+  createUser: (username: string, password: string, firstname: string, lastname: string) => Promise<User | RequestError>;
+  addUserEmail: (userUuid: UUID, email: string, main?: boolean) => Promise<void>;
+  addUserPolicy: (userUuid: UUID, policyUuid: UUID) => Promise<void>;
+  getRestrictionPolicies: (scopes: string[]) => Promise<any>;
+  deleteUserPolicy: (userUuid: UUID, policyUuid: UUID) => Promise<any>;
+  addUserGroup: (userUuid: UUID, groupUuid: UUID) => Promise<any>;
+  listUsersGroup: (groupUuid: UUID) => Promise<any>;
+  deleteUserGroup: (userUuid: UUID, groupUuid: UUID) => Promise<void>;
+  getUser: (userUuid: UUID) => Promise<GetUserResponse>;
+  getUserSession: (userUuid: UUID) => Promise<any>; // @TODO
+  deleteUserSession: (userUuid: UUID, sessionUuids: UUID) => Promise<void>;
+  listUsers: () => Promise<ListUsersResponse>;
+  deleteUser: (userUuid: UUID) => Promise<boolean | RequestError>;
+  listTenants: () => Promise<ListTenantsResponse>;
+  getTenant: (tenantUuid: UUID) => Promise<GetTenantResponse>;
+  createTenant: (name: string) => Promise<Tenant | RequestError>;
+  updateTenant: (uuid: UUID, name: string, contact: string, phone: string, address: Array<Record<string, any>>) => Promise<Tenant | RequestError>;
+  deleteTenant: (uuid: UUID) => Promise<boolean | RequestError>;
+  createGroup: (name: string) => Promise<void>;
+  listGroups: () => Promise<ListGroupsResponse>;
+  deleteGroup: (uuid: UUID) => Promise<boolean | RequestError>;
+  createPolicy: (name: string, description: string, aclTemplates: Array<Record<string, any>>) => Promise<void>;
+  listPolicies: () => Promise<ListPoliciesResponse>;
+  deletePolicy: (policyUuid: UUID) => Promise<boolean | RequestError>;
+  getProviders: (userUuid: UUID) => Promise<any>; // @TODO
+  getProviderToken: (userUuid: UUID, provider: string) => Promise<string>; // @TODO; validate
+  getProviderAuthUrl: (userUuid: UUID, provider: string) => Promise<string>;
+  deleteProviderToken: (userUuid: UUID, provider: string) => Promise<void>;
+}
+
+export default ((client: ApiRequester, baseUrl: string): AuthD => ({
+  checkToken: (token: Token): Promise<boolean> => client.head(`${baseUrl}/token/${token}`, null, {}),
+  authenticate: (token: Token): Promise<Session | null | undefined> => client.get(`${baseUrl}/token/${token}`, null, {}).then((response: Response) => Session.parse(response)),
+
+  logIn(params: {
+    username: string;
+    password: string;
+    backend: string;
+    expiration: number;
+    mobile?: boolean;
+    tenantId?: string;
+    domainName?: string;
+  }): Promise<Session | null | undefined> {
+    const body: Record<string, any> = {
+      backend: params.backend || DEFAULT_BACKEND_USER,
+      expiration: params.expiration || DETAULT_EXPIRATION,
+    };
+    const headers: Record<string, any> = {
+      Authorization: `Basic ${ApiRequester.base64Encode(`${params.username}:${params.password}`)}`,
+      'Content-Type': 'application/json',
+    };
+
+    if (client.clientId) {
+      body.access_type = 'offline';
+      body.client_id = client.clientId;
+    }
+
+    if (params.mobile) {
+      headers['Wazo-Session-Type'] = 'mobile';
+    }
+
+    if (params.tenantId) {
+      console.warn('Use of `tenantId` is deprecated when calling logIn() method, use `domainName` instead.');
+      body.tenant_id = params.tenantId;
+    }
+
+    if (params.domainName) {
+      body.domain_name = params.domainName;
+    }
+
+    return client.post(`${baseUrl}/token`, body, headers).then((response: Response) => Session.parse(response));
+  },
+
+  logOut: (token: Token): Promise<LogoutResponse> => client.delete(`${baseUrl}/token/${token}`, null, {}, ApiRequester.successResponseParser),
+  refreshToken: (refreshToken: string, backend: string, expiration: number, isMobile?: boolean, tenantId?: string, domainName?: string): Promise<Session | null | undefined> => {
+    const body: Record<string, any> = {
+      backend: backend || DEFAULT_BACKEND_USER,
+      expiration: expiration || DETAULT_EXPIRATION,
+      refresh_token: refreshToken,
+      client_id: client.clientId,
+    };
+
+    if (tenantId) {
+      console.warn('Use of `tenantId` is deprecated when calling refreshToken() method, use `domainName` instead.');
+      body.tenant_id = tenantId;
+    }
+
+    if (domainName) {
+      body.domain_name = domainName;
+    }
+
+    const headers: Record<string, any> = {
+      'Content-Type': 'application/json',
+      ...(isMobile ? {
+        'Wazo-Session-Type': 'mobile',
+      } : {}),
+    };
+    return client.post(`${baseUrl}/token`, body, headers, ApiRequester.defaultParser, false).then(Session.parse);
+  },
+  deleteRefreshToken: (clientId: string): Promise<boolean> => client.delete(`${baseUrl}/users/me/tokens/${clientId}`, null, null, ApiRequester.successResponseParser),
+  updatePassword: (userUuid: UUID, oldPassword: string, newPassword: string): Promise<boolean> => {
+    const body = {
+      new_password: newPassword,
+      old_password: oldPassword,
+    };
+    return client.put(`${baseUrl}/users/${userUuid}/password`, body, null, ApiRequester.successResponseParser);
+  },
+  sendDeviceToken: (userUuid: UUID, deviceToken: string, apnsVoipToken: string | null | undefined, apnsNotificationToken: string | null | undefined) => {
+    const body: Record<string, any> = {
+      token: deviceToken,
+    };
+
+    if (apnsVoipToken) {
+      // Should be called `voip_token`, but we can't changed it to be retro-compatible
+      body.apns_token = apnsVoipToken;
+      body.apns_voip_token = apnsVoipToken;
+    }
+
+    if (apnsNotificationToken) {
+      body.apns_notification_token = apnsNotificationToken;
+    }
+
+    return client.post(`${baseUrl}/users/${userUuid}/external/mobile`, body);
+  },
+  getPushNotificationSenderId: (userUuid: UUID) => client.get(`${baseUrl}/users/${userUuid}/external/mobile/sender_id`, null).then((response: Record<string, any>) => response.sender_id),
+
+  /**
+   * `username` or `email` should be set.
+   */
+  sendResetPasswordEmail: ({
+    username,
+    email,
+  }: {
+    username: string | null | undefined;
+    email: string | null | undefined;
+  }) => {
+    const body: any = {};
+
+    if (username) {
+      body.username = username;
+    }
+
+    if (email) {
+      body.email = email;
+    }
+
+    return client.get(`${baseUrl}/users/password/reset`, body, {}, ApiRequester.successResponseParser);
+  },
+  resetPassword: (userUuid: string, password: string) => {
+    const body = {
+      password,
+    };
+    return client.post(`${baseUrl}/users/password/reset?user_uuid=${userUuid}`, body, null, ApiRequester.successResponseParser);
+  },
+  removeDeviceToken: (userUuid: UUID) => client.delete(`${baseUrl}/users/${userUuid}/external/mobile`),
+  createUser: (username: string, password: string, firstname: string, lastname: string): Promise<User | RequestError> => {
+    const body = {
+      username,
+      password,
+      firstname,
+      lastname,
+    };
+    return client.post(`${baseUrl}/users`, body);
+  },
+  addUserEmail: (userUuid: UUID, email: string, main?: boolean) => {
+    const body = {
+      emails: [{
+        address: email,
+        main,
+      }],
+    };
+    return client.put(`${baseUrl}/users/${userUuid}/emails`, body);
+  },
+  addUserPolicy: (userUuid: UUID, policyUuid: UUID) => client.put(`${baseUrl}/users/${userUuid}/policies/${policyUuid}`),
+  getRestrictionPolicies: (scopes: string[]) => client.post(`${baseUrl}/token/${client.token}/scopes/check`, {
+    scopes,
+  }),
+  deleteUserPolicy: (userUuid: UUID, policyUuid: UUID) => client.delete(`${baseUrl}/users/${userUuid}/policies/${policyUuid}`),
+  addUserGroup: (userUuid: UUID, groupUuid: UUID) => client.put(`${baseUrl}/groups/${groupUuid}/users/${userUuid}`),
+  listUsersGroup: (groupUuid: UUID) => client.get(`${baseUrl}/groups/${groupUuid}/users`),
+  deleteUserGroup: (userUuid: UUID, groupUuid: UUID) => client.delete(`${baseUrl}/groups/${groupUuid}/users/${userUuid}`),
+  getUser: (userUuid: UUID): Promise<GetUserResponse> => client.get(`${baseUrl}/users/${userUuid}`),
+  getUserSession: (userUuid: UUID) => client.get(`${baseUrl}/users/${userUuid}/sessions`),
+  deleteUserSession: (userUuid: UUID, sessionUuids: UUID) => client.delete(`${baseUrl}/users/${userUuid}/sessions/${sessionUuids}`),
+  listUsers: (): Promise<ListUsersResponse> => client.get(`${baseUrl}/users`),
+  deleteUser: (userUuid: UUID): Promise<boolean | RequestError> => client.delete(`${baseUrl}/users/${userUuid}`),
+  listTenants: (): Promise<ListTenantsResponse> => client.get(`${baseUrl}/tenants`),
+  getTenant: (tenantUuid: UUID): Promise<GetTenantResponse> => client.get(`${baseUrl}/tenants/${tenantUuid}`),
+  createTenant: (name: string): Promise<Tenant | RequestError> => client.post(`${baseUrl}/tenants`, {
+    name,
+  }),
+  updateTenant: (uuid: UUID, name: string, contact: string, phone: string, address: Array<Record<string, any>>): Promise<Tenant | RequestError> => {
+    const body = {
+      name,
+      contact,
+      phone,
+      address,
+    };
+    return client.put(`${baseUrl}/tenants/${uuid}`, body);
+  },
+  deleteTenant: (uuid: UUID): Promise<boolean | RequestError> => client.delete(`${baseUrl}/tenants/${uuid}`),
+  createGroup: (name: string) => client.post(`${baseUrl}/groups`, {
+    name,
+  }),
+  listGroups: (): Promise<ListGroupsResponse> => client.get(`${baseUrl}/groups`),
+  deleteGroup: (uuid: UUID): Promise<boolean | RequestError> => client.delete(`${baseUrl}/groups/${uuid}`),
+  createPolicy: (name: string, description: string, aclTemplates: Array<Record<string, any>>) => {
+    const body = {
+      name,
+      description,
+      acl_templates: aclTemplates,
+      // deprecated
+      acl: aclTemplates,
+    };
+    return client.post(`${baseUrl}/policies`, body);
+  },
+  listPolicies: (): Promise<ListPoliciesResponse> => client.get(`${baseUrl}/policies`),
+  deletePolicy: (policyUuid: UUID): Promise<boolean | RequestError> => client.delete(`${baseUrl}/policies/${policyUuid}`),
+  getProviders: (userUuid: UUID) => client.get(`${baseUrl}/users/${userUuid}/external`),
+  getProviderToken: (userUuid: UUID, provider: string) => client.get(`${baseUrl}/users/${userUuid}/external/${provider}`),
+  getProviderAuthUrl: (userUuid: UUID, provider: string) => client.post(`${baseUrl}/users/${userUuid}/external/${provider}`, {}),
+  deleteProviderToken: (userUuid: UUID, provider: string) => client.delete(`${baseUrl}/users/${userUuid}/external/${provider}`),
+}));

package/src/api/call-logd.ts

@@ -0,0 +1,38 @@
+import ApiRequester from '../utils/api-requester';
+import CallLog from '../domain/CallLog';
+
+export interface CallLogD {
+  search: (search: string, limit: number) => Promise<Array<CallLog>>;
+  searchBy: (field: string, value: string, limit: number) => Promise<Array<CallLog>>;
+  listCallLogs: (offset?: number, limit?: number) => Promise<Array<CallLog>>;
+  listDistinctCallLogs: (offset: number, limit: number, distinct?: string) => Promise<Array<CallLog>>;
+  listCallLogsFromDate: (from: Date, number: string) => Promise<Array<CallLog>>;
+}
+
+export default ((client: ApiRequester, baseUrl: string): CallLogD => ({
+  search: (search: string, limit = 5): Promise<Array<CallLog>> => client.get(`${baseUrl}/users/me/cdr`, {
+    search,
+    limit,
+  }).then(CallLog.parseMany),
+
+  searchBy: (field: string, value: string, limit = 5): Promise<Array<CallLog>> => client.get(`${baseUrl}/users/me/cdr`, {
+    [field]: value,
+    limit,
+  }).then(CallLog.parseMany),
+
+  listCallLogs: (offset?: number, limit = 5): Promise<Array<CallLog>> => client.get(`${baseUrl}/users/me/cdr`, {
+    offset,
+    limit,
+  }).then(CallLog.parseMany),
+
+  listDistinctCallLogs: (offset: number, limit = 5, distinct = undefined): Promise<Array<CallLog>> => client.get(`${baseUrl}/users/me/cdr`, {
+    offset,
+    limit,
+    distinct,
+  }).then(CallLog.parseMany),
+
+  listCallLogsFromDate: (from: Date, number: string): Promise<Array<CallLog>> => client.get(`${baseUrl}/users/me/cdr`, {
+    from: from.toISOString(),
+    number,
+  }).then(CallLog.parseMany),
+}));

package/src/api/calld.ts

@@ -0,0 +1,183 @@
+/* eslint-disable camelcase */
+import ApiRequester from '../utils/api-requester';
+import type { UUID, RequestError } from '../domain/types';
+import Relocation, { RelocationResponse } from '../domain/Relocation';
+import ChatMessage, { ChatMessageListResponse } from '../domain/ChatMessage';
+import Voicemail from '../domain/Voicemail';
+import Call, { CallResponse } from '../domain/Call';
+import IndirectTransfer from '../domain/IndirectTransfer';
+import MeetingStatus from '../domain/MeetingStatus';
+
+type CallQuery = {
+  from_mobile: boolean;
+  extension: string;
+  line_id?: number;
+  all_lines?: boolean;
+};
+
+export interface CallD {
+  updatePresence: (presence: string) => Promise<boolean>;
+  listMessages: (participantUuid: UUID | null | undefined, limit?: number) => Promise<Array<ChatMessage>>;
+  sendMessage: (alias: string, msg: string, toUserId: string) => Promise<boolean>;
+  makeCall: (extension: string, fromMobile: boolean, lineId: number | null | undefined, allLines: boolean | null | undefined) => Promise<CallResponse>;
+  cancelCall: (callId: string) => Promise<boolean>;
+  listCalls: () => Promise<Array<Call>>;
+  relocateCall: (callId: string, destination: string, lineId: number | null | undefined, contact?: string | null | undefined) => Promise<Relocation>;
+  listVoicemails: () => Promise<RequestError | Array<Voicemail>>;
+  deleteVoicemail: (voicemailId: number) => Promise<boolean>;
+  getVoicemailUrl: (voicemail: Voicemail) => string;
+  fetchSwitchboardHeldCalls: (switchboardUuid: UUID) => Promise<any>; // @TODO: replace `any`
+  holdSwitchboardCall: (switchboardUuid: UUID, callId: string) => Promise<boolean>;
+  answerSwitchboardHeldCall: (switchboardUuid: UUID, callId: string, lineId: string | null | undefined) => Promise<void>;
+  fetchSwitchboardQueuedCalls: (switchboardUuid: UUID) => Promise<any>; // @TODO: replace `any`
+  answerSwitchboardQueuedCall: (switchboardUuid: UUID, callId: string, lineId: string | null | undefined) => Promise<any>; // @TODO: replace `any`
+  sendFax: (extension: string, fax: string, callerId: string | null | undefined) => Promise<void>;
+  getConferenceParticipantsAsUser: (conferenceId: string) => Promise<Record<string, any>>; // @TODO: replace `any`
+  getMeetingParticipantsAsUser: (meetingUuid: string) => Promise<Record<string, any>>; // @TODO: replace `any`
+  banMeetingParticipant: (meetingUuid: string, participantUuid: string) => Promise<boolean>;
+  listTrunks: () => Promise<any>;
+  mute: (callId: string) => Promise<boolean>;
+  unmute: (callId: string) => Promise<boolean>;
+  hold: (callId: string) => Promise<boolean>;
+  resume: (callId: string) => Promise<boolean>;
+  // eslint-disable-next-line camelcase
+  transferCall: (initiator_call: string, exten: string, flow: string) => Promise<IndirectTransfer>;
+  confirmCallTransfer: (transferId: string) => Promise<boolean>;
+  cancelCallTransfer: (transferId: string) => Promise<boolean>;
+  sendDTMF: (callId: string, digits: string) => Promise<boolean>;
+  // @deprecated: check for engine version >= 20.12 instead
+  isAhHocConferenceAPIEnabled: () => Promise<boolean>;
+  createAdHocConference: (hostCallId: string, participantCallIds: string[]) => Promise<any>; // @TODO: replace `any`
+  addAdHocConferenceParticipant: (conferenceId: string, callId: string) => Promise<boolean>;
+  removeAdHocConferenceParticipant: (conferenceId: string, participantCallId: string) => Promise<boolean>;
+  deleteAdHocConference: (conferenceId: string) => Promise<boolean>;
+  startRecording: (callId: string) => Promise<boolean>;
+  stopRecording: (callId: string) => Promise<boolean>;
+  pauseRecording: (callId: string) => Promise<boolean>;
+  resumeRecording: (callId: string) => Promise<boolean>;
+  guestGetMeetingStatus: (meetingUuid: string) => Promise<MeetingStatus>
+}
+
+export default ((client: ApiRequester, baseUrl: string): CallD => ({
+  updatePresence: (presence: string): Promise<boolean> => client.put(`${baseUrl}/users/me/presences`, {
+    presence,
+  }, null, ApiRequester.successResponseParser),
+  listMessages: (participantUuid: UUID | null | undefined, limit?: number): Promise<Array<ChatMessage>> => {
+    const query: Record<string, any> = {};
+
+    if (participantUuid) {
+      query.participant_user_uuid = participantUuid;
+    }
+
+    if (limit) {
+      query.limit = limit;
+    }
+
+    return client.get(`${baseUrl}/users/me/chats`, query).then((response: ChatMessageListResponse) => ChatMessage.parseMany(response));
+  },
+  sendMessage: (alias: string, msg: string, toUserId: string) => {
+    const body = {
+      alias,
+      msg,
+      to: toUserId,
+    };
+    return client.post(`${baseUrl}/users/me/chats`, body, null, ApiRequester.successResponseParser);
+  },
+  makeCall: (extension: string, fromMobile: boolean, lineId: number | null | undefined, allLines: boolean | null | undefined = false): Promise<CallResponse> => {
+    const query: CallQuery = {
+      from_mobile: fromMobile,
+      extension,
+    };
+
+    if (lineId) {
+      query.line_id = lineId;
+    }
+
+    if (allLines) {
+      query.all_lines = true;
+    }
+
+    return client.post(`${baseUrl}/users/me/calls`, query);
+  },
+  cancelCall: (callId: string): Promise<boolean> => client.delete(`${baseUrl}/users/me/calls/${callId}`, null),
+  listCalls: (): Promise<Array<Call>> => client.get(`${baseUrl}/users/me/calls`, null).then((response: any) => Call.parseMany(response.items)),
+
+  relocateCall(callId: string, destination: string, lineId: number | null | undefined, contact?: string | null | undefined): Promise<Relocation> {
+    const body: Record<string, any> = {
+      completions: ['answer'],
+      destination,
+      initiator_call: callId,
+      auto_answer: true,
+    };
+
+    if (lineId || contact) {
+      body.location = {};
+    }
+
+    if (lineId) {
+      body.location.line_id = lineId;
+    }
+
+    if (contact) {
+      body.location.contact = contact;
+    }
+
+    return client.post(`${baseUrl}/users/me/relocates`, body).then((response: RelocationResponse) => Relocation.parse(response));
+  },
+
+  listVoicemails: (): Promise<RequestError | Array<Voicemail>> => client.get(`${baseUrl}/users/me/voicemails`).then((response: any) => Voicemail.parseMany(response)),
+  deleteVoicemail: (voicemailId: number): Promise<boolean> => client.delete(`${baseUrl}/users/me/voicemails/messages/${voicemailId}`),
+  getVoicemailUrl: (voicemail: Voicemail): string => {
+    const body = {
+      token: client.token,
+    };
+    return client.computeUrl('get', `${baseUrl}/users/me/voicemails/messages/${voicemail.id}/recording`, body);
+  },
+  fetchSwitchboardHeldCalls: (switchboardUuid: UUID) => client.get(`${baseUrl}/switchboards/${switchboardUuid}/calls/held`),
+  holdSwitchboardCall: (switchboardUuid: UUID, callId: string) => client.put(`${baseUrl}/switchboards/${switchboardUuid}/calls/held/${callId}`, null, null, ApiRequester.successResponseParser),
+  answerSwitchboardHeldCall: (switchboardUuid: UUID, callId: string, lineId: string | null | undefined = null) => client.put(`${baseUrl}/switchboards/${switchboardUuid}/calls/held/${callId}/answer${lineId ? `?line_id=${lineId}` : ''}`),
+  fetchSwitchboardQueuedCalls: (switchboardUuid: UUID) => client.get(`${baseUrl}/switchboards/${switchboardUuid}/calls/queued`),
+  answerSwitchboardQueuedCall: (switchboardUuid: UUID, callId: string, lineId: string | null | undefined = null) => client.put(`${baseUrl}/switchboards/${switchboardUuid}/calls/queued/${callId}/answer${lineId ? `?line_id=${lineId}` : ''}`),
+  sendFax: (extension: string, fax: string, callerId: string | null | undefined = null) => {
+    const headers = {
+      'Content-type': 'application/pdf',
+      'X-Auth-Token': client.token,
+    };
+    const params = ApiRequester.getQueryString({
+      extension,
+      caller_id: callerId,
+    });
+    return client.post(`${baseUrl}/users/me/faxes?${params}`, fax, headers);
+  },
+  getConferenceParticipantsAsUser: async (conferenceId: string): Promise<Record<string, any>> => client.get(`${baseUrl}/users/me/conferences/${conferenceId}/participants`),
+  getMeetingParticipantsAsUser: async (meetingUuid: string): Promise<Record<string, any>> => client.get(`${baseUrl}/users/me/meetings/${meetingUuid}/participants`),
+  banMeetingParticipant: (meetingUuid: string, participantUuid: string) => client.delete(`${baseUrl}/users/me/meetings/${meetingUuid}/participants/${participantUuid}`, null, null, ApiRequester.successResponseParser),
+  listTrunks: () => client.get(`${baseUrl}/trunks`),
+  mute: (callId: string) => client.put(`${baseUrl}/users/me/calls/${callId}/mute/start`, null, null, ApiRequester.successResponseParser),
+  unmute: (callId: string) => client.put(`${baseUrl}/users/me/calls/${callId}/mute/stop`, null, null, ApiRequester.successResponseParser),
+  hold: (callId: string) => client.put(`${baseUrl}/users/me/calls/${callId}/hold/start`, null, null, ApiRequester.successResponseParser),
+  resume: (callId: string) => client.put(`${baseUrl}/users/me/calls/${callId}/hold/stop`, null, null, ApiRequester.successResponseParser),
+  // eslint-disable-next-line camelcase
+  transferCall: (initiator_call: string, exten: string, flow: string) => client.post(`${baseUrl}/users/me/transfers`, {
+    initiator_call,
+    exten,
+    flow,
+  }).then(IndirectTransfer.parseFromApi),
+  confirmCallTransfer: (transferId: string): Promise<boolean> => client.put(`${baseUrl}/users/me/transfers/${transferId}/complete`, null, null, ApiRequester.successResponseParser),
+  cancelCallTransfer: (transferId: string): Promise<boolean> => client.delete(`${baseUrl}/users/me/transfers/${transferId}`, null, null, ApiRequester.successResponseParser),
+  sendDTMF: (callId: string, digits: string) => client.put(`${baseUrl}/users/me/calls/${callId}/dtmf?digits=${encodeURIComponent(digits)}`, null, null, ApiRequester.successResponseParser),
+  // @deprecated: check for engine version >= 20.12 instead
+  isAhHocConferenceAPIEnabled: () => client.head(`${baseUrl}/users/me/conferences/adhoc`, null, null, ApiRequester.successResponseParser),
+  createAdHocConference: (hostCallId: string, participantCallIds: string[]) => client.post(`${baseUrl}/users/me/conferences/adhoc`, {
+    host_call_id: hostCallId,
+    participant_call_ids: participantCallIds,
+  }),
+  addAdHocConferenceParticipant: (conferenceId: string, callId: string) => client.put(`${baseUrl}/users/me/conferences/adhoc/${conferenceId}/participants/${callId}`, null, null, ApiRequester.successResponseParser),
+  removeAdHocConferenceParticipant: (conferenceId: string, participantCallId: string) => client.delete(`${baseUrl}/users/me/conferences/adhoc/${conferenceId}/participants/${participantCallId}`, null, null, ApiRequester.successResponseParser),
+  deleteAdHocConference: (conferenceId: string) => client.delete(`${baseUrl}/users/me/conferences/adhoc/${conferenceId}`, null, null, ApiRequester.successResponseParser),
+  startRecording: (callId: string) => client.put(`${baseUrl}/users/me/calls/${callId}/record/start`, null, null, ApiRequester.successResponseParser),
+  stopRecording: (callId: string) => client.put(`${baseUrl}/users/me/calls/${callId}/record/stop`, null, null, ApiRequester.successResponseParser),
+  pauseRecording: (callId: string) => client.put(`${baseUrl}/users/me/calls/${callId}/record/pause`, null, null, ApiRequester.successResponseParser),
+  resumeRecording: (callId: string) => client.put(`${baseUrl}/users/me/calls/${callId}/record/resume`, null, null, ApiRequester.successResponseParser),
+  guestGetMeetingStatus: (meetingUuid: string): Promise<MeetingStatus> => client.get(`${baseUrl}/guests/me/meetings/${meetingUuid}/status`).then(MeetingStatus.parse),
+}));