const client = new WazoApiClient({
  server: 'demo.wazo.community', // required string
  agent: null // http(s).Agent instance, allows custom proxy, unsecured https, certificate etc.
});

client.auth.logIn({
  expiration, // optional integer. Session life in number of seconds. If omitted, defaults to 3600 (an hour).
  username, // required string
  password, // required string
  backend, // optional string. If omitted, defaults to wazo_user
  mobile, // optional boolean. If omitted, defaults to false: tells if the current user uses a mobile application
}).then(/* undefined if login failed, or : */{
  metadata: {
    username,
    uuid_tenant_uuid,
    xivo_user_uuid,
    groups,
    xivo_uuid,
    tenants: [{ uuid }],
    auth_id
  },
  token, // should be used for other request
  acls,
  utc_expires_at,
  xivo_uuid,
  issued_at,
  utc_issued_at,
  auth_id,
  expires_at,
  xivo_user_uuid
});
// or
const result = await client.auth.login(/* ... */);

client.auth.logOut(token).then(/* ... */);
// or
await client.auth.logOut(token);

client.auth.listTenants(token);
client.auth.createTenant(token, name);
client.auth.deleteTenant(token, uuid);
client.auth.createUser(token, username, password, firstname, lastname);
client.auth.addUserEmail(token, userUuid, email, main);
client.auth.addUserPolicy(token, userUuid, policyUuid);
client.auth.deleteUser(token);
client.auth.listUsers(token);
client.auth.listGroups(token);
client.auth.createPolicy(token, name);
client.auth.listPolicies(token);

client.application.calls(token, applicationUuid); // list calls
client.application.hangupCall(token, applicationUuid, callId); // hangup a call
client.application.answerCall(token, applicationUuid, callId, context, exten, autoanswer);  // answer a call
client.application.listNodes(token, applicationUuid); // list nodes
client.application.listCallsNodes(token, applicationUuid, nodeUuid); // list calls in a node
client.application.removeCallNodes(token, applicationUuid, nodeUuid, callId); // remove call from node (no hangup)
client.application.addCallNodes(token, applicationUuid, nodeUuid, callId); // add call in a node
client.application.playCall(token, applicationUuid, callId, language, uri); // play a sound into a call

client.confd.listUsers(token);
client.confd.getUser(token, userUuid);
client.confd.getUserLineSip(token, userUuid, lineId);
client.confd.listApplications(token);

client.dird.search(token, context, term);
client.dird.listPersonalContacts(token);
client.dird.addContact(token, newContact);
client.dird.editContact(token, contact);
client.dird.deleteContact(token, contactUuid);
client.dird.listFavorites(token, context);
client.dird.markAsFavorite(token, source, sourceId);
client.dird.removeFavorite(token, source, sourceId);

client.callLogd.search(token, search, limit);
client.callLogd.listCallLogs(token, offset, limit);
client.callLogd.listCallLogsFromDate(token, from, number);

client.ctidNg.updatePresence(token, presence);
client.ctidNg.listMessages(token, participantUuid, limit);
client.ctidNg.sendMessage(token, alias, msg, toUserId);
client.ctidNg.makeCall(token, extension, fromMobile, lineId);
client.ctidNg.cancelCall(token, callId);
client.ctidNg.listCalls(token);
client.ctidNg.relocateCall(token, callId, destination, lineId);
client.ctidNg.listVoicemails(token);
client.ctidNg.deleteVoicemail(token, voicemailId);
client.ctidNg.getPresence(token, contactUuid};
client.ctidNg.getStatus(token, lineUuid);

client.accessd.listSubscriptions(token);
client.accessd.createSubscription(token, { productSku, name, startDate, contractDate, autoRenew, term });
client.accessd.getSubscription(token, uuid);
client.accessd.listAuthorizations(token);
client.accessd.getAuthorization(token, uuid);

import { WazoWebRTCClient } from '@wazo/sdk';

const phone = new WazoWebRTCClient({
  displayName: 'From WEB',
  host: 'demo.wazo.community',
  authorizationUser: lineData.username,
  password: lineData.secret,
  media: {
    audio: boolean,
    video: boolean | document.getElementById('video'), // pointing to a `<video id="video" />` element
    localVideo: boolean | document.getElementById('video'), // pointing to a `<video id="video" />` element
  }
});
// eventName can be on the of events : 
// - transport: `connected`, `disconnected`, `transportError`, `message`, `closed`, `keepAliveDebounceTimeout`
// - webrtc: `registered`, `unregistered`, `registrationFailed`, `invite`, `inviteSent`, `transportCreated`, `newTransaction`, `transactionDestroyed`, `notify`, `outOfDialogReferRequested`, `message`.
phone.on('invite', (session: SIP.sessionDescriptionHandler, hasVideo: boolean, shouldAutoAnswer: boolean) => {
  this.currentSession = session;
  // ...
});

phone.call('1234');

phone.call(number: string);

phone.on('invite', (session: SIP.sessionDescriptionHandler) => {
  this.currentSession = session;
});

phone.answer(session: SIP.sessionDescriptionHandler);

phone.hangup(session: SIP.sessionDescriptionHandler);

phone.reject(session: SIP.sessionDescriptionHandler);

phone.mute(session: SIP.sessionDescriptionHandler);

phone.unmute(session: SIP.sessionDescriptionHandler);

phone.hold(session: SIP.sessionDescriptionHandler);

phone.unhold(session: SIP.sessionDescriptionHandler);

phone.transfert(session: SIP.sessionDescriptionHandler, target: string);

phone.sendDTMF(session: SIP.sessionDescriptionHandler, tone: string);

phone.message(message: string, destination: string);

phone.close();

phone.merge(sessions: Array<SIP.InviteClientContext>);

phone.addToMerge(session: SIP.InviteClientContext);

phone.removeFromMerge(session: SIP.InviteClientContext, shouldHold: boolean);
// shouldHold indicate if the session should be held after removed from session

phone.unmerge(sessions: Array<SIP.InviteClientContext>)

import { WazoWebSocketClient } from '@wazo/sdk';

const ws = new WazoWebSocket({
  host, // wazo websocket host
  token, // valid Wazo token
});

// eventName can be on the of events here: http://documentation.wazo.community/en/stable/api_sdk/websocket.html
ws.on('eventName', (data: mixed) => {
});

ws.connect();

ws.close();