// For Node / packaged app
import Wazo from '@wazo/sdk';

// Browser
// You can access the `Wazo` object directly on the browser, simply include it in the html :
<script src="https://unpkg.com/@wazo/sdk/dist/wazo-sdk.js"></script>
or 
<script src="https://cdn.jsdelivr.net/npm/@wazo/sdk"></script>

Wazo.Auth.init(clientId, tokenExpiration, minSubscriptionType, authorizationName);

Wazo.Auth.setHost(host);

Wazo.Auth.fetchOptions({
  referrer: '',
});

const session = await Wazo.Auth.logIn(username, password, backend, tenantId);

const session = await Wazo.Auth.validateToken(token, refreshToken);

Wazo.Auth.setOnRefreshToken(token => { /* Do something with the new token */ });

await Wazo.Auth.logout();

Wazo.Room.connect(options);

room.sendChat(content);

room.sendSignal(content);

room.startScreenSharing(constraints);

room.stopScreenSharing();

room.turnCameraOff();

room.turnCameraOn();

room.mute();

room.unmute();

room.participants;

Wazo.room.disconnect();

room.on(room.ON_CHAT, (message) => {});

room.on(room.ON_MESSAGE, (message) => {});

room.on(room.ON_JOINED, (participant) => {});

room.on(room.CONFERENCE_USER_PARTICIPANT_JOINED, (participant) => {});

room.on(room.CONFERENCE_USER_PARTICIPANT_LEFT, (participant) => {});

room.on(room.ON_SCREEN_SHARE_ENDED, () => {});

room.on(room.ON_TALKING, (channel, participant) => {});

const adHocConference = Wazo.Phone.startConference(host: CallSession, otherCalls: CallSession[]): Promise<AdHocAPIConference>;

adHocConference.addParticipant(participant: CallSession);

adHocConference.removeParticipant(callSession: CallSession);
// shouldHold indicate if the session should be held after removed from session

adHocConference.hangup();

participant.on(participant.ON_UPDATED, () => {});

participant.on(participant.ON_START_TALKING, () => {});

participant.on(participant.ON_STOP_TALKING, () => {});

participant.on(participant.ON_DISCONNECT, () => {});

participant.on(participant.ON_STREAM_SUBSCRIBED, (stream) => {});

participant.on(participant.ON_STREAM_UNSUBSCRIBED, (stream) => {});

participant.on(participant.ON_AUDIO_MUTED, () => {});

participant.on(participant.ON_AUDIO_UNMUTED, () => {});

participant.on(participant.ON_VIDEO_MUTED, () => {});

participant.on(participant.ON_VIDEO_UNMUTED, () => {});

participant.on(participant.ON_SCREENSHARING, () => {});

participant.on(participant.ON_STOP_SCREENSHARING, () => {});

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

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

const client = new WazoApiClient({
  server: 'stack.example.com', // required string
  agent: null, // http(s).Agent instance, allows custom proxy, unsecured https, certificate etc.
  clientId: null, // Set an identifier for your app when using refreshToken
  isMobile: false,
});

const session = await client.auth.logIn({ ... });

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
  tenantId, // optional string. The tenant identifier (uuid or slug). Needed when backend is external (not wazo_user)
}).then(/* undefined if login failed, or : */{
  metadata: {
    username,
    uuid_tenant_uuid,
    xivo_user_uuid,
    groups,
    xivo_uuid,
    tenants: [{ uuid }],
    auth_id
  },
  // should be used for other request
  acl,
  utc_expires_at,
  xivo_uuid,
  issued_at,
  utc_issued_at,
  auth_id,
  expires_at,
  xivo_user_uuid
});
// or
const { refreshToken, ...result } = await client.auth.logIn(/* ... */);

client.setToken(token);
client.setRefreshToken(refreshToken);
client.setRefreshTokenExpiration(tokenExpirationInSeconds);

client.setOnRefreshToken((newToken, newSession) => {
  // Do something with the new token and the new session (like storing them in the localstorage...).
});

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

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

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

client.calld.getConferenceParticipantsAsUser(conferenceId); // List participants of a conference the user is part of
client.calld.answerSwitchboardQueuedCall(switchboardUuid, callId);
client.calld.answerSwitchboardHeldCall(switchboardUuid, callId);
client.calld.cancelCall(callId);
client.calld.deleteVoicemail(voicemailId);
client.calld.fetchSwitchboardHeldCalls(switchboardUuid);
client.calld.fetchSwitchboardQueuedCalls(switchboardUuid);
client.calld.getConferenceParticipantsAsUser(conferenceId);
client.calld.getPresence(contactUuid); //deprecated use chatd in ctidNg, don't work with calld
client.calld.getStatus(lineUuid); //deprecated use chatd in ctidNg, don't work with calld
client.calld.holdSwitchboardCall(switchboardUuid, callId);
client.calld.listCalls();
client.calld.listMessages(participantUuid, limit);
client.calld.listVoicemails();
client.calld.makeCall(extension, fromMobile, lineId, allLines);
client.calld.sendFax(extension, fax, callerId);
client.calld.sendMessage(alias, msg, toUserId);
client.calld.relocateCall(callId, destination, lineId);
client.calld.updatePresence(presence);

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

