@wazo/sdk 0.37.0 → 0.37.4

package/esm/domain/AdHocAPIConference.js

@@ -1,7 +1,7 @@
 import 'sip.js/lib/api/session-state';
 import moment from 'moment';
-import { jws, b64utoutf8, KEYUTIL } from 'jsrsasign';
 import { Base64 } from 'js-base64';
+import { jws, b64utoutf8, KEYUTIL } from 'jsrsasign';
 import 'events';
 import { jsonToGraphQLQuery } from 'json-to-graphql-query/lib/jsonToGraphQLQuery';
 
@@ -207,2067 +207,2073 @@ class Call {
 }
 
 //      
+/* eslint-disable no-param-reassign */
 
-const swarmPublicKey  = `-----BEGIN PUBLIC KEY-----
-MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAmkXOuNfY8u5xoTiIhkb8
-djnbIwG/Wrz3vpo8BZir8L5e1a1nSy740qBjP7ZINBQoALDhFfmdOfJnCyEGiHuz
-ZW6jbG6C3PryE3Bu6GKwqSmD6k3q4Zk27fpwYAnNl+rWhYYM563rJZBda/INyHNN
-pK7M1mixWi7gNdjjXwoEXSSBx+VpYMkY6LiAB2mvHXTY9M1qI14dvgGoQISZQoKi
-NMTRCg5UP2ic0Dd9nSz/XpcOxGfa+0fwIl1F7RC1tJXOqvkGGPTOV4LLfg/Yta3h
-nUPX9EZZDIX6vO/0IBV1LzjSl2A1bYFYAjJfowv3i1CpvONBOClHjSY5t9Y8MH6p
-BwIDAQAB
------END PUBLIC KEY-----`;
+var updateFrom = (instance     , from     ) => {
+  Object.keys(from).forEach(key => {
+    // $FlowFixMe
+    if (
+      (!instance[key] && from[key])
+      || (typeof instance[key] !== 'undefined' && typeof from[key] !== 'undefined' && instance[key] !== from[key])
+    ) {
+      // $FlowFixMe
+      instance[key] = from[key];
+    }
+  });
+};
 
-//      
+/*       */
 
