@wazo/sdk 0.38.21 → 0.39.0-beta.1

package/src/domain/Device/{DebugDevice.js → DebugDevice.ts}

@@ -1,8 +1,5 @@
-// @flow
 /* eslint-disable */
-
-import type { Device } from './Device';
-
+import type { Device } from "./Device";
 export default class DebugDevice implements Device {
   connectToCall() {
     console.info('DebugDevice - Connected to call');
@@ -43,4 +40,5 @@ export default class DebugDevice implements Device {
   putOffSpeaker() {
     console.info('DebugDevice - Put off speaker');
   }
-}
+
+}

package/src/domain/Device/{Device.js → Device.ts}

@@ -1,23 +1,12 @@
-// @flow
-
 export interface Device {
   connectToCall(): void;
-
   disconnectFromCall(): void;
-
   ringback(): void;
-
   stopRingback(): void;
-
   playRingtone(): void;
-
   stopRingtone(): void;
-
   mute(): void;
-
   unmute(): void;
-
   putOnSpeaker(): void;
-
   putOffSpeaker(): void;
 }

package/src/domain/DirectorySource.ts

@@ -0,0 +1,13 @@
+import type { UUID } from './types';
+
+export type DirectorySource = {
+  backend: string;
+  name: string;
+  tenant_uuid: UUID;
+  uuid: UUID;
+};
+export type DirectorySources = {
+  filtered: number;
+  total: number;
+  items: DirectorySource[];
+};

package/src/domain/{ExternalApp.js → ExternalApp.ts}

@@ -1,24 +1,22 @@
-// @flow
 import newFrom from '../utils/new-from';
 
 type Response = {
-  name: string,
-  configuration: Object,
+  name: string;
+  configuration: Record<string, any>;
 };
-
 type ListResponse = {
-  items: Response[],
+  items: Response[];
 };
-
 type Arguments = {
-  name: string,
-  configuration: Object,
+  name?: string;
+  configuration?: Record<string, any>;
 };
-
 export default class ExternalApp {
-  name: string;
+  name: string | undefined;
+
   type: string;
-  configuration: Object;
+
+  configuration: Record<string, any> | undefined;
 
   static parse(plain: Response): ExternalApp {
     return new ExternalApp({
@@ -35,11 +33,14 @@ export default class ExternalApp {
     return newFrom(profile, ExternalApp);
   }
 
-  constructor({ name, configuration }: Arguments = {}) {
+  constructor({
+    name,
+    configuration,
+  }: Arguments = {}) {
     this.name = name;
     this.configuration = configuration;
-
     // Useful to compare instead of instanceof with minified code
     this.type = 'ExternalApp';
   }
+
 }

package/src/domain/{Features.js → Features.ts}

@@ -1,21 +1,22 @@
-// @flow
-
 import getApiClient from '../service/getApiClient';
 
 export const FEATURES = ['chat', 'video', 'call_recording', 'fax', 'mobile_double_call', 'mobile_gsm', 'meeting'];
-
 export const getScopeName = (featureName: string) => `enterprise.app.${featureName}`;
+const scopesToCheck = FEATURES.map(getScopeName); // Handle available features on the engine.
 
-const scopesToCheck = FEATURES.map(getScopeName);
-
-// Handle available features on the engine.
 class Features {
   _hasChat: boolean;
+
   _hasVideo: boolean;
+
   _hasCallRecording: boolean;
+
   _hasFax: boolean;
+
   _hasMobileDoubleCall: boolean;
+
   _hasMobileGsm: boolean;
+
   _hasMeeting: boolean;
 
   constructor() {
@@ -30,16 +31,19 @@ class Features {
 
   async fetchAccess() {
     let response;
+
     try {
       response = await getApiClient().auth.getRestrictionPolicies(scopesToCheck);
-    } catch (_) {
-      // Noting to do because everything should be available even if the API is not available
+    } catch (_) { // Noting to do because everything should be available even if the API is not available
     }
+
     if (!response) {
       return;
     }
-    const { scopes } = response;
 
+    const {
+      scopes,
+    } = response;
     this._hasChat = this._hasFeatures(scopes, 'chat');
     this._hasVideo = this._hasFeatures(scopes, 'video');
     this._hasCallRecording = this._hasFeatures(scopes, 'call_recording');
@@ -49,20 +53,42 @@ class Features {
     this._hasMeeting = this._hasFeatures(scopes, 'meeting');
   }
 
-  hasChat() { return this._hasChat; }
-  hasVideo() { return this._hasVideo; }
-  hasCallRecording() { return this._hasCallRecording; }
-  hasFax() { return this._hasFax; }
-  hasMobileDoubleCall() { return this._hasMobileDoubleCall; }
-  hasMobileGsm() { return this._hasMobileGsm; }
-  hasMeeting() { return this._hasMeeting; }
+  hasChat() {
+    return this._hasChat;
+  }
+
+  hasVideo() {
+    return this._hasVideo;
+  }
+
+  hasCallRecording() {
+    return this._hasCallRecording;
+  }
+
+  hasFax() {
+    return this._hasFax;
+  }
+
+  hasMobileDoubleCall() {
+    return this._hasMobileDoubleCall;
+  }
 
-  _hasFeatures(scopes: Object, featureName: string) {
+  hasMobileGsm() {
+    return this._hasMobileGsm;
+  }
+
+  hasMeeting() {
+    return this._hasMeeting;
+  }
+
+  _hasFeatures(scopes: Record<string, any>, featureName: string) {
     const scopeName = getScopeName(featureName);
+
     if (!scopes || !(scopeName in scopes)) {
       // Assume that the feature is available if not present (available by default)
       return true;
     }
+
     return scopes[scopeName] === true;
   }
 

package/src/domain/{ForwardOption.js → ForwardOption.ts}

@@ -1,28 +1,25 @@
-// @flow
-
 import newFrom from '../utils/new-from';
 
 type Response = {
-  destination: string,
-  enabled: boolean,
+  destination: string;
+  enabled: boolean;
 };
-
 export const FORWARD_KEYS = {
   BUSY: 'busy',
   NO_ANSWER: 'noanswer',
   UNCONDITIONAL: 'unconditional',
 };
-
 type ForwardOptionArguments = {
-  destination: string,
-  enabled: boolean,
-  key: string,
+  destination?: string;
+  enabled?: boolean;
+  key?: string;
 };
-
 export default class ForwardOption {
-  destination: string;
-  enabled: boolean;
-  key: string;
+  destination: string | undefined;
+
+  enabled: boolean | undefined;
+
+  key: string | undefined;
 
   static parse(plain: Response, key: string): ForwardOption {
     return new ForwardOption({
@@ -36,7 +33,11 @@ export default class ForwardOption {
     return newFrom(profile, ForwardOption);
   }
 
-  constructor({ destination, enabled, key }: ForwardOptionArguments = {}) {
+  constructor({
+    destination,
+    enabled,
+    key,
+  }: ForwardOptionArguments = {}) {
     this.destination = destination;
     this.enabled = enabled;
     this.key = key;
@@ -44,17 +45,16 @@ export default class ForwardOption {
 
   setDestination(number: string): ForwardOption {
     this.destination = number;
-
     return this;
   }
 
   setEnabled(enabled: boolean): ForwardOption {
     this.enabled = enabled;
-
     return this;
   }
 
   is(other: ForwardOption) {
     return this.key === other.key;
   }
+
 }

package/src/domain/{IndirectTransfer.js → IndirectTransfer.ts}

@@ -1,36 +1,37 @@
-// @flow
-
 import CallSession from './CallSession';
 import newFrom from '../utils/new-from';
 import updateFrom from '../utils/update-from';
 
 export type IndirectTransferArguments = {
-  status?: string,
-  id?: string,
-  destinationId: string,
-  sourceId: string,
+  status?: string;
+  id?: string;
+  destinationId: string;
+  sourceId: string;
 };
-
 type Reponse = {
-  id: string,
-  initiator_uuid: string,
-  transferred_call: string,
-  initiator_call: string,
-  recipient_call: string,
-  status: string,
-  flow: string,
-}
-
+  id: string;
+  initiator_uuid: string;
+  transferred_call: string;
+  initiator_call: string;
+  recipient_call: string;
+  status: string;
+  flow: string;
+};
 export default class IndirectTransfer {
-  status: ?string;
+  status: string | null | undefined;
 
-  id: ?string;
+  id: string | null | undefined;
 
   sourceId: string;
 
   destinationId: string;
 
-  constructor({ sourceId, destinationId, status, id }: IndirectTransferArguments) {
+  constructor({
+    sourceId,
+    destinationId,
+    status,
+    id,
+  }: IndirectTransferArguments) {
     this.sourceId = sourceId;
     this.destinationId = destinationId;
     this.status = status;
@@ -68,4 +69,5 @@ export default class IndirectTransfer {
   static newFrom(indirectTransfer: IndirectTransfer) {
     return newFrom(indirectTransfer, IndirectTransfer);
   }
+
 }

package/src/domain/{Line.js → Line.ts}

@@ -1,42 +1,49 @@
-// @flow
 import newFrom from '../utils/new-from';
 
 type Extension = {
-  context: string,
-  exten: string,
-  id: number,
-  links?: Array<{ href: string, rel: string }>,
+  context: string;
+  exten: string;
+  id: number;
+  links?: Array<{
+    href: string;
+    rel: string;
+  }>;
 };
-
 export type Endpoint = {
-  id: number,
-  links: Array<{ href: string, rel: string }>,
-  username?: string,
+  id: number;
+  links: Array<{
+    href: string;
+    rel: string;
+  }>;
+  username?: string;
 };
 
-type LineResponse = {
-  endpoint_custom: ?Endpoint,
-  endpoint_sccp: ?Endpoint,
-  endpoint_sip: ?Endpoint,
-  extensions: Array<Extension>,
-  id: number,
+export type LineResponse = {
+  endpoint_custom: Endpoint | null | undefined;
+  endpoint_sccp: Endpoint | null | undefined;
+  endpoint_sip: Endpoint | null | undefined;
+  extensions: Array<Extension>;
+  id: number;
 };
 
 type LineArguments = {
-  id: number,
-  extensions: Array<Extension>,
-  endpointCustom?: Endpoint | null,
-  endpointSccp?: Endpoint | null,
-  endpointSip?: Endpoint | null,
+  id?: number;
+  extensions?: Array<Extension>;
+  endpointCustom?: Endpoint | null;
+  endpointSccp?: Endpoint | null;
+  endpointSip?: Endpoint | null;
 };
-
 export default class Line {
   type: string;
 
-  id: number;
-  extensions: Array<Extension>;
+  id: number | undefined;
+
+  extensions: Array<Extension> | undefined;
+
   endpointCustom: Endpoint | null;
+
   endpointSccp: Endpoint | null;
+
   endpointSip: Endpoint | null;
 
   static parse(plain: LineResponse): Line {
@@ -53,7 +60,7 @@ export default class Line {
     return newFrom(profile, Line);
   }
 
-  is(line: ?Line) {
+  is(line: Line | null | undefined) {
     return line ? this.id === line.id : false;
   }
 
@@ -65,14 +72,20 @@ export default class Line {
     return this.extensions.some(ext => ext.exten === extension);
   }
 
-  constructor({ id, extensions, endpointCustom, endpointSccp, endpointSip }: LineArguments = {}) {
+  constructor({
+    id,
+    extensions,
+    endpointCustom,
+    endpointSccp,
+    endpointSip,
+  }: LineArguments = {}) {
     this.id = id;
     this.extensions = extensions;
     this.endpointCustom = endpointCustom || null;
     this.endpointSccp = endpointSccp || null;
     this.endpointSip = endpointSip || null;
-
     // Useful to compare instead of instanceof with minified code
     this.type = 'Line';
   }
+
 }

package/src/domain/{Meeting.js → Meeting.ts}

@@ -1,47 +1,51 @@
-// @flow
 import moment from 'moment';
-
 import newFrom from '../utils/new-from';
-
 import MeetingAuthorization from './MeetingAuthorization';
 
 export type MeetingCreateArguments = {
-  name: string,
-  requireAuthorization: boolean,
-  persistent: boolean,
-}
-
+  name: string;
+  requireAuthorization: boolean;
+  persistent: boolean;
+};
 export type MeetingUpdateArguments = {
-  name?: string,
-  requireAuthorization?: boolean,
-}
-
+  name?: string;
+  requireAuthorization?: boolean;
+};
 export type MeetingCreationResponse = {
-  guest_sip_authorization: string,
-  ingress_http_uri: string,
-  name: string,
-  owner_uuids: Array<string>,
-  port: string,
-  uuid: string,
-  exten: string,
-  persistent: boolean,
-  creation_time: string,
-  require_authorization: boolean,
-}
-
+  guest_sip_authorization: string;
+  ingress_http_uri: string;
+  name: string;
+  owner_uuids: Array<string>;
+  port: string;
+  uuid: string;
+  exten: string;
+  persistent: boolean;
+  creation_time: string;
+  require_authorization: boolean;
+};
 export default class Meeting {
   type: string;
 
   guestSipAuthorization: string;
+
   uri: string;
+
   uuid: string;
+
   name: string;
+
   port: string;
+
   extension: string;
+
   persistent: boolean;
+
   ownerUuids: Array<string>;
+
   creationTime: Date;
-  pendingAuthorizations: Array<MeetingAuthorization>
+
+  pendingAuthorizations: Array<MeetingAuthorization>;
+
   requireAuthorization: boolean;
 
   static parse(plain: MeetingCreationResponse): Meeting {
@@ -63,6 +67,7 @@ export default class Meeting {
     if (!items) {
       return [];
     }
+
     return items.map(plain => Meeting.parse(plain));
   }
 
@@ -81,7 +86,7 @@ export default class Meeting {
     persistent,
     creationTime,
     requireAuthorization,
-  }: Object = {}) {
+  }: Record<string, any> = {}) {
     this.guestSipAuthorization = guestSipAuthorization;
     this.uri = uri;
     this.name = name;
@@ -92,15 +97,17 @@ export default class Meeting {
     this.persistent = persistent;
     this.creationTime = creationTime;
     this.requireAuthorization = requireAuthorization;
-
     // Useful to compare instead of instanceof with minified code
     this.type = 'Meeting';
   }
 
   getGuestSipCredentials() {
     // eslint-disable-next-line no-undef
-    const [username, secret] = atob(this.guestSipAuthorization).split(':');
-    return { username, secret };
+    const [username, secret] = Buffer.from(this.guestSipAuthorization, 'base64').toString('ascii').split(':');
+    return {
+      username,
+      secret,
+    };
   }
 
 }

package/src/domain/{MeetingAuthorization.js → MeetingAuthorization.ts}

@@ -1,25 +1,25 @@
-// @flow
-
 export type RawMeetingAuthorization = {
-  created_at: string,
-  meeting_uuid: string,
-  uuid: string,
-  guest_uuid: string,
-  guest_name: string,
-}
-
+  created_at: string;
+  meeting_uuid: string;
+  uuid: string;
+  guest_uuid: string;
+  guest_name: string;
+};
 export const PENDING = 'pending';
 export const ACCEPTED = 'accepted';
 export const REJECTED = 'rejected';
 export const POST_PROCESSING = 'post_processing';
 export const POST_PROCESSED_SUCCESS = 'post_processed_success';
 export const POST_PROCESSED_ERROR = 'post_processed_error';
-
 export default class MeetingAuthorization {
   meetingUuid: string;
+
   uuid: string;
+
   userUuid: string;
+
   userName: string;
+
   status: string;
 
   constructor({
@@ -27,7 +27,7 @@ export default class MeetingAuthorization {
     uuid,
     userUuid,
     userName,
-  }: Object = {}) {
+  }: Record<string, any> = {}) {
     this.meetingUuid = meetingUuid;
     this.uuid = uuid;
     this.userUuid = userUuid;
@@ -49,7 +49,6 @@ export default class MeetingAuthorization {
       guest_uuid: userUuid,
       guest_name: userName,
     } = plain;
-
     return new MeetingAuthorization({
       meetingUuid,
       uuid,
@@ -62,6 +61,8 @@ export default class MeetingAuthorization {
     if (!items) {
       return [];
     }
+
     return items.map(MeetingAuthorization.parse);
   }
+
 }

package/src/domain/{MeetingStatus.js → MeetingStatus.ts}

@@ -1,9 +1,6 @@
-// @flow
-
 export type MeetingStatusResponse = {
-  full: boolean
+  full: boolean;
 };
-
 export default class MeetingStatus {
   type: string;
 
@@ -11,9 +8,8 @@ export default class MeetingStatus {
 
   constructor({
     full,
-  }: Object = {}) {
+  }: Record<string, any> = {}) {
     this.full = full;
-
     // Useful to compare instead of instanceof with minified code
     this.type = 'MeetingStatus';
   }