client.dird.search(context: string, term: string, offset: number, limit: number);
client.dird.listPersonalContacts();
client.dird.addContact(newContact: NewContact);
client.dird.editContact(contact: Contact);
client.dird.deleteContact(contactUuid: UUID);
client.dird.listFavorites(context: string);
client.dird.markAsFavorite(source: string, sourceId: string);
client.dird.removeFavorite(source: string, sourceId: string);

client.agentd.getAgent(agentNumber);
client.agentd.login(agentNumber, context, extension);
client.agentd.logout(agentNumber);
client.agentd.pause(agentNumber);
client.agentd.resume(agentNumber);

client.agentd.loginWithLineId(lineId);

client.agentd.getStatus();
client.agentd.staticLogout();
client.agentd.staticPause();
client.agentd.staticResume();

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

client.chatd.getContactStatusInfo(contactUuid: UUID);
client.chatd.getState(contactUuid: UUID);
client.chatd.getLineState(contactUuid: UUID);
client.chatd.getMultipleLineState(contactUuids: ?Array<UUID>);
client.chatd.getUserRooms();
client.chatd.updateState(contactUuid: UUID, state: string);
client.chatd.updateStatus(contactUuid: UUID, state: string, status: string);
client.chatd.createRoom(name: string, users: Array<ChatUser>);
client.chatd.getRoomMessages(roomUuid: string);
client.chatd.sendRoomMessage(roomUuid: string, message: ChatMessage);
client.chatd.getMessages(options: GetMessagesOptions);

const requester = new ApiRequester({ 
  server: 'stack.example.com', // Engine server
  refreshTokenCallback: () => {}, // Called when the token is refreshed
  clientId: 'my-id', // ClientId used for refreshToken
  agent: null, // http(s).Agent instance, allows custom proxy, unsecured https, certificate etc.
  token: null, // User token (can be defined later with requester.setToken()
});

// Retrieve personal contacts
const results = await requester.call('dird/0.1/personal');

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

const session = await client.auth.logIn({ ... }); // log in

const client = new WazoWebRTCClient({
  displayName: 'From WEB',
  host: 'stack.example.com',
  websocketSip: 'other.url.com', // Allows to connect throught another URL than host (default to `host` is not set).
  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
  }
}, session);

// 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`.
client.on('invite', (sipSession: SipSession, hasVideo: boolean, shouldAutoAnswer: boolean) => {
  this.currentSipSession = sipSession;
  // ...
});

// We have to wait to be registered to be able to make a call
await client.waitForRegister();

client.call('1234');

const config = {
  displayName: '', // Display name sent in SIP payload
  host: '', // Host where to connect
  port: '', // Port of the host (default to `443`)
  media: {
    audio: boolean, // If we want to send audio
    video: boolean | document.getElementById('video'), // pointing to a `<video id="video" />` element
    localVideo: boolean | document.getElementById('video'), // pointing to a `<video id="video" />` element
  },
  iceCheckingTimeout: 1000, // Time allowed to retrieve ice candidates
  log: {}, // @see https://sipjs.com/api/0.5.0/ua_configuration_parameters/#log
  audioOutputDeviceId: null, // The audio output device id (when we want to send audio in another destination).
  userAgentString: null, // Customize the User-Agent SIP header
  heartbeatDelay: 1000, // Duration in ms between 2 heartbeat (default to 2000)
  heartbeatTimeout: 5000, // Duration in ms when to consider that the Asterisk server is not responding (default to 5000)
  maxHeartbeats: 4, // Number of heatbeat send each time we want to check connection (default to 3)
  
  // When not passing session as second argument:
  authorizationUser: '', // The SIP username
  password: '', // The SIP user password
  uri: '', // The SIP user identity
}

const uaConfigOverrides = {
  peerConnectionOptions: {
    iceServers = [
      {urls: "stun:stun.example.com:443"},  // STUN server
      {urls: "turn:turn.example.com:443", username: "login", credential: "secret" },  // TURN server
      ...
    ]
  }
}

const client = new WazoWebRTCClient(config, session, /* optional */ uaConfigOverrides);

client.call(number: string);

client.on('invite', (sipSession: SipSession) => {
  this.currentSipSession = sipSession;
});

client.answer(sipSession: SipSession);

client.hangup(sipSession: SipSession);

client.reject(sipSession: SipSession);

client.mute(sipSession: SipSession);

client.unmute(sipSession: SipSession);

client.hold(sipSession: SipSession);

client.unhold(sipSession: SipSession);

client.transfer(sipSession: SipSession, target: string);

transfer = client.atxfer(sipSession: SipSession);