-                  
-                  
-                
-             
-                                               
-  
+class BadResponse extends Error {
+  static fromResponse(error        , status        ) {
+    return new BadResponse(
+      error.message || JSON.stringify(error),
+      status,
+      error.timestamp,
+      error.error_id,
+      error.details,
+      error,
+    );
+  }
 
-                        
-             
-                                              
-                    
-  
+  static fromText(response        , status        ) {
+    return new BadResponse(response, status);
+  }
 
+                  
+                 
                      
-                             
-                           
-                          
-                               
-             
-  
+                   
+                   
+                
 
-                      
-             
-                               
-                                   
-                                 
-                                
-  
+  constructor(
+    message        ,
+    status        ,
+    timestamp          = null,
+    errorId          = null,
+    details          = null,
+    error         = null,
+  ) {
+    super(message);
 
-class Line {
-               
+    this.timestamp = timestamp;
+    this.status = status;
+    this.errorId = errorId;
+    this.details = details;
+    this.error = error;
+  }
+}
 
-             
-                               
-                                  
-                                
-                               
+/*       */
 
-  static parse(plain              )       {
-    return new Line({
-      id: plain.id,
-      extensions: plain.extensions,
-      endpointCustom: plain.endpoint_custom || null,
-      endpointSccp: plain.endpoint_sccp || null,
-      endpointSip: plain.endpoint_sip || null,
-    });
+class ServerError extends BadResponse {
+  static fromResponse(error        , status        ) {
+    return new ServerError(
+      error.message || JSON.stringify(error),
+      status,
+      error.timestamp,
+      error.error_id,
+      error.details,
+    );
   }
 
-  static newFrom(profile      ) {
-    return newFrom(profile, Line);
+  static fromText(response        , status        ) {
+    return new ServerError(response, status);
   }
+}
 
-  is(line      ) {
-    return this.id === line.id;
-  }
+/*       */
+/* global navigator */
+const isMobile = () => typeof navigator !== 'undefined' && navigator.product === 'ReactNative';
 
-  hasExtension(extension        ) {
-    if (!this.extensions) {
-      return false;
-    }
+/* global window */
 
-    return this.extensions.some(ext => ext.exten === extension);
-  }
+const TRACE = 'trace';
+const DEBUG = 'debug';
+const INFO = 'info';
+const LOG = 'log';
+const WARN = 'warn';
+const ERROR = 'error';
+const CONSOLE_METHODS = [INFO, LOG, WARN, ERROR];
+const LOG_LEVELS = [TRACE, DEBUG, INFO, LOG, WARN, ERROR];
+const CATEGORY_PREFIX = 'logger-category=';
 
-  constructor({ id, extensions, endpointCustom, endpointSccp, endpointSip }                = {}) {
-    this.id = id;
-    this.extensions = extensions;
-    this.endpointCustom = endpointCustom || null;
-    this.endpointSccp = endpointSccp || null;
-    this.endpointSip = endpointSip || null;
+const MAX_REMOTE_RETRY = 100;
 
-    // Useful to compare instead of instanceof with minified code
-    this.type = 'Line';
+const addLevelsTo = (instance        , withMethods = false) => {
+  instance.TRACE = TRACE;
+  instance.DEBUG = DEBUG;
+  instance.INFO = INFO;
+  instance.LOG = LOG;
+  instance.WARN = WARN;
+  instance.ERROR = ERROR;
+
+  if (withMethods) {
+    instance.trace = (...args) => instance.apply(null, [TRACE, ...args]);
+    instance.debug = (...args) => instance.apply(null, [DEBUG, ...args]);
+    instance.info = (...args) => instance.apply(null, [INFO, ...args]);
+    instance.log = (...args) => instance.apply(null, [LOG, ...args]);
+    instance.warn = (...args) => instance.apply(null, [WARN, ...args]);
+    instance.error = (...args) => instance.apply(null, [ERROR, ...args]);
   }
-}
 
-//      
+  return instance;
+};
 
-                 
-                      
-                   
-  
+const safeStringify = (object        ) => {
+  const result = '{"message": "Not parsable JSON"}';
+  try {
+    return JSON.stringify(object);
+  } catch (e) {
+    // Nothing to do
+  }
 
-const FORWARD_KEYS = {
-  BUSY: 'busy',
-  NO_ANSWER: 'noanswer',
-  UNCONDITIONAL: 'unconditional',
+  return result;
 };
 
-                               
-                      
-                   
+class IssueReporter {
+                
+               
               
-  
+               
+                
 
-class ForwardOption {
-                      
+                            
                    
-              
+                                     
 
-  static parse(plain          , key        )                {
-    return new ForwardOption({
-      destination: plain.destination || '',
-      enabled: plain.enabled,
-      key,
-    });
+  constructor() {
+    addLevelsTo(this);
+
+    this.oldConsoleMethods = null;
+    this.enabled = false;
+    this.remoteClientConfiguration = null;
   }
 
-  static newFrom(profile               ) {
-    return newFrom(profile, ForwardOption);
+  init() {
+    this._catchConsole();
   }
 
-  constructor({ destination, enabled, key }                         = {}) {
-    this.destination = destination;
-    this.enabled = enabled;
-    this.key = key;
+  configureRemoteClient(configuration         = { tag: 'wazo-sdk', host: null, port: null, level: null, extra: {} }) {
+    this.remoteClientConfiguration = configuration;
   }
 
-  setDestination(number        )                {
-    this.destination = number;
+  enable() {
+    if (!this.oldConsoleMethods) {
+      this.init();
+    }
 
-    return this;
+    this.enabled = true;
   }
 
-  setEnabled(enabled         )                {
-    this.enabled = enabled;
-
-    return this;
+  disable() {
+    this.enabled = false;
   }
 
-  is(other               ) {
-    return this.key === other.key;
+  loggerFor(category        )      {
+    const logger = (level        , ...args     ) => {
+      this.log.apply(this, [level, this._makeCategory(category), ...args]);
+    };
+
+    return addLevelsTo(logger, true);
   }
-}
 
-//      
-                                       
+  removeSlashes(str        ) {
+    return str.replace(/"/g, "'").replace(/\\/g, '');
+  }
 
-const availableCodecs = ['vp8', 'vp9', 'h264'];
+  log(level        , ...args     ) {
+    if (!this.enabled) {
+      return;
+    }
 
-                        
-             
-               
-                      
-                   
-                 
-               
-               
-                       
-                                    
-                                        
-                       
-                 
-                 
-  
+    // Handle category label
+    let category = null;
+    let extra = {};
+    if (args[0].indexOf(CATEGORY_PREFIX) === 0) {
+      category = args[0].split('=')[1];
+      // eslint-disable-next-line no-param-reassign
+      args.splice(0, 1);
+    }
 
-                         
-             
-               
-                     
-                   
-                 
-               
-               
-                       
-                                      
-                       
-                 
-                 
-  
+    // Handle extra data as object for the last argument
+    const lastArg = args[args.length - 1];
+    if (lastArg && ((typeof lastArg === 'object' && Object.keys(lastArg).length) || lastArg instanceof Error)) {
+      if (lastArg instanceof Error) {
+        extra = {
+          errorMessage: lastArg.message,
+          errorStack: lastArg.stack,
+          errorType: lastArg.constructor.name,
+        };
+      } else {
+        extra = lastArg;
+      }
+      // eslint-disable-next-line no-param-reassign
+      args.splice(1, 1);
+    }
 
-class SipLine {
-          
-               
-                     
-                   
-                 
-               
-               
-                       
-                                      
-                       
-                 
-                 
+    const date = moment().format('YYYY-MM-DD HH:mm:ss.SSS');
+    const message = args.join(', ');
+    let consoleMessage = message;
 
-  static parse(plain                 )          {
-    let { username, secret, host } = plain;
+    if (Object.keys(extra).length) {
+      const parsedExtra = safeStringify(extra);
+      consoleMessage = `${consoleMessage} (${parsedExtra})`;
+    }
 
-    // Since 20.13 engine so options are now in section
-    if (plain.auth_section_options) {
-      // $FlowFixMe
-      const findOption = (options            , name        ) => options.find(option => option[0] === name);
+    if (category) {
+      consoleMessage = `[${category}] ${consoleMessage}`;
+    }
 
-      const usernameOption = findOption(plain.auth_section_options, 'username');
-      const secretOption = findOption(plain.auth_section_options, 'password');
-      const hostOption = findOption(plain.endpoint_section_options, 'media_address');
+    // Log the message in the console anyway (but don't console.error on mobile)
+    const consoleLevel = isMobile() && level === 'error' ? WARN : level;
 
-      username = usernameOption ? usernameOption[1] : '';
-      secret = secretOption ? secretOption[1] : '';
-      host = hostOption ? hostOption[1] : '';
+    // eslint-disable-next-line
+    const oldMethod = this.oldConsoleMethods[consoleLevel] || this.oldConsoleMethods.log;
+    oldMethod.apply(oldMethod, [date, consoleMessage]);
+
+    this._sendToRemoteLogger(level, { date, message, category, ...extra });
+  }
+
+  logRequest(url        , options        , response        , start      ) {
+    if (!this.enabled) {
+      return;
     }
+    const { status } = response;
+    const duration = new Date() - start;
 
-    return new SipLine({
-      id: plain.id,
-      uuid: plain.uuid,
-      tenantUuid: plain.tenant_uuid,
-      username,
-      secret,
-      type: plain.type,
-      host,
-      options: plain.options,
-      endpointSectionOptions: plain.endpoint_section_options,
-      links: plain.links,
-      trunk: plain.trunk,
-      line: plain.line,
+    let level = TRACE;
+    if (status >= 400 && status < 500) {
+      level = WARN;
+    } else if (status >= 500) {
+      level = ERROR;
+    }
+
+    this.log(level, this._makeCategory('http'), url, {
+      status,
+      body: this.removeSlashes(JSON.stringify(options.body)),
+      method: options.method,
+      headers: options.headers,
+      duration,
     });
   }
 
-  static newFrom(sipLine         ) {
-    return newFrom(sipLine, SipLine);
+  // Logs aren't stored anymore
+  getLogs() {
+    console.warn('IssueReporter\'s logs aren\'t stored anymore. Please use fluentd to store them');
+    return [];
   }
 
-  is(line         ) {
-    if (line.uuid) {
-      return this.uuid === line.uuid;
-    }
-    return this.id === line.id;
+  getParsedLogs() {
+    console.warn('IssueReporter\'s logs aren\'t stored anymore. Please use fluentd to store them');
+    return [];
   }
 
-  getOptions()                {
-    // `options` params have beend remove since 20.13... we should now use endpointSectionOptions
-    return this.endpointSectionOptions || this.options || [];
+  getReport() {
+    return this.getParsedLogs().join('\r\n');
   }
 
-  isWebRtc() {
-    return this.getOptions().some(option => option[0] === 'webrtc' && option[1] === 'yes');
+  _catchConsole() {
+    this.oldConsoleMethods = {};
+    CONSOLE_METHODS.forEach((methodName        ) => {
+      // eslint-disable-next-line
+      this.oldConsoleMethods[methodName] = console[methodName];
+      window.console[methodName] = (...args) => {
+        // Store message
+        try {
+          this.log(methodName, args.join(' '));
+          // Use old console method to log it normally
+          this.oldConsoleMethods[methodName].apply(null, args);
+        } catch (e) {
+          // Avoid circular structure issues
+        }
+      };
+    });
   }
 
-  hasVideo() {
-    const allow = this.getOptions().find(option => option[0] === 'allow');
-    return Array.isArray(allow) && allow[1].split(',').some(codec => availableCodecs.some(c => c === codec));
-  }
+  _sendToRemoteLogger(level        , payload        , retry         = 0) {
+    if (!this.remoteClientConfiguration || retry >= MAX_REMOTE_RETRY) {
+      return;
+    }
 
-  hasVideoConference() {
-    return (
-      this.getOptions().some(option => option[0] === 'max_audio_streams' && parseInt(option[1], 10) > 0)
-      && this.getOptions().some(option => option[0] === 'max_video_streams' && parseInt(option[1], 10) > 1)
-    );
+    const { tag, host, port, extra, level: minLevel } = this.remoteClientConfiguration;
+    if (!minLevel || this._isLevelAbove(minLevel, level)) {
+      return;
+    }
+
+    const isSecure = +port === 443;
+    const url = `http${isSecure ? 's' : ''}://${host}${isSecure ? '' : `:${port}`}/${tag}`;
+
+    realFetch()(url, {
+      method: 'POST',
+      headers: {
+        Accept: 'application/json',
+        'Content-Type': 'application/json',
+      },
+      body: safeStringify({
+        level,
+        ...payload,
+        ...extra,
+      }),
+    }).catch(() => {
+      setTimeout(() => {
+        // eslint-disable-next-line no-underscore-dangle
+        payload._retry = retry + 1;
+        this._sendToRemoteLogger(level, payload, retry + 1);
+      }, 5000 + retry * 1000);
+    });
   }
 
-  constructor({
-    id,
-    uuid,
-    tenantUuid,
-    username,
-    secret,
-    type,
-    host,
-    options,
-    endpointSectionOptions,
-    links,
-    trunk,
-    line,
-  }                   = {}) {
-    this.id = id;
-    this.uuid = uuid;
-    this.tenantUuid = tenantUuid;
-    this.username = username;
-    this.secret = secret;
-    this.type = type;
-    this.host = host;
-    this.options = options;
-    this.endpointSectionOptions = endpointSectionOptions;
-    this.links = links;
-    this.trunk = trunk;
-    this.line = line;
+  _isLevelAbove(level1        , level2        ) {
+    const index1 = LOG_LEVELS.indexOf(level1);
+    const index2 = LOG_LEVELS.indexOf(level2);
+    if (index1 === -1 || index2 === -1) {
+      return false;
+    }
 
-    // Useful to compare instead of instanceof with minified code
-    this.type = 'SipLine';
+    return index1 > index2;
   }
-}
 
-//      
+  _makeCategory(category        ) {
+    return `${CATEGORY_PREFIX}${category}`;
+  }
+}
 
-const STATE = {
-  AVAILABLE: 'available',
-  UNAVAILABLE: 'unavailable',
-  INVISIBLE: 'invisible',
-  DISCONNECTED: 'disconnected',
-  AWAY: 'away',
-};
+var IssueReporter$1 = new IssueReporter();
 
-const LINE_STATE = {
-  AVAILABLE: 'available',
-  HOLDING: 'holding',
-  RINGING: 'ringing',
-  TALKING: 'talking',
-  UNAVAILABLE: 'unavailable',
-  PROGRESSING: 'progressing',
-};
+/*       */
 
-                        
-                                              
+                          
+                 
+                 
                     
-                     
-                   
-                    
-               
-                
-               
-                                                                                                                    
-                                      
-                                    
-                                   
-     
-             
-                   
-                    
-                   
-                
-             
-           
-                          
-                       
-      
-               
-                          
-                       
-      
-                    
-                          
-                       
-      
-    
-                               
-                             
-             
-          
-                       
-      
-    
-                           
-           
-                      
-               
-                     
-                   
-    
-               
-               
-                 
-    
-                                    
-                      
-                     
+                                 
                  
-     
-                                       
+                        
   
 
-                         
-             
-                    
-                   
-                
-                     
-                            
-                   
-                       
-                                 
-                         
-                 
+const methods = ['head', 'get', 'post', 'put', 'delete'];
+
+const logger$1 = IssueReporter$1 ? IssueReporter$1.loggerFor('api') : console;
+
+// Use a function here to be able to mock it in tests
+const realFetch = () => {
+  if (typeof document !== 'undefined') {
+    // Browser
+    return window.fetch;
+  }
+
+  if (isMobile()) {
+    // React native
+    return fetch;
+  }
+
+  // nodejs
+  // this package is disable for react-native in package.json because it requires nodejs modules
+  // Used to trick the optimizer to avoid requiring `node-fetch/lib/index` directly
+  // It causes to require it on browsers when delivered by a nodejs engine (cf: vitejs).
+  try {
+    // $FlowFixMe
+    return require(Math.random() >= 0 ? 'node-fetch/lib/index' : '');
+  } catch (e) {
+    return fetch;
+  }
+};
+
+class ApiRequester {
                  
-                            
-               
-               
                  
-    
-           
-                      
-               
-                     
-                   
-    
-                           
-                                                                                       
-                                     
-  
-
-class Profile {
-             
                     
-                   
                 
-                     
-                           
-                   
+                  
                        
                                  
-                         
-                                    
+                                     
+                           
+
                  
-                                           
+                
                  
-                            
-                                                                              
-                           
-                                                                                      
+                
+                   
 
-  static parse(plain                 )          {
-    return new Profile({
-      id: plain.uuid,
-      firstName: plain.firstName || plain.firstname || '',
-      lastName: plain.lastName || plain.lastname || '',
-      email: plain.email,
-      lines: plain.lines.map(line => Line.parse(line)),
-      username: plain.username,
-      mobileNumber: plain.mobile_phone_number || '',
-      forwards: [
-        ForwardOption.parse(plain.forwards.unconditional, FORWARD_KEYS.UNCONDITIONAL),
-        ForwardOption.parse(plain.forwards.noanswer, FORWARD_KEYS.NO_ANSWER),
-        ForwardOption.parse(plain.forwards.busy, FORWARD_KEYS.BUSY),
-      ],
-      doNotDisturb: plain.services.dnd.enabled,
-      subscriptionType: plain.subscription_type,
-      voicemail: plain.voicemail,
-      switchboards: plain.switchboards || [],
-      agent: plain.agent,
-      status: '',
-      callPickupTargetUsers: plain.call_pickup_target_users || [],
-      onlineCallRecordEnabled: plain.online_call_record_enabled,
-    });
+  // eslint-disable-next-line
+  static successResponseParser(response        , isJson         ) {
+    return response.status === 204 || response.status === 201 || response.status === 200;
   }
 
-  static newFrom(profile         ) {
-    return newFrom(profile, Profile);
+  static defaultParser(response        ) {
+    return response.json().then((data        ) => data);
   }
 
-  constructor({
-    id,
-    firstName,
-    lastName,
-    email,
-    lines,
-    username,
-    mobileNumber,
-    forwards,
-    doNotDisturb,
-    state,
-    subscriptionType,
-    voicemail,
-    switchboards,
-    agent,
-    status,
-    sipLines,
-    callPickupTargetUsers,
-    onlineCallRecordEnabled,
-  }                           = {}) {
-    this.id = id;
-    this.firstName = firstName;
-    this.lastName = lastName;
-    this.email = email;
-    this.lines = lines;
-    this.username = username;
-    this.mobileNumber = mobileNumber;
-    this.forwards = forwards;
-    this.doNotDisturb = doNotDisturb;
-    this.state = state;
-    this.voicemail = voicemail;
-    this.subscriptionType = subscriptionType;
-    this.switchboards = switchboards;
-    this.agent = agent;
-    this.status = status;
-    this.callPickupTargetUsers = callPickupTargetUsers;
-    this.onlineCallRecordEnabled = onlineCallRecordEnabled;
-
-    this.sipLines = sipLines || [];
+  static getQueryString(obj        )         {
+    return Object.keys(obj)
+      .filter(key => obj[key])
+      .map(key => `${key}=${encodeURIComponent(obj[key])}`)
+      .join('&');
   }
 
-  static getLinesState(lines               ) {
-    let result = LINE_STATE.UNAVAILABLE;
+  static base64Encode(str        )         {
+    return typeof btoa !== 'undefined' ? btoa(str) : Base64.encode(str);
+  }
 
-    // eslint-disable-next-line
-    for (const line of lines) {
-      if (line.state === LINE_STATE.RINGING) {
-        result = LINE_STATE.RINGING;
-        break;
-      }
+  // @see https://github.com/facebook/flow/issues/183#issuecomment-358607052
+  constructor({ server, refreshTokenCallback, clientId, agent = null, token = null, fetchOptions }                   ) {
+    this.server = server;
+    this.agent = agent;
+    this.clientId = clientId;
+    this.refreshTokenCallback = refreshTokenCallback;
+    this.refreshTokenPromise = null;
+    this.fetchOptions = fetchOptions || {};
+    if (token) {
+      this.token = token;
+    }
 
-      if (line.state === LINE_STATE.TALKING) {
-        result = LINE_STATE.TALKING;
-        break;
-      }
+    this.shouldLogErrors = true;
 
-      if (line.state === LINE_STATE.AVAILABLE) {
-        result = LINE_STATE.AVAILABLE;
-      }
-    }
+    methods.forEach(method => {
+      // $FlowFixMe
+      ApiRequester.prototype[method] = function sugar(...args) {
+        // Add method in arguments passed to `call`
+        args.splice(1, 0, method);
 
-    return result;
+        return this.call.call(this, ...args);
+      };
+    });
   }
 
-  hasId(id        ) {
-    return id === this.id;
+  setTenant(tenant         ) {
+    this.tenant = tenant;
   }
 
-  setMobileNumber(number        ) {
-    this.mobileNumber = number;
-
-    return this;
+  setToken(token        ) {
+    this.token = token;
   }
 
-  setForwardOption(forwardOption               ) {
-    const updatedForwardOptions = this.forwards.slice();
-    const index = updatedForwardOptions.findIndex(forward => forward.is(forwardOption));
-    updatedForwardOptions.splice(index, 1, forwardOption);
+  setFetchOptions(options        ) {
+    this.fetchOptions = options;
+  }
 
-    this.forwards = updatedForwardOptions;
+  disableErrorLogging() {
+    this.shouldLogErrors = false;
+  }
 
-    return this;
+  enableErrorLogging() {
+    this.shouldLogErrors = true;
   }
 
-  setDoNotDisturb(enabled         ) {
-    this.doNotDisturb = enabled;
+  async call(
+    path        ,
+    method         = 'get',
+    body          = null,
+    headers                    = null,
+    parse           = ApiRequester.defaultParser,
+    firstCall          = true,
+  )               {
+    const url = this.computeUrl(method, path, body);
+    const newHeaders = this.getHeaders(headers);
+    let newBody = method === 'get' ? null : body;
+    if (newBody && newHeaders['Content-Type'] === 'application/json') {
+      newBody = JSON.stringify(newBody);
+    }
+    const isHead = method === 'head';
+    const hasEmptyResponse = method === 'delete' || isHead;
+    const newParse = hasEmptyResponse ? ApiRequester.successResponseParser : parse;
 
-    return this;
+    const fetchOptions = { ...this.fetchOptions || {} };
+    const extraHeaders = fetchOptions.headers || {};
+    delete fetchOptions.headers;
+
+    const options = {
+      method,
+      body: newBody,
+      headers: { ...this.getHeaders(headers), ...extraHeaders },
+      agent: this.agent,
+      ...fetchOptions,
+    };
+
+    if (this.refreshTokenPromise) {
+      logger$1.info('A token is already refreshing, waiting ...', { url });
+      await this.refreshTokenPromise;
+    }
+
+    const start = new Date();
+
+    return realFetch()(url, options).then(response => {
+      const contentType = response.headers.get('content-type') || '';
+      const isJson = contentType.indexOf('application/json') !== -1;
+
+      IssueReporter$1.logRequest(url, options, response, start);
+
+      // Throw an error only if status >= 400
+      if ((isHead && response.status >= 500) || (!isHead && response.status >= 400)) {
+        const promise = isJson ? response.json() : response.text();
+        const exceptionClass = response.status >= 500 ? ServerError : BadResponse;
+
+        return promise.then(async (err        ) => {
+          // Check if the token is still valid
+          if (firstCall && this._checkTokenExpired(response, err)) {
+            logger$1.warn('token expired', { error: err.reason });
+            // Replay the call after refreshing the token
+            return this._replayWithNewToken(err, path, method, body, headers, parse);
+          }
+
+          const error = typeof err === 'string'
+            ? exceptionClass.fromText(err, response.status)
+            : exceptionClass.fromResponse(err, response.status);
+
+          if (this.shouldLogErrors) {
+            logger$1.error('API error', error);
+          }
+
+          throw error;
+        });
+      }
+
+      return newParse(response, isJson);
+    }).catch(error => {
+      if (this.shouldLogErrors) {
+        logger$1.error('Fetch failed', { url, options, message: error.message, stack: error.stack });
+      }
+
+      throw error;
+    });
   }
 
-  setState(state        ) {
-    this.state = state;
+  _checkTokenExpired(response        , err        ) {
+    // Special case when authenticating form a token: we got a 404
+    const isTokenNotFound = response.status === 404 && this._isTokenNotFound(err);
 
-    return this;
+    return response.status === 401 || isTokenNotFound;
+  }
+
+  _isTokenNotFound(err        ) {
+    return err && err.reason && err.reason[0] === 'No such token';
+  }
+
+  _replayWithNewToken(
+    err        ,
+    path        ,
+    method        ,
+    body          = null,
+    headers                    = null,
+    parse          ,
+  ) {
+    const isTokenNotFound = this._isTokenNotFound(err);
+    let newPath = path;
+    logger$1.info('refreshing token', { inProgress: !!this.refreshTokenPromise });
+
+    this.refreshTokenPromise = this.refreshTokenPromise || this.refreshTokenCallback();
+
+    return this.refreshTokenPromise.then(() => {
+      this.refreshTokenPromise = null;
+      logger$1.info('token refreshed', { isTokenNotFound });
+      if (isTokenNotFound) {
+        const pathParts = path.split('/');
+        pathParts.pop();
+        pathParts.push(this.token);
+        newPath = pathParts.join('/');
+      }
+
+      return this.call(newPath, method, body, headers, parse, false);
+    }).catch((e) => {
+      this.refreshTokenPromise = null;
+      throw e;
+    });
+  }
+
+  getHeaders(header                  )         {
+    if (header instanceof Object) {
+      return header;
+    }
+
+    return {
+      'X-Auth-Token': this.token,
+      ...(this.tenant ? { 'Wazo-Tenant': this.tenant } : null),
+      Accept: 'application/json',
+      'Content-Type': 'application/json',
+    };
+  }
+
+  computeUrl(method        , path        , body         )         {
+    const url = `${this.baseUrl}/${path}`;
+
+    return method === 'get' && body && Object.keys(body).length ? `${url}?${ApiRequester.getQueryString(body)}` : url;
+  }
+
+  get baseUrl()         {
+    return `https://${this.server}/api`;
   }
 }
 
 //      
-                                                         
 
-const BACKEND = {
-  OFFICE365: 'office365',
-  PERSONAL: 'personal',
-  GOOGLE: 'google',
-  WAZO: 'wazo',
-};
+const swarmPublicKey  = `-----BEGIN PUBLIC KEY-----
+MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAmkXOuNfY8u5xoTiIhkb8
+djnbIwG/Wrz3vpo8BZir8L5e1a1nSy740qBjP7ZINBQoALDhFfmdOfJnCyEGiHuz
+ZW6jbG6C3PryE3Bu6GKwqSmD6k3q4Zk27fpwYAnNl+rWhYYM563rJZBda/INyHNN
+pK7M1mixWi7gNdjjXwoEXSSBx+VpYMkY6LiAB2mvHXTY9M1qI14dvgGoQISZQoKi
+NMTRCg5UP2ic0Dd9nSz/XpcOxGfa+0fwIl1F7RC1tJXOqvkGGPTOV4LLfg/Yta3h
+nUPX9EZZDIX6vO/0IBV1LzjSl2A1bYFYAjJfowv3i1CpvONBOClHjSY5t9Y8MH6p
+BwIDAQAB
+-----END PUBLIC KEY-----`;
 
-                          
-                    
-                   
-                      
-                 
-                   
-                      
-                    
+//      
+
+                  
+                  
                 
-                                                     
-                      
+             
+                                               
   
 
-                               
-                 
-                  
-                            
-              
-                    
-                    
-                      
                         
-                      
-                            
-    
+             
+                                              
+                    
   
 
-                                
+                     
+                             
+                           
+                          
                                
-               
-                                
-                                  
-  
-
-                                       
              
-                     
-                    
-                  
-                                                      
-                 
-                      
-                    
-                   
-                
-                    
-                     
-                    
-                   
-                     
   
 
-                                       
-         
-         
-                 
                       
-                 
+             
                                
-                              
-                                 
-                                    
+                                   
                                  
-                           
-                                       
-                              
-            
-           
-        
-      
-    
+                                
   
 
-// @see: https://github.com/rt2zz/react-native-contacts#example-contact-record
-                                     
-                   
-                  
-                         
-                  
-                  
-     
-                    
-                     
-                     
-                   
+class Line {
                
-                       
-                  
-                
-     
-                       
-                  
-                   
-     
-                        
-                        
-                          
-                   
-                 
-                  
-                   
-                     
-                    
-                  
-     
+
              
-                 
-                  
-                
-    
-  
+                               
+                                  
+                                
+                               
+
+  static parse(plain              )       {
+    return new Line({
+      id: plain.id,
+      extensions: plain.extensions,
+      endpointCustom: plain.endpoint_custom || null,
+      endpointSccp: plain.endpoint_sccp || null,
+      endpointSip: plain.endpoint_sip || null,
+    });
+  }
+
+  static newFrom(profile      ) {
+    return newFrom(profile, Line);
+  }
+
+  is(line      ) {
+    return this.id === line.id;
+  }
+
+  hasExtension(extension        ) {
+    if (!this.extensions) {
+      return false;
+    }
+
+    return this.extensions.some(ext => ext.exten === extension);
+  }
+
+  constructor({ id, extensions, endpointCustom, endpointSccp, endpointSip }                = {}) {
+    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';
+  }
+}
+
+//      
 
-                         
-              
-                
-                
-                  
-                                                      
-                      
                  
-                                                    
                       
-                    
-                   
-                
-                      
-                     
-                 
-                  
-                     
-                     
-                              
-                        
-                   
-                  
                    
-                          
-                                                     
+  
+
+const FORWARD_KEYS = {
+  BUSY: 'busy',
+  NO_ANSWER: 'noanswer',
+  UNCONDITIONAL: 'unconditional',
+};
+
+                               
                       
-                         
-                    
                    
+              
   
 
-                          
-                     
-                
-                       
-                        
-                             
-                         
-                    
-                       
-                   
-                          
-                  
+class ForwardOption {
                       
-                                                           
-                 
-                  
-                 
                    
-                       
+              
+
+  static parse(plain          , key        )                {
+    return new ForwardOption({
+      destination: plain.destination || '',
+      enabled: plain.enabled,
+      key,
+    });
+  }
+
+  static newFrom(profile               ) {
+    return newFrom(profile, ForwardOption);
+  }
+
+  constructor({ destination, enabled, key }                         = {}) {
+    this.destination = destination;
+    this.enabled = enabled;
+    this.key = key;
+  }
+
+  setDestination(number        )                {
+    this.destination = number;
+
+    return this;
+  }
+
+  setEnabled(enabled         )                {
+    this.enabled = enabled;
+
+    return this;
+  }
+
+  is(other               ) {
+    return this.key === other.key;
+  }
+}
+
+//      
+                                       
+
+const availableCodecs = ['vp8', 'vp9', 'h264'];
+
+                        
              
-                   
-                
-                
-                               
                
-                  
-                      
-                
                       
-                    
-                         
-                        
-                  
-                  
-                  
-             
-                       
-                     
                    
+                 
+               
+               
+                       
+                                    
+                                        
+                       
+                 
+                 
   
 
+                         
+             
+               
                      
-                
-                
-                    
                    
-                           
+                 
                
-             
-                        
-  
-                           
-                  
                
-             
-                                                        
-                                                     
+                       
+                                      
+                       
+                 
+                 
   
 
-                       
+class SipLine {
+          
+               
+                     
                    
-             
+                 
                
-                    
-                        
-  
-
-const SOURCE_MOBILE = 'mobile';
-
-class Contact {
                
-
-              
-                
-                
-                  
-                                                      
-                      
+                       
+                                      
+                       
                  
-                                                    
-                      
-                    
-                   
-                
-                      
-                     
                  
-                     
-                              
-                        
-                   
-                  
-                    
-                  
-                   
-                         
-                                                     
-                      
-                         
-                    
-                  
-
-  static merge(oldContacts                , newContacts                )                 {
-    return newContacts.map(current => {
-      const old = oldContacts.find(contact => contact && contact.is(current));
-
-      return old ? current.merge(old) : current;
-    });
-  }
-
-  static sortContacts(a         , b         ) {
-    const aNames = a.separateName();
-    const bNames = b.separateName();
-    const aLastName = aNames.lastName;
-    const bLastName = bNames.lastName;
-
-    // last Name can be empty
-    if (aLastName === bLastName) {
-      return aNames.firstName.localeCompare(bNames.firstName);
-    }
-
-    return aLastName.localeCompare(bLastName);
-  }
-
-  static parseMany(response                  )                 {
-    return response.results.map(r => Contact.parse(r, response.column_types));
-  }
-
-  static manyGraphQlWithNumbersParser(numbers          )           {
-    return (response                         ) => {
-      if (!response.data || !response.data.me || !response.data.me.contacts) {
-        return [];
-      }
-
-      return response.data.me.contacts.edges.map((edge, i) => {
-        if (!edge.node) {
-          return null;
-        }
-
-        const { email } = edge.node;
-        const name = edge.node.firstname && edge.node.lastname
-          ? `${edge.node.firstname || ''} ${edge.node.lastname || ''}` : edge.node.wazoReverse;
-
-        return new Contact({
-          name,
-          number: numbers[i],
-          numbers: [{ label: 'primary', number: numbers[i] }],
-          backend: edge.node.wazoBackend,
-          source: edge.node.wazoSourceName,
-          sourceId: edge.node.wazoSourceEntryId || '',
-          email: email || '',
-          emails: email ? [{ label: 'primary', email }] : [],
-          uuid: edge.node.userUuid,
-        });
-      }).filter(contact => !!contact);
-    };
-  }
-
-  static fetchNumbers(plain                 , columns                )                {
-    const numberColumns = columns
-      .map((e, index) => ({ index, columnName: e }))
-      .filter(e => e.columnName === 'number' || e.columnName === 'callable')
-      .map(e => e.index);
-
-    return plain.column_values.filter((e, index) => numberColumns.some(i => i === index) && e !== null);
-  }
-
-  static parse(plain                 , columns                )          {
-    const numbers = Contact.fetchNumbers(plain, columns);
-    const email = plain.column_values[columns.indexOf('email')];
-
-    return new Contact({
-      name: plain.column_values[columns.indexOf('name')],
-      number: numbers.length ? numbers[0] : '',
-      numbers: numbers.map((number, i) => ({ label: i === 0 ? 'primary' : 'secondary', number })),
-      favorited: plain.column_values[columns.indexOf('favorite')],
-      email: email || '',
-      emails: email ? [{ label: 'primary', email }] : [],
-      entreprise: plain.column_values[columns.indexOf('entreprise')] || '',
-      birthday: plain.column_values[columns.indexOf('birthday')] || '',
-      address: plain.column_values[columns.indexOf('address')] || '',
-      note: plain.column_values[columns.indexOf('note')] || '',
-      endpointId: plain.relations.endpoint_id,
-      personal: plain.column_values[columns.indexOf('personal')],
-      source: plain.source,
-      sourceId: plain.relations.source_entry_id || '',
-      uuid: plain.relations.user_uuid,
-      backend: plain.backend || '',
-    });
-  }
-
-  static parseManyPersonal(results                                )                  {
-    return results.map(r => Contact.parsePersonal(r));
-  }
-
-  static parsePersonal(plain                         )          {
-    return new Contact({
-      name: `${plain.firstName || plain.firstname || ''} ${plain.lastName || plain.lastname || ''}`,
-      number: plain.number || '',
-      numbers: plain.number ? [{ label: 'primary', number: plain.number }] : [],
-      email: plain.email || '',
-      emails: plain.email ? [{ label: 'primary', email: plain.email }] : [],
-      source: 'personal',
-      sourceId: plain.id || '',
-      entreprise: plain.entreprise || '',
-      birthday: plain.birthday || '',
-      address: plain.address || '',
-      note: plain.note || '',
-      favorited: plain.favorited,
-      personal: true,
-      backend: plain.backend || BACKEND.PERSONAL,
-    });
-  }
-
-  static parseMobile(plain                       )          {
-    let address = '';
-    if (plain.postalAddresses.length) {
-      const postalAddress = plain.postalAddresses[0];
-
-      address = `${postalAddress.street} ${postalAddress.city} ${postalAddress.postCode} ${postalAddress.country}`;
-    }
-
-    return new Contact({
-      name: `${plain.givenName || ''} ${plain.familyName || ''}`,
-      number: plain.phoneNumbers.length ? plain.phoneNumbers[0].number : '',
-      numbers: plain.phoneNumbers.length ? [{ label: 'primary', number: plain.phoneNumbers[0].number }] : [],
-      email: plain.emailAddresses.length ? plain.emailAddresses[0].email : '',
-      emails: plain.emailAddresses.length ? [{ label: 'primary', email: plain.emailAddresses[0].email }] : [],
-      source: SOURCE_MOBILE,
-      sourceId: plain.recordID || '',
-      birthday: plain.birthday ? `${plain.birthday.year}-${plain.birthday.month}-${plain.birthday.day}` : '',
-      address,
-      note: plain.note || '',
-      favorited: false,
-      personal: true,
-    });
-  }
-
-  static parseManyOffice365(response                     , source                 )                 {
-    return response.map(r => Contact.parseOffice365(r, source));
-  }
-
-  static parseOffice365(single                   , source                 )          {
-    const emails                                           = [];
-    const numbers                                            = [];
 
-    if (single.emailAddresses) {
-      single.emailAddresses.map(email => emails.push({ email: email.address }));
-    }
+  static parse(plain                 )          {
+    let { username, secret, host } = plain;
 
-    if (single.businessPhones) {
-      single.businessPhones.map(phone => numbers.push({ label: 'business', number: phone }));
-    }
+    // Since 20.13 engine so options are now in section
+    if (plain.auth_section_options) {
+      // $FlowFixMe
+      const findOption = (options            , name        ) => options.find(option => option[0] === name);
 
-    if (single.mobilePhone) {
-      numbers.push({ label: 'mobile', number: single.mobilePhone });
-    }
+      const usernameOption = findOption(plain.auth_section_options, 'username');
+      const secretOption = findOption(plain.auth_section_options, 'password');
+      const hostOption = findOption(plain.endpoint_section_options, 'media_address');
 
-    if (single.homePhones) {
-      single.homePhones.map(phone => numbers.push({ label: 'home', number: phone }));
+      username = usernameOption ? usernameOption[1] : '';
+      secret = secretOption ? secretOption[1] : '';
+      host = hostOption ? hostOption[1] : '';
     }
 
-    return new Contact({
-      sourceId: single.id || '',
-      name: single.displayName || '',
-      number: numbers.length ? numbers[0].number : '',
-      numbers,
-      emails,
-      source: source.name,
-      backend: BACKEND.OFFICE365,
+    return new SipLine({
+      id: plain.id,
+      uuid: plain.uuid,
+      tenantUuid: plain.tenant_uuid,
+      username,
+      secret,
+      type: plain.type,
+      host,
+      options: plain.options,
+      endpointSectionOptions: plain.endpoint_section_options,
+      links: plain.links,
+      trunk: plain.trunk,
+      line: plain.line,
     });
   }
 
-  static parseManyGoogle(response                  , source                 )                 {
-    return response.map(r => Contact.parseGoogle(r, source));
+  static newFrom(sipLine         ) {
+    return newFrom(sipLine, SipLine);
   }
 
-  static parseGoogle(single                , source                 )          {
-    const emails                                           = [];
-    const numbers                                            = [];
-
-    if (single.emails) {
-      single.emails.forEach(email =>
-        (typeof email === 'object' ? { email: email.address, label: email.label } : { email }));
-    }
-
-    if (single.numbers_by_label) {
-      Object.keys(single.numbers_by_label).forEach(label =>
-        numbers.push({ label, number: single.numbers_by_label[label] }));
-    } else if (single.numbers) {
-      single.numbers.forEach(phone => numbers.push({ number: phone }));
+  is(line         ) {
+    if (line.uuid) {
+      return this.uuid === line.uuid;
     }
-
-    return new Contact({
-      sourceId: single.id || '',
-      name: single.name || '',
-      number: numbers.length ? numbers[0].number : '',
-      numbers,
-      emails,
-      source: source.name,
-      backend: BACKEND.GOOGLE,
-    });
-  }
-
-  static parseManyWazo(response                , source                 )                 {
-    return response.map(r => Contact.parseWazo(r, source));
+    return this.id === line.id;
   }
 
-  static parseWazo(single              , source                 )          {
-    const emails = [];
-    const numbers = [];
-
-    if (single.email) {
-      emails.push({ label: 'email', email: single.email });
-    }
-
-    if (single.exten) {
-      numbers.push({ label: 'exten', number: single.exten });
-    }
-
-    if (single.mobile_phone_number) {
-      numbers.push({ label: 'mobile', number: single.mobile_phone_number });
-    }
-
-    return new Contact({
-      uuid: single.uuid,
-      sourceId: String(single.id) || '',
-      name: `${single.firstname}${single.lastname ? ` ${single.lastname}` : ''}`,
-      number: numbers.length ? numbers[0].number : '',
-      numbers,
-      emails,
-      source: source.name,
-      backend: BACKEND.WAZO,
-    });
+  getOptions()                {
+    // `options` params have beend remove since 20.13... we should now use endpointSectionOptions
+    return this.endpointSectionOptions || this.options || [];
   }
 
-  static parseManyConference(response                      , source                 )                 {
-    return response.map(r => Contact.parseConference(r, source));
+  isWebRtc() {
+    return this.getOptions().some(option => option[0] === 'webrtc' && option[1] === 'yes');
   }
 
-  static parseConference(single                    , source                 )          {
-    const numbers = [];
-    let firstNumber = '';
-
-    if (single && single.extensions && single.extensions.length > 0 && single.extensions[0].exten) {
-      firstNumber = single.extensions[0].exten;
-      numbers.push({ label: 'exten', number: firstNumber });
-    }
-
-    return new Contact({
-      sourceId: String(single.id),
-      name: single.name,
-      number: firstNumber,
-      numbers,
-      source: source.name,
-      backend: 'conference',
-    });
+  hasVideo() {
+    const allow = this.getOptions().find(option => option[0] === 'allow');
+    return Array.isArray(allow) && allow[1].split(',').some(codec => availableCodecs.some(c => c === codec));
   }
 
-  static newFrom(contact         ) {
-    return newFrom(contact, Contact);
+  hasVideoConference() {
+    return (
+      this.getOptions().some(option => option[0] === 'max_audio_streams' && parseInt(option[1], 10) > 0)
+      && this.getOptions().some(option => option[0] === 'max_video_streams' && parseInt(option[1], 10) > 1)
+    );
   }
 
   constructor({
     id,
     uuid,
-    name,
-    number,
-    numbers,
-    email,
-    emails,
-    source,
-    sourceId,
-    entreprise,
-    birthday,
-    address,
-    note,
-    state,
-    lineState,
-    lastActivity,
-    mobile,
-    status,
-    endpointId,
-    personal,
-    favorited,
-    backend,
-    personalStatus,
-    sessions,
-    connected,
-    doNotDisturb,
-    ringing,
-    previousPresential,
-    lines,
+    tenantUuid,
+    username,
+    secret,
+    type,
+    host,
+    options,
+    endpointSectionOptions,
+    links,
+    trunk,
+    line,
   }                   = {}) {
     this.id = id;
     this.uuid = uuid;
-    this.name = name || '';
-    this.number = number;
-    this.numbers = numbers;
-    this.email = email;
-    this.emails = emails;
-    this.source = source;
-    this.sourceId = sourceId;
-    this.entreprise = entreprise;
-    this.birthday = birthday;
-    this.address = address;
-    this.note = note;
-    this.state = state;
-    this.lineState = lineState;
-    this.lastActivity = lastActivity;
-    this.mobile = mobile;
-    this.status = status;
-    this.endpointId = endpointId;
-    this.personal = personal;
-    this.favorited = favorited;
-    this.backend = backend;
-    this.personalStatus = personalStatus || '';
-    this.sessions = sessions || [];
-    this.connected = connected;
-    this.doNotDisturb = doNotDisturb;
-    this.ringing = ringing;
-    this.previousPresential = previousPresential;
-    this.lines = lines || [];
+    this.tenantUuid = tenantUuid;
+    this.username = username;
+    this.secret = secret;
+    this.type = type;
+    this.host = host;
+    this.options = options;
+    this.endpointSectionOptions = endpointSectionOptions;
+    this.links = links;
+    this.trunk = trunk;
+    this.line = line;
 
     // Useful to compare instead of instanceof with minified code
-    this.type = 'Contact';
+    this.type = 'SipLine';
   }
+}
 
-  setFavorite(value         ) {
-    this.favorited = value;
+//      
 
-    return this;
-  }
+const STATE = {
+  AVAILABLE: 'available',
+  UNAVAILABLE: 'unavailable',
+  INVISIBLE: 'invisible',
+  DISCONNECTED: 'disconnected',
+  AWAY: 'away',
+};
 
-  is(other         )          {
-    const sameSourceId = this.sourceId !== null && other.sourceId !== null && this.sourceId === other.sourceId;
-    const sameUuid = !!this.uuid && !!other.uuid && this.uuid === other.uuid;
+const LINE_STATE = {
+  AVAILABLE: 'available',
+  HOLDING: 'holding',
+  RINGING: 'ringing',
+  TALKING: 'talking',
+  UNAVAILABLE: 'unavailable',
+  PROGRESSING: 'progressing',
+};
 
-    const hasSameId = sameSourceId || sameUuid;
-    const hasSameBackend = !!this.backend && !!other.backend && this.backend === other.backend;
-    const hasSameSource = !!this.source && !!other.source && this.source === other.source;
+                        
+                                              
+                    
+                     
+                   
+                    
+               
+                
+               
+                                                                                                                    
+                                      
+                                    
+                                   
+     
+             
+                   
+                    
+                   
+                
+             
+           
+                          
+                       
+      
+               
+                          
+                       
+      
+                    
+                          
+                       
+      
+    
+                               
+                             
+             
+          
+                       
+      
+    
+                           
+           
+                      
+               
+                     
+                   
+    
+               
+               
+                 
+    
+                                    
+                      
+                     
+                 
+     
+                                       
+  
 
-    return !!other && hasSameId && hasSameBackend && hasSameSource;
+                         
+             
+                    
+                   
+                
+                     
+                            
+                   
+                       
+                                 
+                         
+                 
+                 
+                            
+               
+               
+                 
+    
+           
+                      
+               
+                     
+                   
+    
+                           
+                                                                                       
+                                     
+  
+
+class Profile {
+             
+                    
+                   
+                
+                     
+                           
+                   
+                       
+                                 
+                         
+                                    
+                 
+                                           
+                 
+                            
+                                                                              
+                           
+                                                                                      
+
+  static parse(plain                 )          {
+    return new Profile({
+      id: plain.uuid,
+      firstName: plain.firstName || plain.firstname || '',
+      lastName: plain.lastName || plain.lastname || '',
+      email: plain.email,
+      lines: plain.lines.map(line => Line.parse(line)),
+      username: plain.username,
+      mobileNumber: plain.mobile_phone_number || '',
+      forwards: [
+        ForwardOption.parse(plain.forwards.unconditional, FORWARD_KEYS.UNCONDITIONAL),
+        ForwardOption.parse(plain.forwards.noanswer, FORWARD_KEYS.NO_ANSWER),
+        ForwardOption.parse(plain.forwards.busy, FORWARD_KEYS.BUSY),
+      ],
+      doNotDisturb: plain.services.dnd.enabled,
+      subscriptionType: plain.subscription_type,
+      voicemail: plain.voicemail,
+      switchboards: plain.switchboards || [],
+      agent: plain.agent,
+      status: '',
+      callPickupTargetUsers: plain.call_pickup_target_users || [],
+      onlineCallRecordEnabled: plain.online_call_record_enabled,
+    });
   }
 
-  hasId(id        )          {
-    return this.uuid === id;
+  static newFrom(profile         ) {
+    return newFrom(profile, Profile);
   }
 
-  hasNumber(number        )          {
-    return this.number === number;
-  }
+  constructor({
+    id,
+    firstName,
+    lastName,
+    email,
+    lines,
+    username,
+    mobileNumber,
+    forwards,
+    doNotDisturb,
+    state,
+    subscriptionType,
+    voicemail,
+    switchboards,
+    agent,
+    status,
+    sipLines,
+    callPickupTargetUsers,
+    onlineCallRecordEnabled,
+  }                           = {}) {
+    this.id = id;
+    this.firstName = firstName;
+    this.lastName = lastName;
+    this.email = email;
+    this.lines = lines;
+    this.username = username;
+    this.mobileNumber = mobileNumber;
+    this.forwards = forwards;
+    this.doNotDisturb = doNotDisturb;
+    this.state = state;
+    this.voicemail = voicemail;
+    this.subscriptionType = subscriptionType;
+    this.switchboards = switchboards;
+    this.agent = agent;
+    this.status = status;
+    this.callPickupTargetUsers = callPickupTargetUsers;
+    this.onlineCallRecordEnabled = onlineCallRecordEnabled;
 
-  hasEndpointId(endpointId        )          {
-    return this.endpointId === endpointId;
+    this.sipLines = sipLines || [];
   }
 
-  isAvailable()          {
-    return this.state === STATE.AVAILABLE;
-  }
+  static getLinesState(lines               ) {
+    let result = LINE_STATE.UNAVAILABLE;
 
-  isAway()          {
-    return this.state === STATE.AWAY;
-  }
+    // eslint-disable-next-line
+    for (const line of lines) {
+      if (line.state === LINE_STATE.RINGING) {
+        result = LINE_STATE.RINGING;
+        break;
+      }
 
-  isUnavailable()          {
-    return this.state === STATE.UNAVAILABLE;
-  }
+      if (line.state === LINE_STATE.TALKING) {
+        result = LINE_STATE.TALKING;
+        break;
+      }
 
-  isInvisible()          {
-    return this.state === STATE.INVISIBLE;
-  }
+      if (line.state === LINE_STATE.AVAILABLE) {
+        result = LINE_STATE.AVAILABLE;
+      }
+    }
 
-  isInCall()          {
-    return this.lineState === LINE_STATE.TALKING || this.lineState === LINE_STATE.HOLDING;
+    return result;
   }
 
-  isRinging()           {
-    return this.ringing;
+  hasId(id        ) {
+    return id === this.id;
   }
 
-  isInUseOrRinging()          {
-    return this.lineState === LINE_STATE.TALKING || this.lineState === LINE_STATE.RINGING;
-  }
+  setMobileNumber(number        ) {
+    this.mobileNumber = number;
 
-  isProgressing()          {
-    return this.lineState === LINE_STATE.PROGRESSING;
+    return this;
   }
 
-  merge(old         )          {
-    Object.keys(old).filter(key => key !== 'lineState').forEach(key => {
-      // $FlowFixMe
-      this[key] = old[key] || this[key];
-    });
+  setForwardOption(forwardOption               ) {
+    const updatedForwardOptions = this.forwards.slice();
+    const index = updatedForwardOptions.findIndex(forward => forward.is(forwardOption));
+    updatedForwardOptions.splice(index, 1, forwardOption);
 
-    if (old.lineState && !this.lineState) {
-      this.lineState = old.lineState;
-    }
+    this.forwards = updatedForwardOptions;
 
     return this;
   }
 
-  isIntern()          {
-    return !!this.uuid;
-  }
-
-  isCallable(session         )          {
-    return !!this.number && !!session && !session.is(this);
-  }
-
-  isFromMobile() {
-    return this.source === SOURCE_MOBILE;
-  }
+  setDoNotDisturb(enabled         ) {
+    this.doNotDisturb = enabled;
 
-  isFavorite() {
-    return this.favorited;
+    return this;
   }
 
-  separateName()                                          {
-    if (!this.name) {
-      return {
-        firstName: '',
-        lastName: '',
-      };
-    }
-    const names = this.name.split(/\s+/);
-    const firstName = names[0];
-    const lastName = names.slice(1).join(' ');
+  setState(state        ) {
+    this.state = state;
 
-    return {
-      firstName,
-      lastName,
-    };
+    return this;
   }
 }
 
-// Can't use `semver` package as Wazo version aren't in semver format
-
-const compareVersions = (a, b) => {
-  let i;
-  let diff;
-  const regExStrip0 = /(\.0+)+$/;
-  const segmentsA = a.replace(regExStrip0, '').split('.');
-  const segmentsB = b.replace(regExStrip0, '').split('.');
-  const l = Math.min(segmentsA.length, segmentsB.length);
+//      
+                                                         
 
-  for (i = 0; i < l; i++) {
-    diff = parseInt(segmentsA[i], 10) - parseInt(segmentsB[i], 10);
-    if (diff) {
-      return diff;
-    }
-  }
-  return segmentsA.length - segmentsB.length;
+const BACKEND = {
+  OFFICE365: 'office365',
+  PERSONAL: 'personal',
+  GOOGLE: 'google',
+  WAZO: 'wazo',
 };
 
-//      
+                          
+                    
+                   
+                      
+                 
+                   
+                      
+                    
+                
+                                                     
+                      
+  
 
-const swarmKey = KEYUTIL.getKey(swarmPublicKey);
-const MINIMUM_WAZO_ENGINE_VERSION_FOR_DEFAULT_CONTEXT = '19.08';
+                               
+                 
+                  
+                            
+              
+                    
+                    
+                      
+                        
+                      
+                            
+    
+  
+
+                                
+                               
+               
+                                
+                                  
+  
 
+                                       
+             
+                     
+                    
+                  
+                                                      
                  
+                      
+                    
+                   
+                
+                    
+                     
+                    
+                   
+                     
+  
+
+                                       
+         
          
                  
-                          
-                       
-                                       
-                        
-                           
-                      
                       
+                 
+                               
+                              
+                                 
+                                    
+                                 
+                           
+                                       
+                              
+            
+           
+        
+      
+    
+  
+
+// @see: https://github.com/rt2zz/react-native-contacts#example-contact-record
+                                     
+                   
+                  
+                         
+                  
+                  
+     
                     
+                     
+                     
+                   
+               
                        
-                            
+                  
                 
+     
+                       
+                  
                    
+     
+                        
                         
+                          
+                   
                  
-                         
-                            
-                             
-                       
-                                      
+                  
+                   
                      
-      
+                    
+                  
+     
+             
+                 
+                  
+                
     
   
 
+                         
+              
+                
+                
+                  
+                                                      
                       
-               
-                                                  
+                 
+                                                    
+                      
+                    
+                   
+                
+                      
+                     
+                 
+                  
+                     
+                     
+                              
+                        
+                   
+                  
+                   
+                          
+                                                     
+                      
+                         
+                    
                    
   
 
+                          
+                     
+                
+                       
+                        
+                             
                          
-                                
+                    
+                       
+                   
+                          
+                  
+                      
+                                                           
+                 
+                  
                  
+                   
+                       
+             
+                   
+                
+                
+                               
+               
+                  
+                      
                 
+                      
+                    
                          
                         
-                 
+                  
+                  
+                  
+             
                        
                      
+                   
+  
+
+                     
+                
+                
+                    
+                   
+                           
+               
+             
+                        
+  
+                           
                   
-                                        
-                          
+               
+             
+                                                        
+                                                     
+  
+
                        
+                   
+             
+               
+                    
+                        
   
 
-class Session {
+const SOURCE_MOBILE = 'mobile';
+
+class Contact {
+               
+
+              
                 
                 
-                        
+                  
+                                                      
+                      
+                 
+                                                    
+                      
+                    
+                   
                 
                       
+                     
+                 
+                     
+                              
+                        
+                   
+                  
+                    
+                  
+                   
+                         
+                                                     
                       
-                       
                          
                     
                   
-                                       
-
-  static parse(plain          )           {
-    const token = plain.data.metadata ? plain.data.metadata.jwt : null;
-    let authorizations = [];
 
-    // Add authorizations from JWT
-    if (token) {
-      const isValid = jws.JWS.verifyJWT(token, swarmKey, { alg: ['RS256'], verifyAt: new Date() });
-      if (isValid) {
-        const decodedToken = jws.JWS.readSafeJSONString(b64utoutf8(token.split('.')[1]));
-        authorizations = decodedToken ? decodedToken.authorizations : [];
-      }
-    }
+  static merge(oldContacts                , newContacts                )                 {
+    return newContacts.map(current => {
+      const old = oldContacts.find(contact => contact && contact.is(current));
 
-    return new Session({
-      token: plain.data.token,
-      refreshToken: plain.data.refresh_token || null,
-      uuid: plain.data.metadata ? plain.data.metadata.uuid : null,
-      sessionUuid: plain.data.session_uuid,
-      authorizations,
-      acl: plain.data.acls ? plain.data.acls : plain.data.acl ? plain.data.acl : [],
-      tenantUuid: plain.data.metadata ? plain.data.metadata.tenant_uuid : undefined,
-      expiresAt: new Date(`${plain.data.utc_expires_at}z`),
-      engineUuid: plain.data.xivo_uuid,
+      return old ? current.merge(old) : current;
     });
   }
 
-  static newFrom(profile         ) {
-    return newFrom(profile, Session);
-  }
+  static sortContacts(a         , b         ) {
+    const aNames = a.separateName();
+    const bNames = b.separateName();
+    const aLastName = aNames.lastName;
+    const bLastName = bNames.lastName;
 
-  constructor({
-    token,
-    uuid,
-    tenantUuid,
-    profile,
-    expiresAt,
-    authorizations,
-    acl,
-    engineVersion,
-    refreshToken,
-    sessionUuid,
-    engineUuid,
-  }                   = {}) {
-    this.token = token;
-    this.uuid = uuid;
-    this.tenantUuid = tenantUuid || null;
-    this.profile = profile;
-    this.expiresAt = expiresAt;
-    this.authorizations = authorizations || [];
-    this.acl = acl || [];
-    this.engineVersion = engineVersion;
-    this.refreshToken = refreshToken;
-    this.sessionUuid = sessionUuid;
-    this.engineUuid = engineUuid;
-  }
+    // last Name can be empty
+    if (aLastName === bLastName) {
+      return aNames.firstName.localeCompare(bNames.firstName);
+    }
 
-  hasExpired(date       = new Date())          {
-    return date >= this.expiresAt;
+    return aLastName.localeCompare(bLastName);
   }
 
-  is(contact         )          {
-    return Boolean(contact) && this.uuid === contact.uuid;
+  static parseMany(response                  )                 {
+    return response.results.map(r => Contact.parse(r, response.column_types));
   }
 
-  using(profile         )          {
-    this.profile = profile;
-
-    return this;
-  }
+  static manyGraphQlWithNumbersParser(numbers          )           {
+    return (response                         ) => {
+      if (!response.data || !response.data.me || !response.data.me.contacts) {
+        return [];
+      }
 
-  hasAuthorizations() {
-    return this.authorizations && !!this.authorizations.length;
-  }
+      return response.data.me.contacts.edges.map((edge, i) => {
+        if (!edge.node) {
+          return null;
+        }
 
-  displayName()         {
-    return this.profile ? `${this.profile.firstName} ${this.profile.lastName}` : '';
-  }
+        const { email } = edge.node;
+        const name = edge.node.firstname && edge.node.lastname
+          ? `${edge.node.firstname || ''} ${edge.node.lastname || ''}` : edge.node.wazoReverse;
 
-  hasAccessToVoicemail()          {
-    if (!this.profile) {
-      return false;
-    }
-    return !!this.profile.voicemail;
+        return new Contact({
+          name,
+          number: numbers[i],
+          numbers: [{ label: 'primary', number: numbers[i] }],
+          backend: edge.node.wazoBackend,
+          source: edge.node.wazoSourceName,
+          sourceId: edge.node.wazoSourceEntryId || '',
+          email: email || '',
+          emails: email ? [{ label: 'primary', email }] : [],
+          uuid: edge.node.userUuid,
+        });
+      }).filter(contact => !!contact);
+    };
   }
 
-  primaryLine()        {
-    return this.profile && this.profile.lines.length > 0 ? this.profile.lines[0] : null;
+  static fetchNumbers(plain                 , columns                )                {
+    const numberColumns = columns
+      .map((e, index) => ({ index, columnName: e }))
+      .filter(e => e.columnName === 'number' || e.columnName === 'callable')
+      .map(e => e.index);
+
+    return plain.column_values.filter((e, index) => numberColumns.some(i => i === index) && e !== null);
   }
 
-  primarySipLine()           {
-    return this.profile && this.profile.sipLines.length > 0 ? this.profile.sipLines[0] : null;
+  static parse(plain                 , columns                )          {
+    const numbers = Contact.fetchNumbers(plain, columns);
+    const email = plain.column_values[columns.indexOf('email')];
+
+    return new Contact({
+      name: plain.column_values[columns.indexOf('name')],
+      number: numbers.length ? numbers[0] : '',
+      numbers: numbers.map((number, i) => ({ label: i === 0 ? 'primary' : 'secondary', number })),
+      favorited: plain.column_values[columns.indexOf('favorite')],
+      email: email || '',
+      emails: email ? [{ label: 'primary', email }] : [],
+      entreprise: plain.column_values[columns.indexOf('entreprise')] || '',
+      birthday: plain.column_values[columns.indexOf('birthday')] || '',
+      address: plain.column_values[columns.indexOf('address')] || '',
+      note: plain.column_values[columns.indexOf('note')] || '',
+      endpointId: plain.relations.endpoint_id,
+      personal: plain.column_values[columns.indexOf('personal')],
+      source: plain.source,
+      sourceId: plain.relations.source_entry_id || '',
+      uuid: plain.relations.user_uuid,
+      backend: plain.backend || '',
+    });
   }
 
-  primaryWebRtcLine()           {
-    return this.profile && (this.profile.sipLines || []).find(sipLine => sipLine && sipLine.isWebRtc());
+  static parseManyPersonal(results                                )                  {
+    return results.map(r => Contact.parsePersonal(r));
   }
 
-  primaryCtiLine()           {
-    return this.profile && (this.profile.sipLines || []).find(sipLine => sipLine && !sipLine.isWebRtc());
+  static parsePersonal(plain                         )          {
+    return new Contact({
+      name: `${plain.firstName || plain.firstname || ''} ${plain.lastName || plain.lastname || ''}`,
+      number: plain.number || '',
+      numbers: plain.number ? [{ label: 'primary', number: plain.number }] : [],
+      email: plain.email || '',
+      emails: plain.email ? [{ label: 'primary', email: plain.email }] : [],
+      source: 'personal',
+      sourceId: plain.id || '',
+      entreprise: plain.entreprise || '',
+      birthday: plain.birthday || '',
+      address: plain.address || '',
+      note: plain.note || '',
+      favorited: plain.favorited,
+      personal: true,
+      backend: plain.backend || BACKEND.PERSONAL,
+    });
   }
 
-  primaryContext()         {
-    if (this.engineVersion) {
-      if (this.hasEngineVersionGte(MINIMUM_WAZO_ENGINE_VERSION_FOR_DEFAULT_CONTEXT)) {
-        return 'default';
-      }
-    }
+  static parseMobile(plain                       )          {
+    let address = '';
+    if (plain.postalAddresses.length) {
+      const postalAddress = plain.postalAddresses[0];
 
-    const line = this.primaryLine();
+      address = `${postalAddress.street} ${postalAddress.city} ${postalAddress.postCode} ${postalAddress.country}`;
+    }
 
-    return line && line.extensions.length > 0 ? line.extensions[0].context : 'default';
+    return new Contact({
+      name: `${plain.givenName || ''} ${plain.familyName || ''}`,
+      number: plain.phoneNumbers.length ? plain.phoneNumbers[0].number : '',
+      numbers: plain.phoneNumbers.length ? [{ label: 'primary', number: plain.phoneNumbers[0].number }] : [],
+      email: plain.emailAddresses.length ? plain.emailAddresses[0].email : '',
+      emails: plain.emailAddresses.length ? [{ label: 'primary', email: plain.emailAddresses[0].email }] : [],
+      source: SOURCE_MOBILE,
+      sourceId: plain.recordID || '',
+      birthday: plain.birthday ? `${plain.birthday.year}-${plain.birthday.month}-${plain.birthday.day}` : '',
+      address,
+      note: plain.note || '',
+      favorited: false,
+      personal: true,
+    });
   }
 
-  hasEngineVersionGte(version        ) {
-    return this.engineVersion && compareVersions(String(this.engineVersion), String(version)) >= 0;
+  static parseManyOffice365(response                     , source                 )                 {
+    return response.map(r => Contact.parseOffice365(r, source));
   }
 
-  primaryNumber()          {
-    const line = this.primaryLine();
+  static parseOffice365(single                   , source                 )          {
+    const emails                                           = [];
+    const numbers                                            = [];
 
-    return line && line.extensions.length ? line.extensions[0].exten : null;
-  }
+    if (single.emailAddresses) {
+      single.emailAddresses.map(email => emails.push({ email: email.address }));
+    }
 
-  allLines()         {
-    return this.profile ? this.profile.lines || [] : [];
-  }
+    if (single.businessPhones) {
+      single.businessPhones.map(phone => numbers.push({ label: 'business', number: phone }));
+    }
 
-  allNumbers()           {
-    const extensions = this.allLines().map(line => line.extensions.map(extension => extension.exten));
-    if (!extensions.length) {
-      return [];
+    if (single.mobilePhone) {
+      numbers.push({ label: 'mobile', number: single.mobilePhone });
     }
 
-    return extensions.reduce((a, b) => a.concat(b));
-  }
+    if (single.homePhones) {
+      single.homePhones.map(phone => numbers.push({ label: 'home', number: phone }));
+    }
 
-  hasExtension(extension        )          {
-    return this.allNumbers().some(number => number === extension);
+    return new Contact({
+      sourceId: single.id || '',
+      name: single.displayName || '',
+      number: numbers.length ? numbers[0].number : '',
+      numbers,
+      emails,
+      source: source.name,
+      backend: BACKEND.OFFICE365,
+    });
   }
 
-  get acls()                 {
-    console.warn('`acls` property of Session has been removed in Wazo\'s SDK, please use `acl` instead.');
-    return this.acl;
+  static parseManyGoogle(response                  , source                 )                 {
+    return response.map(r => Contact.parseGoogle(r, source));
   }
-}
 
-//      
-/* eslint-disable no-param-reassign */
+  static parseGoogle(single                , source                 )          {
+    const emails                                           = [];
+    const numbers                                            = [];
 
-var updateFrom = (instance     , from     ) => {
-  Object.keys(from).forEach(key => {
-    // $FlowFixMe
-    if (
-      (!instance[key] && from[key])
-      || (typeof instance[key] !== 'undefined' && typeof from[key] !== 'undefined' && instance[key] !== from[key])
-    ) {
-      // $FlowFixMe
-      instance[key] = from[key];
+    if (single.emails) {
+      single.emails.forEach(email =>
+        (typeof email === 'object' ? { email: email.address, label: email.label } : { email }));
     }
-  });
-};
 
-/*       */
+    if (single.numbers_by_label) {
+      Object.keys(single.numbers_by_label).forEach(label =>
+        numbers.push({ label, number: single.numbers_by_label[label] }));
+    } else if (single.numbers) {
+      single.numbers.forEach(phone => numbers.push({ number: phone }));
+    }
 
-class BadResponse extends Error {
-  static fromResponse(error        , status        ) {
-    return new BadResponse(
-      error.message || JSON.stringify(error),
-      status,
-      error.timestamp,
-      error.error_id,
-      error.details,
-      error,
-    );
+    return new Contact({
+      sourceId: single.id || '',
+      name: single.name || '',
+      number: numbers.length ? numbers[0].number : '',
+      numbers,
+      emails,
+      source: source.name,
+      backend: BACKEND.GOOGLE,
+    });
   }
 
-  static fromText(response        , status        ) {
-    return new BadResponse(response, status);
+  static parseManyWazo(response                , source                 )                 {
+    return response.map(r => Contact.parseWazo(r, source));
   }
 
-                  
-                 
-                     
-                   
-                   
-                
+  static parseWazo(single              , source                 )          {
+    const emails = [];
+    const numbers = [];
 
-  constructor(
-    message        ,
-    status        ,
-    timestamp          = null,
-    errorId          = null,
-    details          = null,
-    error         = null,
-  ) {
-    super(message);
+    if (single.email) {
+      emails.push({ label: 'email', email: single.email });
+    }
 
-    this.timestamp = timestamp;
-    this.status = status;
-    this.errorId = errorId;
-    this.details = details;
-    this.error = error;
-  }
-}
+    if (single.exten) {
+      numbers.push({ label: 'exten', number: single.exten });
+    }
 
-/*       */
+    if (single.mobile_phone_number) {
+      numbers.push({ label: 'mobile', number: single.mobile_phone_number });
+    }
 
-class ServerError extends BadResponse {
-  static fromResponse(error        , status        ) {
-    return new ServerError(
-      error.message || JSON.stringify(error),
-      status,
-      error.timestamp,
-      error.error_id,
-      error.details,
-    );
+    return new Contact({
+      uuid: single.uuid,
+      sourceId: String(single.id) || '',
+      name: `${single.firstname}${single.lastname ? ` ${single.lastname}` : ''}`,
+      number: numbers.length ? numbers[0].number : '',
+      numbers,
+      emails,
+      source: source.name,
+      backend: BACKEND.WAZO,
+    });
   }
 
-  static fromText(response        , status        ) {
-    return new ServerError(response, status);
+  static parseManyConference(response                      , source                 )                 {
+    return response.map(r => Contact.parseConference(r, source));
   }
-}
-
-/*       */
-/* global navigator */
-const isMobile = () => typeof navigator !== 'undefined' && navigator.product === 'ReactNative';
-
-/* global window */
-
-const TRACE = 'trace';
-const DEBUG = 'debug';
-const INFO = 'info';
-const LOG = 'log';
-const WARN = 'warn';
-const ERROR = 'error';
-const CONSOLE_METHODS = [INFO, LOG, WARN, ERROR];
-const LOG_LEVELS = [TRACE, DEBUG, INFO, LOG, WARN, ERROR];
-const CATEGORY_PREFIX = 'logger-category=';
 
-const MAX_REMOTE_RETRY = 100;
+  static parseConference(single                    , source                 )          {
+    const numbers = [];
+    let firstNumber = '';
 
-const addLevelsTo = (instance        , withMethods = false) => {
-  instance.TRACE = TRACE;
-  instance.DEBUG = DEBUG;
-  instance.INFO = INFO;
-  instance.LOG = LOG;
-  instance.WARN = WARN;
-  instance.ERROR = ERROR;
+    if (single && single.extensions && single.extensions.length > 0 && single.extensions[0].exten) {
+      firstNumber = single.extensions[0].exten;
+      numbers.push({ label: 'exten', number: firstNumber });
+    }
 
-  if (withMethods) {
-    instance.trace = (...args) => instance.apply(null, [TRACE, ...args]);
-    instance.debug = (...args) => instance.apply(null, [DEBUG, ...args]);
-    instance.info = (...args) => instance.apply(null, [INFO, ...args]);
-    instance.log = (...args) => instance.apply(null, [LOG, ...args]);
-    instance.warn = (...args) => instance.apply(null, [WARN, ...args]);
-    instance.error = (...args) => instance.apply(null, [ERROR, ...args]);
+    return new Contact({
+      sourceId: String(single.id),
+      name: single.name,
+      number: firstNumber,
+      numbers,
+      source: source.name,
+      backend: 'conference',
+    });
   }
 
-  return instance;
-};
+  static newFrom(contact         ) {
+    return newFrom(contact, Contact);
+  }
 
-const safeStringify = (object        ) => {
-  const result = '{"message": "Not parsable JSON"}';
-  try {
-    return JSON.stringify(object);
-  } catch (e) {
-    // Nothing to do
+  constructor({
+    id,
+    uuid,
+    name,
+    number,
+    numbers,
+    email,
+    emails,
+    source,
+    sourceId,
+    entreprise,
+    birthday,
+    address,
+    note,
+    state,
+    lineState,
+    lastActivity,
+    mobile,
+    status,
+    endpointId,
+    personal,
+    favorited,
+    backend,
+    personalStatus,
+    sessions,
+    connected,
+    doNotDisturb,
+    ringing,
+    previousPresential,
+    lines,
+  }                   = {}) {
+    this.id = id;
+    this.uuid = uuid;
+    this.name = name || '';
+    this.number = number;
+    this.numbers = numbers;
+    this.email = email;
+    this.emails = emails;
+    this.source = source;
+    this.sourceId = sourceId;
+    this.entreprise = entreprise;
+    this.birthday = birthday;
+    this.address = address;
+    this.note = note;
+    this.state = state;
+    this.lineState = lineState;
+    this.lastActivity = lastActivity;
+    this.mobile = mobile;
+    this.status = status;
+    this.endpointId = endpointId;
+    this.personal = personal;
+    this.favorited = favorited;
+    this.backend = backend;
+    this.personalStatus = personalStatus || '';
+    this.sessions = sessions || [];
+    this.connected = connected;
+    this.doNotDisturb = doNotDisturb;
+    this.ringing = ringing;
+    this.previousPresential = previousPresential;
+    this.lines = lines || [];
+
+    // Useful to compare instead of instanceof with minified code
+    this.type = 'Contact';
   }
 
-  return result;
-};
+  setFavorite(value         ) {
+    this.favorited = value;
 
-class IssueReporter {
-                
-               
-              
-               
-                
+    return this;
+  }
 
-                            
-                   
-                                     
+  is(other         )          {
+    const sameSourceId = this.sourceId !== null && other.sourceId !== null && this.sourceId === other.sourceId;
+    const sameUuid = !!this.uuid && !!other.uuid && this.uuid === other.uuid;
 
-  constructor() {
-    addLevelsTo(this);
+    const hasSameId = sameSourceId || sameUuid;
+    const hasSameBackend = !!this.backend && !!other.backend && this.backend === other.backend;
+    const hasSameSource = !!this.source && !!other.source && this.source === other.source;
 
-    this.oldConsoleMethods = null;
-    this.enabled = false;
-    this.remoteClientConfiguration = null;
+    return !!other && hasSameId && hasSameBackend && hasSameSource;
   }
 
-  init() {
-    this._catchConsole();
+  hasId(id        )          {
+    return this.uuid === id;
   }
 
-  configureRemoteClient(configuration         = { tag: 'wazo-sdk', host: null, port: null, level: null, extra: {} }) {
-    this.remoteClientConfiguration = configuration;
+  hasNumber(number        )          {
+    return this.number === number;
   }
 
-  enable() {
-    if (!this.oldConsoleMethods) {
-      this.init();
-    }
-
-    this.enabled = true;
+  hasEndpointId(endpointId        )          {
+    return this.endpointId === endpointId;
   }
 
-  disable() {
-    this.enabled = false;
+  isAvailable()          {
+    return this.state === STATE.AVAILABLE;
   }
 
-  loggerFor(category        )      {
-    const logger = (level        , ...args     ) => {
-      this.log.apply(this, [level, this._makeCategory(category), ...args]);
-    };
-
-    return addLevelsTo(logger, true);
+  isAway()          {
+    return this.state === STATE.AWAY;
   }
 
-  removeSlashes(str        ) {
-    return str.replace(/"/g, "'").replace(/\\/g, '');
+  isUnavailable()          {
+    return this.state === STATE.UNAVAILABLE;
   }
 
-  log(level        , ...args     ) {
-    if (!this.enabled) {
-      return;
-    }
-
-    // Handle category label
-    let category = null;
-    let extra = {};
-    if (args[0].indexOf(CATEGORY_PREFIX) === 0) {
-      category = args[0].split('=')[1];
-      // eslint-disable-next-line no-param-reassign
-      args.splice(0, 1);
-    }
-
-    // Handle extra data as object for the last argument
-    const lastArg = args[args.length - 1];
-    if (lastArg && ((typeof lastArg === 'object' && Object.keys(lastArg).length) || lastArg instanceof Error)) {
-      if (lastArg instanceof Error) {
-        extra = {
-          errorMessage: lastArg.message,
-          errorStack: lastArg.stack,
-          errorType: lastArg.constructor.name,
-        };
-      } else {
-        extra = lastArg;
-      }
-      // eslint-disable-next-line no-param-reassign
-      args.splice(1, 1);
-    }
-
-    const date = moment().format('YYYY-MM-DD HH:mm:ss.SSS');
-    const message = args.join(', ');
-    let consoleMessage = message;
-
-    if (Object.keys(extra).length) {
-      const parsedExtra = safeStringify(extra);
-      consoleMessage = `${consoleMessage} (${parsedExtra})`;
-    }
+  isInvisible()          {
+    return this.state === STATE.INVISIBLE;
+  }
 
-    if (category) {
-      consoleMessage = `[${category}] ${consoleMessage}`;
-    }
+  isInCall()          {
+    return this.lineState === LINE_STATE.TALKING || this.lineState === LINE_STATE.HOLDING;
+  }
 
-    // Log the message in the console anyway (but don't console.error on mobile)
-    const consoleLevel = isMobile() && level === 'error' ? WARN : level;
+  isRinging()           {
+    return this.ringing;
+  }
 
-    // eslint-disable-next-line
-    const oldMethod = this.oldConsoleMethods[consoleLevel] || this.oldConsoleMethods.log;
-    oldMethod.apply(oldMethod, [date, consoleMessage]);
+  isInUseOrRinging()          {
+    return this.lineState === LINE_STATE.TALKING || this.lineState === LINE_STATE.RINGING;
+  }
 
-    this._sendToRemoteLogger(level, { date, message, category, ...extra });
+  isProgressing()          {
+    return this.lineState === LINE_STATE.PROGRESSING;
   }
 
-  logRequest(url        , options        , response        , start      ) {
-    if (!this.enabled) {
-      return;
-    }
-    const { status } = response;
-    const duration = new Date() - start;
+  merge(old         )          {
+    Object.keys(old).filter(key => key !== 'lineState').forEach(key => {
+      // $FlowFixMe
+      this[key] = old[key] || this[key];
+    });
 
-    let level = TRACE;
-    if (status >= 400 && status < 500) {
-      level = WARN;
-    } else if (status >= 500) {
-      level = ERROR;
+    if (old.lineState && !this.lineState) {
+      this.lineState = old.lineState;
     }
 
-    this.log(level, this._makeCategory('http'), url, {
-      status,
-      body: this.removeSlashes(JSON.stringify(options.body)),
-      method: options.method,
-      headers: options.headers,
-      duration,
-    });
-  }
-
-  // Logs aren't stored anymore
-  getLogs() {
-    console.warn('IssueReporter\'s logs aren\'t stored anymore. Please use fluentd to store them');
-    return [];
+    return this;
   }
 
-  getParsedLogs() {
-    console.warn('IssueReporter\'s logs aren\'t stored anymore. Please use fluentd to store them');
-    return [];
+  isIntern()          {
+    return !!this.uuid;
   }
 
-  getReport() {
-    return this.getParsedLogs().join('\r\n');
+  isCallable(session         )          {
+    return !!this.number && !!session && !session.is(this);
   }
 
-  _catchConsole() {
-    this.oldConsoleMethods = {};
-    CONSOLE_METHODS.forEach((methodName        ) => {
-      // eslint-disable-next-line
-      this.oldConsoleMethods[methodName] = console[methodName];
-      window.console[methodName] = (...args) => {
-        // Store message
-        try {
-          this.log(methodName, args.join(' '));
-          // Use old console method to log it normally
-          this.oldConsoleMethods[methodName].apply(null, args);
-        } catch (e) {
-          // Avoid circular structure issues
-        }
-      };
-    });
+  isFromMobile() {
+    return this.source === SOURCE_MOBILE;
   }
 
-  _sendToRemoteLogger(level        , payload        , retry         = 0) {
-    if (!this.remoteClientConfiguration || retry >= MAX_REMOTE_RETRY) {
-      return;
-    }
+  isFavorite() {
+    return this.favorited;
+  }
 
-    const { tag, host, port, extra, level: minLevel } = this.remoteClientConfiguration;
-    if (!minLevel || this._isLevelAbove(minLevel, level)) {
-      return;
+  separateName()                                          {
+    if (!this.name) {
+      return {
+        firstName: '',
+        lastName: '',
+      };
     }
+    const names = this.name.split(/\s+/);
+    const firstName = names[0];
+    const lastName = names.slice(1).join(' ');
 
-    const isSecure = +port === 443;
-    const url = `http${isSecure ? 's' : ''}://${host}${isSecure ? '' : `:${port}`}/${tag}`;
-
-    realFetch()(url, {
-      method: 'POST',
-      headers: {
-        Accept: 'application/json',
-        'Content-Type': 'application/json',
-      },
-      body: safeStringify({
-        level,
-        ...payload,
-        ...extra,
-      }),
-    }).catch(() => {
-      setTimeout(() => {
-        // eslint-disable-next-line no-underscore-dangle
-        payload._retry = retry + 1;
-        this._sendToRemoteLogger(level, payload, retry + 1);
-      }, 5000 + retry * 1000);
-    });
+    return {
+      firstName,
+      lastName,
+    };
   }
+}
 
-  _isLevelAbove(level1        , level2        ) {
-    return LOG_LEVELS.indexOf(level1) > LOG_LEVELS.indexOf(level2);
-  }
+// Can't use `semver` package as Wazo version aren't in semver format
 
-  _makeCategory(category        ) {
-    return `${CATEGORY_PREFIX}${category}`;
+const compareVersions = (a, b) => {
+  let i;
+  let diff;
+  const regExStrip0 = /(\.0+)+$/;
+  const segmentsA = a.replace(regExStrip0, '').split('.');
+  const segmentsB = b.replace(regExStrip0, '').split('.');
+  const l = Math.min(segmentsA.length, segmentsB.length);
+
+  for (i = 0; i < l; i++) {
+    diff = parseInt(segmentsA[i], 10) - parseInt(segmentsB[i], 10);
+    if (diff) {
+      return diff;
+    }
   }
-}
+  return segmentsA.length - segmentsB.length;
+};
 
-var IssueReporter$1 = new IssueReporter();
+//      
 
-/*       */
+const swarmKey = KEYUTIL.getKey(swarmPublicKey);
+const MINIMUM_WAZO_ENGINE_VERSION_FOR_DEFAULT_CONTEXT = '19.08';
 
-                          
                  
+         
                  
+                          
+                       
+                                       
+                        
+                           
+                      
+                      
                     
-                                 
-                 
+                       
+                            
+                
+                   
                         
+                 
+                         
+                            
+                             
+                       
+                                      
+                     
+      
+    
   
 
-const methods = ['head', 'get', 'post', 'put', 'delete'];
-
-const logger$1 = IssueReporter$1 ? IssueReporter$1.loggerFor('api') : console;
-
-// Use a function here to be able to mock it in tests
-const realFetch = () => {
-  if (typeof document !== 'undefined') {
-    // Browser
-    return window.fetch;
-  }
-
-  if (isMobile()) {
-    // React native
-    return fetch;
-  }
-
-  // nodejs
-  // this package is disable for react-native in package.json because it requires nodejs modules
-  // Used to trick the optimizer to avoid requiring `node-fetch/lib/index` directly
-  // It causes to require it on browsers when delivered by a nodejs engine (cf: vitejs).
-  try {
-    // $FlowFixMe
-    return require(Math.random() >= 0 ? 'node-fetch/lib/index' : '');
-  } catch (e) {
-    return fetch;
-  }
-};
+                      
+               
+                                                  
+                   
+  
 
-class ApiRequester {
-                 
+                         
+                                
                  
-                    
                 
+                         
+                        
+                 
+                       
+                     
                   
+                                        
+                          
                        
-                                 
-                                     
-                           
+  
 
-                 
+class Session {
                 
-                 
                 
-                   
-
-  // eslint-disable-next-line
-  static successResponseParser(response        , isJson         ) {
-    return response.status === 204 || response.status === 201 || response.status === 200;
-  }
-
-  static defaultParser(response        ) {
-    return response.json().then((data        ) => data);
-  }
-
-  static getQueryString(obj        )         {
-    return Object.keys(obj)
-      .filter(key => obj[key])
-      .map(key => `${key}=${encodeURIComponent(obj[key])}`)
-      .join('&');
-  }
+                        
+                
+                      
+                      
+                       
+                         
+                    
+                  
+                                       
 
-  static base64Encode(str        )         {
-    return typeof btoa !== 'undefined' ? btoa(str) : Base64.encode(str);
-  }
+  static parse(plain          )           {
+    const token = plain.data.metadata ? plain.data.metadata.jwt : null;
+    let authorizations = [];
 
-  // @see https://github.com/facebook/flow/issues/183#issuecomment-358607052
-  constructor({ server, refreshTokenCallback, clientId, agent = null, token = null, fetchOptions }                   ) {
-    this.server = server;
-    this.agent = agent;
-    this.clientId = clientId;
-    this.refreshTokenCallback = refreshTokenCallback;
-    this.refreshTokenPromise = null;
-    this.fetchOptions = fetchOptions || {};
+    // Add authorizations from JWT
     if (token) {
-      this.token = token;
+      const isValid = jws.JWS.verifyJWT(token, swarmKey, { alg: ['RS256'], verifyAt: new Date() });
+      if (isValid) {
+        const decodedToken = jws.JWS.readSafeJSONString(b64utoutf8(token.split('.')[1]));
+        authorizations = decodedToken ? decodedToken.authorizations : [];
+      }
     }
 
-    this.shouldLogErrors = true;
+    return new Session({
+      token: plain.data.token,
+      refreshToken: plain.data.refresh_token || null,
+      uuid: plain.data.metadata ? plain.data.metadata.uuid : null,
+      sessionUuid: plain.data.session_uuid,
+      authorizations,
+      acl: plain.data.acls ? plain.data.acls : plain.data.acl ? plain.data.acl : [],
+      tenantUuid: plain.data.metadata ? plain.data.metadata.tenant_uuid : undefined,
+      expiresAt: new Date(`${plain.data.utc_expires_at}z`),
+      engineUuid: plain.data.xivo_uuid,
+    });
+  }
 
-    methods.forEach(method => {
-      // $FlowFixMe
-      ApiRequester.prototype[method] = function sugar(...args) {
-        // Add method in arguments passed to `call`
-        args.splice(1, 0, method);
+  static newFrom(profile         ) {
+    return newFrom(profile, Session);
+  }
 
-        return this.call.call(this, ...args);
-      };
-    });
+  constructor({
+    token,
+    uuid,
+    tenantUuid,
+    profile,
+    expiresAt,
+    authorizations,
+    acl,
+    engineVersion,
+    refreshToken,
+    sessionUuid,
+    engineUuid,
+  }                   = {}) {
+    this.token = token;
+    this.uuid = uuid;
+    this.tenantUuid = tenantUuid || null;
+    this.profile = profile;
+    this.expiresAt = expiresAt;
+    this.authorizations = authorizations || [];
+    this.acl = acl || [];
+    this.engineVersion = engineVersion;
+    this.refreshToken = refreshToken;
+    this.sessionUuid = sessionUuid;
+    this.engineUuid = engineUuid;
   }
 
-  setTenant(tenant         ) {
-    this.tenant = tenant;
+  hasExpired(date       = new Date())          {
+    return date >= this.expiresAt;
   }
 
-  setToken(token        ) {
-    this.token = token;
+  is(contact         )          {
+    return Boolean(contact) && this.uuid === contact.uuid;
   }
 
-  setFetchOptions(options        ) {
-    this.fetchOptions = options;
-  }
+  using(profile         )          {
+    this.profile = profile;
 
-  disableErrorLogging() {
-    this.shouldLogErrors = false;
+    return this;
   }
 
-  enableErrorLogging() {
-    this.shouldLogErrors = true;
+  hasAuthorizations() {
+    return this.authorizations && !!this.authorizations.length;
   }
 
-  async call(
-    path        ,
-    method         = 'get',
-    body          = null,
-    headers                    = null,
-    parse           = ApiRequester.defaultParser,
-    firstCall          = true,
-  )               {
-    const url = this.computeUrl(method, path, body);
-    const newHeaders = this.getHeaders(headers);
-    let newBody = method === 'get' ? null : body;
-    if (newBody && newHeaders['Content-Type'] === 'application/json') {
-      newBody = JSON.stringify(newBody);
-    }
-    const isHead = method === 'head';
-    const hasEmptyResponse = method === 'delete' || isHead;
-    const newParse = hasEmptyResponse ? ApiRequester.successResponseParser : parse;
-
-    const fetchOptions = { ...this.fetchOptions || {} };
-    const extraHeaders = fetchOptions.headers || {};
-    delete fetchOptions.headers;
-
-    const options = {
-      method,
-      body: newBody,
-      headers: { ...this.getHeaders(headers), ...extraHeaders },
-      agent: this.agent,
-      ...fetchOptions,
-    };
+  displayName()         {
+    return this.profile ? `${this.profile.firstName} ${this.profile.lastName}` : '';
+  }
 
-    if (this.refreshTokenPromise) {
-      logger$1.info('A token is already refreshing, waiting ...', { url });
-      await this.refreshTokenPromise;
+  hasAccessToVoicemail()          {
+    if (!this.profile) {
+      return false;
     }
+    return !!this.profile.voicemail;
+  }
 
-    const start = new Date();
-
-    return realFetch()(url, options).then(response => {
-      const contentType = response.headers.get('content-type') || '';
-      const isJson = contentType.indexOf('application/json') !== -1;
-
-      IssueReporter$1.logRequest(url, options, response, start);
-
-      // Throw an error only if status >= 400
-      if ((isHead && response.status >= 500) || (!isHead && response.status >= 400)) {
-        const promise = isJson ? response.json() : response.text();
-        const exceptionClass = response.status >= 500 ? ServerError : BadResponse;
-
-        return promise.then(async (err        ) => {
-          // Check if the token is still valid
-          if (firstCall && this._checkTokenExpired(response, err)) {
-            logger$1.warn('token expired', { error: err.reason });
-            // Replay the call after refreshing the token
-            return this._replayWithNewToken(err, path, method, body, headers, parse);
-          }
+  primaryLine()        {
+    return this.profile && this.profile.lines.length > 0 ? this.profile.lines[0] : null;
+  }
 
-          const error = typeof err === 'string'
-            ? exceptionClass.fromText(err, response.status)
-            : exceptionClass.fromResponse(err, response.status);
+  primarySipLine()           {
+    return this.profile && this.profile.sipLines.length > 0 ? this.profile.sipLines[0] : null;
+  }
 
-          if (this.shouldLogErrors) {
-            logger$1.error('API error', error);
-          }
+  primaryWebRtcLine()           {
+    return this.profile && (this.profile.sipLines || []).find(sipLine => sipLine && sipLine.isWebRtc());
+  }
 
-          throw error;
-        });
-      }
+  primaryCtiLine()           {
+    return this.profile && (this.profile.sipLines || []).find(sipLine => sipLine && !sipLine.isWebRtc());
+  }
 
-      return newParse(response, isJson);
-    }).catch(error => {
-      if (this.shouldLogErrors) {
-        logger$1.error('Fetch failed', { url, options, message: error.message, stack: error.stack });
+  primaryContext()         {
+    if (this.engineVersion) {
+      if (this.hasEngineVersionGte(MINIMUM_WAZO_ENGINE_VERSION_FOR_DEFAULT_CONTEXT)) {
+        return 'default';
       }
+    }
 
-      throw error;
-    });
-  }
-
-  _checkTokenExpired(response        , err        ) {
-    // Special case when authenticating form a token: we got a 404
-    const isTokenNotFound = response.status === 404 && this._isTokenNotFound(err);
+    const line = this.primaryLine();
 
-    return response.status === 401 || isTokenNotFound;
+    return line && line.extensions.length > 0 ? line.extensions[0].context : 'default';
   }
 
-  _isTokenNotFound(err        ) {
-    return err && err.reason && err.reason[0] === 'No such token';
+  hasEngineVersionGte(version        ) {
+    return this.engineVersion && compareVersions(String(this.engineVersion), String(version)) >= 0;
   }
 
-  _replayWithNewToken(
-    err        ,
-    path        ,
-    method        ,
-    body          = null,
-    headers                    = null,
-    parse          ,
-  ) {
-    const isTokenNotFound = this._isTokenNotFound(err);
-    let newPath = path;
-    logger$1.info('refreshing token', { inProgress: !!this.refreshTokenPromise });
-
-    this.refreshTokenPromise = this.refreshTokenPromise || this.refreshTokenCallback();
+  primaryNumber()          {
+    const line = this.primaryLine();
 
-    return this.refreshTokenPromise.then(() => {
-      this.refreshTokenPromise = null;
-      logger$1.info('token refreshed', { isTokenNotFound });
-      if (isTokenNotFound) {
-        const pathParts = path.split('/');
-        pathParts.pop();
-        pathParts.push(this.token);
-        newPath = pathParts.join('/');
-      }
+    return line && line.extensions.length ? line.extensions[0].exten : null;
+  }
 
-      return this.call(newPath, method, body, headers, parse, false);
-    }).catch((e) => {
-      this.refreshTokenPromise = null;
-      throw e;
-    });
+  allLines()         {
+    return this.profile ? this.profile.lines || [] : [];
   }
 
-  getHeaders(header                  )         {
-    if (header instanceof Object) {
-      return header;
+  allNumbers()           {
+    const extensions = this.allLines().map(line => line.extensions.map(extension => extension.exten));
+    if (!extensions.length) {
+      return [];
     }
 
-    return {
-      'X-Auth-Token': this.token,
-      ...(this.tenant ? { 'Wazo-Tenant': this.tenant } : null),
-      Accept: 'application/json',
-      'Content-Type': 'application/json',
-    };
+    return extensions.reduce((a, b) => a.concat(b));
   }
 
-  computeUrl(method        , path        , body         )         {
-    const url = `${this.baseUrl}/${path}`;
-
-    return method === 'get' && body && Object.keys(body).length ? `${url}?${ApiRequester.getQueryString(body)}` : url;
+  hasExtension(extension        )          {
+    return this.allNumbers().some(number => number === extension);
   }
 
-  get baseUrl()         {
-    return `https://${this.server}/api`;
+  get acls()                 {
+    console.warn('`acls` property of Session has been removed in Wazo\'s SDK, please use `acl` instead.');
+    return this.acl;
   }
 }
 
@@ -2693,6 +2699,65 @@ class ExternalApp {
   }
 }
 
+//      
+
+                                       
+                                  
+                   
+               
+                             
+               
+               
+                
+ 
+
+class Meeting {
+               
+
+                                
+                   
+               
+               
+               
+                 
+                            
+
+  static parse(plain                         )          {
+    return new Meeting({
+      guestSipAuthorization: plain.guest_sip_authorization,
+      hostname: plain.hostname,
+      name: plain.name,
+      ownerUuids: plain.owner_uuids,
+      port: plain.port,
+      uuid: plain.uuid,
+      number: plain.number,
+    });
+  }
+
+  static newFrom(meeting         ) {
+    return newFrom(meeting, Meeting);
+  }
+
+  constructor({ uuid, name, guestSipAuthorization, ownerUuids, port, hostname, number }         = {}) {
+    this.guestSipAuthorization = guestSipAuthorization;
+    this.hostname = hostname;
+    this.name = name;
+    this.ownerUuids = ownerUuids;
+    this.port = port;
+    this.uuid = uuid;
+    this.number = number;
+
+    // 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 };
+  }
+}
+
 /*       */
 
 var confdMethods = (client              , baseUrl        ) => ({
@@ -2757,6 +2822,18 @@ var confdMethods = (client              , baseUrl        ) => ({
       return null;
     }
   },
+
+  createMyMeeting: (name        )                   =>
+    client.post(`${baseUrl}/users/me/meetings`, { name }).then(Meeting.parse),
+
+  deleteMyMeeting: (meetingUuid        )                   =>
+    client.delete(`${baseUrl}/users/me/meetings/${meetingUuid}`, null),
+
+  getMeeting: (meetingUuid        )                   =>
+    client.get(`${baseUrl}/meetings/${meetingUuid}`, null).then(Meeting.parse),
+
+  guestGetMeeting: (meetingUuid        )                   =>
+    client.get(`${baseUrl}/guests/me/meetings/${meetingUuid}`, null).then(Meeting.parse),
 });
 
 //      
@@ -3135,7 +3212,11 @@ class CallLog {
       answered: plain.answered,
       callDirection: plain.call_direction,
       destination: {
-        extension: plain.requested_extension || plain.destination_extension,
+        // @TEMP: Temporarily assuming empty numbers are meetings
+        // which is admittedly a very dangerous assumption. Did i mention it was temporary?
+        extension: plain.requested_extension
+          || plain.destination_extension
+          || `meeting-${plain.requested_name || plain.destination_name || ''}`,
         name: plain.requested_name || plain.destination_name || '',
       },
       source: {
@@ -3151,27 +3232,11 @@ class CallLog {
   }
 
   static parseNew(plain                 , session         )          {
-    return new CallLog({
-      answer: plain.answer ? moment(plain.answer).toDate() : null,
-      answered: plain.answered,
-      callDirection: plain.call_direction,
-      destination: {
-        extension: plain.requested_extension || plain.destination_extension,
-        name: plain.requested_name || plain.destination_name || '',
-      },
-      source: {
-        extension: plain.source_extension,
-        name: plain.source_name,
-      },
-      id: plain.id,
-      duration: (plain.duration || 0) * 1000, // duration is in seconds
-      start: moment(plain.start).toDate(),
-      end: plain.end ? moment(plain.end).toDate() : null,
-      recordings: Recording.parseMany(plain.recordings),
-      // @TODO: FIXME add verification declined vs missed call
-      newMissedCall: session
-        && session.hasExtension(plain.requested_extension || plain.destination_extension) && !plain.answered,
-    });
+    const callLog          = CallLog.parse(plain);
+    // @TODO: FIXME add verification declined vs missed call
+    callLog.newMissedCall = session
+      && session.hasExtension(plain.requested_extension || plain.destination_extension) && !plain.answered;
+    return callLog;
   }
 
   static newFrom(profile         ) {
@@ -3913,6 +3978,9 @@ var calldMethods = (client              , baseUrl        ) => ({
   getConferenceParticipantsAsUser: async (conferenceId        )                  =>
     client.get(`${baseUrl}/users/me/conferences/${conferenceId}/participants`),
 
+  getMeetingParticipantsAsUser: async (meetingUuid        )                  =>
+    client.get(`${baseUrl}/users/me/meetings/${meetingUuid}/participants`),
+
   listTrunks: () => client.get(`${baseUrl}/trunks`),
 
   mute: (callId        ) =>