// Start the transfer to a phone number, starts a new SIP session in the process
transfer.init(target: string)

// Get the new SIP session to the target of the transfer
targetSession = transfer.newSession

// Complete the transfer.
// transfer.init(...) must be called first.
transfer.complete()

// Cancel the transfer.
// transfer.init(...) must be called first.
transfer.cancel()

client.sendDTMF(sipSession: SipSession, tone: string);

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

phone.changeAudioOutputVolume(volume: number);

phone.changeAudioRingVolume(volume: number);

client.close();

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

const webRtcClient = new WazoWebRTCClient({/* See above for parameters */});

const phone = new WebRTCPhone(
  webRtcClient: WazoWebRTCClient, // Instance of WazoWebRTCClient
  audioDeviceOutput: string, // The output device used to play audio
  allowVideo: boolean, // Allow to send and receive video
  audioDeviceRing, // The output device used to play ringtones
);

const callSession = await phone.makeCall(
  number: string, // The number to dial
  line: // Not used
  enableVideo: boolean // Optional (default to false) when we want to make a video call 
);

phone.hangup(
  callSession: CallSession, // The callSession to stop
);

phone.accept(
  callSession: CallSession, // The callSession to accept
  cameraEnabled?: boolean // Should we accept the call with video
);

phone.reject(
  callSession: CallSession // The callSession to reject
);

phone.hold(
  callSession: CallSession, // The call session to put on hold
  withEvent: boolean = true // Should the phone triggers event
);

phone.resume(callSession: CallSession);

phone.unhold(callSession: CallSession); // deprecated

phone.mute(
  callSession: CallSession, // The call session to mute
  withEvent: boolean = true // Should the phone triggers event
);

phone.unmute(callSession: CallSession);

phone.turnCameraOff(callSession: CallSession);

phone.turnCameraOn(callSession: CallSession);

phone.sendKey(callSession: CallSession, tone: string);

phone.transfer(
  callSession: CallSession, // The call session to transfer
  target: string // The extension where to transfer to call
);

phone.indirectTransfer(
  callSession: CallSession, // The call session to transfer
  target: string // The extension where to transfer to call
);

const screenShareStream: MediaStream = await phone.startScreenSharing({ 
  audio: true, 
  video: true, 
  /* See webRtc media constraints */ 
});

phone.stopScreenSharing();

phone.startConference(participants: CallSession[]);

phone.addToConference(participant: CallSession);

phone.holdConference(participants: CallSession[]);

phone.resumeConference(participants: CallSession[]);

phone.muteConference(participants: CallSession[]);

phone.unmuteConference(participants: CallSession[]);

phone.removeFromConference(participants: CallSession[]);

phone.hangupConference(participants: CallSession[]);

phone.register();

phone.isRegistered();

phone.unregister();

phone.changeAudioDevice(someDevice: string);

phone.changeRingDevice(someDevice: string);

phone.changeAudioInputDevice(someDevice: string, session: ?Inviter, force: ?boolean);

phone.changeVideoInputDevice(someDevice: string);

phone.hasAnActiveCall(): boolean;

phone.callCount(): number;

phone.sendMessage(
  sipSession: SipSession = null, The sip session where to send to message
  body: string, // The message to SEND
);

phone.stop();

phone.startHeartbeat();

phone.stopHeartbeat();

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

const ws = new WebSocketClient({
  host: '', // wazo websocket host
  token: '', // valid Wazo token
  events: [''], // List of events you want to receive (use `['*']` as wildcard).
  version: 2, // Use version 2 of the Wazo WebSocket protocol to be informed when the token will expire.
}, {
  // see https://github.com/pladaria/reconnecting-websocket#available-options
});

ws.connect();

import { USERS_SERVICES_DND_UPDATED, AUTH_SESSION_EXPIRE_SOON } from '@wazo/sdk/lib/websocket-client';

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

ws.on(USERS_SERVICES_DND_UPDATED, ({ enabled }) => {
  // Do something with the new do not disturb value.
});

ws.on(AUTH_SESSION_EXPIRE_SOON, (data) => {
  // Called when the user's token will expire soon.
  // You should refresh it at this point (eg: by using a refreshToken).
});

ws.updateToken(newToken: string);

ws.close();

const webpack = require('webpack');
module.exports = function override(config, env) {
  config.resolve.fallback = {
    ...config.resolve.fallback,
    assert: require.resolve("assert"),
    buffer: require.resolve('buffer'),
    https: require.resolve('https-browserify'),
    url: require.resolve('url'),
    http: require.resolve('stream-http'),
    stream: require.resolve('stream-browserify'),
    zlib: require.resolve('browserify-zlib'),
  };

  config.plugins.push(
    new webpack.ProvidePlugin({
      process: 'process/browser',
      Buffer: ['buffer', 'Buffer'],
    }),
  );

  config.module.rules.push({
    test: /\.m?js/,
    resolve: {
      fullySpecified: false
    }
  })

  return config;
}