@wazo/sdk 0.38.7 → 0.38.10

package/src/api/calld.js

@@ -137,6 +137,14 @@ export default (client: ApiRequester, baseUrl: string) => ({
   getMeetingParticipantsAsUser: async (meetingUuid: string): Promise<Object> =>
     client.get(`${baseUrl}/users/me/meetings/${meetingUuid}/participants`),
 
+  banMeetingParticipant: (meetingUuid: string, participantUuid: string) =>
+    client.delete(
+      `${baseUrl}/users/me/meetings/${meetingUuid}/participants/${participantUuid}`,
+      null,
+      null,
+      ApiRequester.successResponseParser,
+    ),
+
   listTrunks: () => client.get(`${baseUrl}/trunks`),
 
   mute: (callId: string) =>

package/src/api/confd.js

@@ -1,10 +1,13 @@
 /* @flow */
 import ApiRequester from '../utils/api-requester';
 import type { UUID, ListConfdUsersResponse, ListApplicationsResponse } from '../domain/types';
+import type { MeetingCreateArguments, MeetingUpdateArguments } from '../domain/Meeting';
 import Profile from '../domain/Profile';
 import SipLine from '../domain/SipLine';
 import ExternalApp from '../domain/ExternalApp';
 import Meeting from '../domain/Meeting';
+import MeetingAuthorization from '../domain/MeetingAuthorization';
+import { convertKeysFromCamelToUnderscore } from '../utils/object';
 
 export default (client: ApiRequester, baseUrl: string) => ({
   listUsers: (): Promise<ListConfdUsersResponse> => client.get(`${baseUrl}/users`, null),
@@ -72,8 +75,18 @@ export default (client: ApiRequester, baseUrl: string) => ({
   getMyMeetings: (): Promise<Meeting> =>
     client.get(`${baseUrl}/users/me/meetings`).then(response => Meeting.parseMany(response.items)),
 
-  createMyMeeting: (name: string, persistent: boolean): Promise<Meeting> =>
-    client.post(`${baseUrl}/users/me/meetings`, { name, persistent }).then(Meeting.parse),
+  createMyMeeting: (args: MeetingCreateArguments): Promise<Meeting> =>
+    client
+      .post(`${baseUrl}/users/me/meetings`, convertKeysFromCamelToUnderscore(args))
+      .then(Meeting.parse),
+
+  updateMyMeeting: (meetingUuid: string, data: MeetingUpdateArguments): Promise<Boolean> =>
+    client.put(
+      `${baseUrl}/users/me/meetings/${meetingUuid}`,
+      convertKeysFromCamelToUnderscore(data),
+      null,
+      ApiRequester.successResponseParser,
+    ),
 
   deleteMyMeeting: (meetingUuid: string): Promise<Meeting> =>
     client.delete(`${baseUrl}/users/me/meetings/${meetingUuid}`, null),
@@ -81,6 +94,34 @@ export default (client: ApiRequester, baseUrl: string) => ({
   getMeeting: (meetingUuid: string): Promise<Meeting> =>
     client.get(`${baseUrl}/meetings/${meetingUuid}`, null).then(Meeting.parse),
 
+  meetingAuthorizations: (meetingUuid: string): Promise<Array<MeetingAuthorization>> =>
+    client.get(`${baseUrl}/users/me/meetings/${meetingUuid}/authorizations`, null).then(MeetingAuthorization.parseMany),
+
+  meetingAuthorizationReject: (meetingUuid: string, authorizationUuid: string): Promise<Boolean> =>
+    client.put(
+      `${baseUrl}/users/me/meetings/${meetingUuid}/authorizations/${authorizationUuid}/reject`,
+      {},
+      null,
+      ApiRequester.successResponseParser,
+    ),
+
+  meetingAuthorizationAccept: (meetingUuid: string, authorizationUuid: string): Promise<Boolean> =>
+    client.put(
+      `${baseUrl}/users/me/meetings/${meetingUuid}/authorizations/${authorizationUuid}/accept`,
+      {},
+      null,
+      ApiRequester.successResponseParser,
+    ),
+
   guestGetMeeting: (meetingUuid: string): Promise<Meeting> =>
     client.get(`${baseUrl}/guests/me/meetings/${meetingUuid}`, null).then(Meeting.parse),
+
+  guestAuthorizationRequest: (userUuid: string, meetingUuid: string, username: string): Promise<> =>
+    client
+      .post(`${baseUrl}/guests/${userUuid}/meetings/${meetingUuid}/authorizations`, { guest_name: username })
+      .then(MeetingAuthorization.parse),
+
+  guestAuthorizationCheck: (userUuid: string, meetingUuid: string, authorizationUuid: string): Promise<> =>
+    client.get(`${baseUrl}/guests/${userUuid}/meetings/${meetingUuid}/authorizations/${authorizationUuid}`, null),
+
 });

package/src/api-client.js

@@ -57,6 +57,7 @@ export default class ApiClient {
   refreshExpiration: ?number;
   refreshBackend: ?string;
   refreshTenantId: ?string;
+  refreshDomainName: ?string;
   isMobile: boolean;
   fetchOptions: Object;
 
@@ -98,6 +99,7 @@ export default class ApiClient {
       refreshToken: this.refreshToken,
       refreshBackend: this.refreshBackend,
       refreshTenantId: this.refreshTenantId,
+      refreshDomainName: this.refreshDomainName,
       refreshExpiration: this.refreshExpiration,
       isMobile: this.isMobile,
     });
@@ -113,6 +115,7 @@ export default class ApiClient {
         this.refreshExpiration,
         this.isMobile,
         this.refreshTenantId,
+        this.refreshDomainName,
       );
 
       logger.info('token refreshed', { token: session.token });
@@ -166,9 +169,14 @@ export default class ApiClient {
   }
 
   setRefreshTenantId(tenantId: ?string) {
+    console.warn('Use of `setRefreshTenantId` is deprecated, use `setRefreshDomainName` instead');
     this.refreshTenantId = tenantId;
   }
 
+  setRefreshDomainName(domainName: ?string) {
+    this.refreshDomainName = domainName;
+  }
+
   setIsMobile(isMobile: boolean) {
     this.isMobile = isMobile;
   }

package/src/domain/Meeting.js

@@ -3,6 +3,19 @@ import moment from 'moment';
 
 import newFrom from '../utils/new-from';
 
+import MeetingAuthorization from './MeetingAuthorization';
+
+export type MeetingCreateArguments = {
+  name: string,
+  requireAuthorization: boolean,
+  persistent: boolean,
+}
+
+export type MeetingUpdateArguments = {
+  name?: string,
+  requireAuthorization?: boolean,
+}
+
 export type MeetingCreationResponse = {
   guest_sip_authorization: string,
   ingress_http_uri: string,
@@ -13,6 +26,7 @@ export type MeetingCreationResponse = {
   exten: string,
   persistent: boolean,
   creation_time: string,
+  require_authorization: boolean,
 }
 
 export default class Meeting {
@@ -27,6 +41,8 @@ export default class Meeting {
   persistent: boolean;
   ownerUuids: Array<string>;
   creationTime: Date;
+  pendingAuthorizations: Array<MeetingAuthorization>
+  requireAuthorization: boolean;
 
   static parse(plain: MeetingCreationResponse): Meeting {
     return new Meeting({
@@ -39,6 +55,7 @@ export default class Meeting {
       extension: plain.exten,
       persistent: plain.persistent,
       creationTime: moment(plain.creation_time).toDate(),
+      requireAuthorization: plain.require_authorization,
     });
   }
 
@@ -63,6 +80,7 @@ export default class Meeting {
     extension,
     persistent,
     creationTime,
+    requireAuthorization,
   }: Object = {}) {
     this.guestSipAuthorization = guestSipAuthorization;
     this.uri = uri;
@@ -73,6 +91,7 @@ export default class Meeting {
     this.extension = extension;
     this.persistent = persistent;
     this.creationTime = creationTime;
+    this.requireAuthorization = requireAuthorization;
 
     // Useful to compare instead of instanceof with minified code
     this.type = 'Meeting';
@@ -83,4 +102,5 @@ export default class Meeting {
     const [username, secret] = atob(this.guestSipAuthorization).split(':');
     return { username, secret };
   }
+
 }

package/src/domain/MeetingAuthorization.js

@@ -0,0 +1,67 @@
+// @flow
+
+export type RawMeetingAuthorization = {
+  created_at: string,
+  meeting_uuid: string,
+  uuid: string,
+  guest_uuid: string,
+  guest_name: string,
+}
+
+export const PENDING = 'pending';
+export const ACCEPTED = 'accepted';
+export const REJECTED = 'rejected';
+export const POST_PROCESSING = 'post_processing';
+export const POST_PROCESSED_SUCCESS = 'post_processed_success';
+export const POST_PROCESSED_ERROR = 'post_processed_error';
+
+export default class MeetingAuthorization {
+  meetingUuid: string;
+  uuid: string;
+  userUuid: string;
+  userName: string;
+  status: string;
+
+  constructor({
+    meetingUuid,
+    uuid,
+    userUuid,
+    userName,
+  }: Object = {}) {
+    this.meetingUuid = meetingUuid;
+    this.uuid = uuid;
+    this.userUuid = userUuid;
+    this.userName = userName;
+  }
+
+  setStatus(status: string) {
+    this.status = status;
+  }
+
+  getStatus() {
+    return this.status;
+  }
+
+  static parse(plain: RawMeetingAuthorization) {
+    const {
+      meeting_uuid: meetingUuid,
+      uuid,
+      guest_uuid: userUuid,
+      guest_name: userName,
+    } = plain;
+
+    return new MeetingAuthorization({
+      meetingUuid,
+      uuid,
+      userUuid,
+      userName,
+    });
+  }
+
+  static parseMany(items: RawMeetingAuthorization[]): Array<MeetingAuthorization> {
+    if (!items) {
+      return [];
+    }
+    return items.map(MeetingAuthorization.parse);
+  }
+}

package/src/domain/Phone/WebRTCPhone.js

@@ -531,9 +531,7 @@ export default class WebRTCPhone extends Emitter implements Phone {
 
     try {
       if (this.currentScreenShare.stream) {
-        this.currentScreenShare.stream.getTracks()
-          .filter(track => track.kind === 'video')
-          .forEach(track => track.stop());
+        this.currentScreenShare.stream.getTracks().forEach(track => track.stop());
       }
 
       if (restoreLocalStream) {

package/src/domain/__tests__/Meeting.test.js

@@ -1,9 +1,76 @@
 // @flow
 /* global btoa */
 
+import moment from 'moment';
 import Meeting from '../Meeting';
 
+const rawCreationTime = '2021-12-21T15:56:42.880Z';
+
 describe('Meeting domain', () => {
+  it('should retain its values when parsed', () => {
+    const args = {
+      guest_sip_authorization: 'some-guest-sip-authorization',
+      ingress_http_uri: 'some-uri',
+      name: 'some-name',
+      owner_uuids: ['some-owner-uuid'],
+      port: 'some-port',
+      uuid: 'some-uuid',
+      exten: 'some-exten',
+      persistent: true,
+      creation_time: rawCreationTime,
+      require_authorization: true,
+    };
+
+    const meeting = Meeting.parse(args);
+    const {
+      uri,
+      uuid,
+      name,
+      port,
+      extension,
+      persistent,
+      ownerUuids,
+      creationTime,
+      requireAuthorization,
+    } = meeting;
+
+    expect(uri).toEqual(args.ingress_http_uri);
+    expect(uuid).toEqual(args.uuid);
+    expect(name).toEqual(args.name);
+    expect(port).toEqual(args.port);
+    expect(extension).toEqual(args.exten);
+    expect(persistent).toEqual(args.persistent);
+    expect(ownerUuids).toEqual(args.owner_uuids);
+    expect(creationTime).toEqual(moment(rawCreationTime).toDate());
+    expect(requireAuthorization).toEqual(args.require_authorization);
+  });
+
+  it('should retain its values when instantiated', () => {
+    const keys = [
+      'uuid',
+      'name',
+      'guestSipAuthorization',
+      'ownerUuids',
+      'port',
+      'uri',
+      'extension',
+      'persistent',
+      'creationTime',
+      'requireAuthorization',
+    ];
+
+    const args = keys.reduce((acc, key) => {
+      acc[key] = `some-${key}`;
+      return acc;
+    }, {});
+
+    const meeting = new Meeting(args);
+
+    keys.forEach(key =>
+      // $FlowFixMe
+      expect(meeting[key]).toEqual(`some-${key}`));
+  });
+
   it('can return username and secret from an base64 encrypted string', () => {
     const USERNAME = 'username';
     const SECRET = 'secret';
@@ -18,6 +85,7 @@ describe('Meeting domain', () => {
       uuid: '',
       exten: '',
       persistent: false,
+      require_authorization: false,
     };
 
     const meeting = Meeting.parse(args);
@@ -30,7 +98,7 @@ describe('Meeting domain', () => {
 
   it('should return a date from a string', () => {
     const args = {
-      creation_time: '2021-12-21T15:56:42.880Z',
+      creation_time: rawCreationTime,
       guest_sip_authorization: '',
       ingress_http_uri: '',
       name: '',
@@ -39,6 +107,7 @@ describe('Meeting domain', () => {
       uuid: '',
       exten: '',
       persistent: false,
+      require_authorization: false,
     };
 
     const { creationTime } = Meeting.parse(args);

package/src/domain/__tests__/MeetingAuthorization.test.js

@@ -0,0 +1,58 @@
+import MeetingAuthorization from '../MeetingAuthorization';
+
+describe('MeetingAuthorization', () => {
+  describe('parse', () => {
+    it('should parse a raw input', () => {
+      const rawAuthorization = {
+        created_at: 'today',
+        meeting_uuid: 'meeting_uuid',
+        uuid: 'uuid',
+        guest_uuid: 'guest_uuid',
+        guest_name: 'guest_name',
+      };
+
+      const authorization = {
+        meetingUuid: rawAuthorization.meeting_uuid,
+        uuid: rawAuthorization.uuid,
+        userUuid: rawAuthorization.guest_uuid,
+        userName: rawAuthorization.guest_name,
+        status: undefined,
+      };
+
+      const response = MeetingAuthorization.parse(rawAuthorization);
+      expect(response).toEqual(authorization);
+    });
+  });
+
+  describe('parseMany', () => {
+    it('should parse multiple raw inputs', () => {
+      const rawAuthorizations = [
+        {
+          created_at: 'today1',
+          meeting_uuid: 'meeting_uuid1',
+          uuid: 'uuid1',
+          guest_uuid: 'guest_uuid1',
+          guest_name: 'guest_name1',
+        },
+        {
+          created_at: 'today2',
+          meeting_uuid: 'meeting_uuid2',
+          uuid: 'uuid2',
+          guest_uuid: 'guest_uuid2',
+          guest_name: 'guest_name2',
+        },
+      ];
+
+      const authorizations = rawAuthorizations.map(rawAuthorization => ({
+        meetingUuid: rawAuthorization.meeting_uuid,
+        uuid: rawAuthorization.uuid,
+        userUuid: rawAuthorization.guest_uuid,
+        userName: rawAuthorization.guest_name,
+        status: undefined,
+      }));
+
+      const response = MeetingAuthorization.parseMany(rawAuthorizations);
+      expect(response).toEqual(authorizations);
+    });
+  });
+});

package/src/service/getApiClient.js

@@ -11,6 +11,7 @@ global.wazoClientId = global.wazoClientId || {};
 global.wazoClientToken = global.wazoClientToken || {};
 global.wazoRefreshToken = global.wazoRefreshToken || {};
 global.wazoRefreshTenantId = global.wazoRefreshTenantId || {};
+global.wazoRefreshDomainName = global.wazoRefreshDomainName || {};
 global.wazoOnRefreshToken = global.wazoOnRefreshToken || {};
 global.wazoOnRefreshTokenError = global.wazoOnRefreshTokenError || {};
 global.wazoRefreshExpiration = global.wazoRefreshExpiration || {};
@@ -35,9 +36,14 @@ export const setRefreshToken = (newRefreshToken: ?string, forServer: ?string = n
 };
 
 export const setRefreshTenantId = (refreshTenantId: ?string, forServer: ?string = null) => {
+  console.warn('Use of `setRefreshTenantId` is deprecated, please use `setRefreshDomainName` instead');
   global.wazoRefreshTenantId[forServer] = refreshTenantId;
 };
 
+export const setRefreshDomainName = (refreshDomainName: ?string, forServer: ?string = null) => {
+  global.wazoRefreshDomainName[forServer] = refreshDomainName;
+};
+
 export const setOnRefreshToken = (onRefreshToken: Function, forServer: ?string = null) => {
   global.wazoOnRefreshToken[forServer] = onRefreshToken;
 };
@@ -64,6 +70,7 @@ export const setFetchOptions = (fetchOptions: Object, forServer: ?string = null)
 
 const fillClient = (apiClient: WazoApiClient) => {
   const { server, token, clientId } = apiClient.client;
+  const tenantId = global.wazoRefreshTenantId[server] || global.wazoRefreshTenantId[null] || apiClient.refreshTenantId;
 
   //  try with null server when dealing with non-related server info
   apiClient.setToken(global.wazoClientToken[server] || global.wazoClientToken[null] || token);
@@ -72,8 +79,12 @@ const fillClient = (apiClient: WazoApiClient) => {
 
   apiClient.setRefreshToken(global.wazoRefreshToken[server] || global.wazoRefreshToken[null] || apiClient.refreshToken);
 
-  apiClient.setRefreshTenantId(
-    global.wazoRefreshTenantId[server] || global.wazoRefreshTenantId[null] || apiClient.refreshTenantId,
+  if (tenantId) {
+    apiClient.setRefreshTenantId(tenantId);
+  }
+
+  apiClient.setRefreshDomainName(
+    global.wazoRefreshDomainName[server] || global.wazoRefreshDomainName[null] || apiClient.refreshDomainName,
   );
 
   apiClient.setFetchOptions(global.wazoFetchOptions[server] || global.wazoFetchOptions[null] || apiClient.fetchOptions);

package/src/simple/Auth.js

@@ -11,6 +11,7 @@ import getApiClient, {
   setOnRefreshToken,
   setFetchOptions,
   setRefreshTenantId,
+  setRefreshDomainName,
   setOnRefreshTokenError,
 } from '../service/getApiClient';
 import IssueReporter from '../service/IssueReporter';
@@ -20,6 +21,7 @@ import Wazo from './index';
 export class InvalidSubscription extends Error {}
 export class InvalidAuthorization extends Error {}
 export class NoTenantIdError extends Error {}
+export class NoDomainNameError extends Error {}
 
 const logger = IssueReporter.loggerFor('simple-auth');
 
@@ -83,9 +85,24 @@ class Auth {
     setFetchOptions(options);
   }
 
-  async logIn(username: string, password: string, backend?: string, tenantId?: string) {
-    if (backend && backend !== this.BACKEND_WAZO && !tenantId) {
-      throw new NoTenantIdError('No tenant id');
+  async logIn(username: string, password: string, backend?: string, extra?: string | Object) {
+    let tenantId = null;
+    let domainName = null;
+    if (typeof extra === 'string') {
+      tenantId = extra;
+    }
+    if (extra && typeof extra === 'object') {
+      domainName = extra.domainName;
+    }
+
+    if (backend && backend !== this.BACKEND_WAZO && !tenantId && !domainName) {
+      if (!tenantId) {
+        throw new NoTenantIdError('No tenant id');
+      }
+
+      if (!domainName) {
+        throw new NoDomainNameError('No domain name');
+      }
     }
 
     this.authenticated = false;
@@ -95,6 +112,7 @@ class Auth {
       password,
       backend,
       tenantId,
+      domainName,
       expiration: this.expiration,
       mobile: this.mobile,
     });
@@ -103,7 +121,13 @@ class Auth {
       getApiClient().setRefreshBackend(backend);
     }
 
-    getApiClient().setRefreshTenantId(tenantId);
+    if (tenantId) {
+      getApiClient().setRefreshTenantId(tenantId);
+    }
+
+    if (domainName) {
+      getApiClient().setRefreshDomainName(domainName);
+    }
 
     return this._onAuthenticated(rawSession);
   }
@@ -202,11 +226,18 @@ class Auth {
   }
 
   setRefreshTenantId(refreshTenantId: string) {
+    console.warn('Use of `setRefreshTenantId` is deprecated, use `setRefreshDomainName` instead.');
     setRefreshTenantId(refreshTenantId);
 
     getApiClient().setRefreshTenantId(refreshTenantId);
   }
 
+  setRefreshDomainName(domainName: string) {
+    setRefreshDomainName(domainName);
+
+    getApiClient().setRefreshDomainName(domainName);
+  }
+
   forceRefreshToken() {
     getApiClient().forceRefreshToken();
   }

package/src/simple/Softphone.js

@@ -107,6 +107,7 @@ class Softphone {
     wrapUpDuration,
     enableAgent = true,
     tenantId,
+    domainName,
     debug = false,
   }: Object = {}) {
     this.url = url || 'https://softphone.wazo.io';
@@ -131,8 +132,12 @@ class Softphone {
       config.port = port;
     }
     if (tenantId) {
+      console.warn('Use of `tenantId` is deprecated when calling `Softphone.init()`, use `domainName` instead');
       config.tenantId = tenantId;
     }
+    if (domainName) {
+      config.domainName = domainName;
+    }
     if (wrapUpDuration) {
       config.wrapUpDuration = wrapUpDuration;
     }

package/src/simple/index.js

@@ -1,5 +1,5 @@
 /* global window */
-import Auth, { InvalidSubscription, InvalidAuthorization, NoTenantIdError } from './Auth';
+import Auth, { InvalidSubscription, InvalidAuthorization, NoTenantIdError, NoDomainNameError } from './Auth';
 import Phone from './Phone';
 import Websocket from './Websocket';
 import Room from './room/Room';
@@ -106,6 +106,7 @@ const Wazo = {
   CanceledCallError,
   SFUNotAvailableError,
   NoTenantIdError,
+  NoDomainNameError,
 };
 
 if (window) {

package/src/simple/room/Participant.js

@@ -4,6 +4,7 @@ import IssueReporter from '../../service/IssueReporter';
 
 import Room, { SIGNAL_TYPE_PARTICIPANT_UPDATE } from './Room';
 import Contact from '../../domain/Contact';
+import getApiClient from '../../service/getApiClient';
 
 const logger = IssueReporter.loggerFor('room');
 
@@ -20,6 +21,7 @@ class Participant extends Emitter {
   videoMuted: boolean;
   screensharing: boolean;
   isOnHold: boolean;
+  banned: boolean;
   extra: Object;
 
   ON_UPDATED: string;
@@ -37,6 +39,7 @@ class Participant extends Emitter {
   ON_EXTRA_CHANGE: string;
   ON_HOLD: string;
   ON_RESUME: string;
+  ON_BAN: string;
 
   /**
    * @param room Room The room where the participant is
@@ -60,6 +63,7 @@ class Participant extends Emitter {
     this.screensharing = false;
     this.isOnHold = false;
     this.extra = extra;
+    this.banned = false;
 
     this.ON_UPDATED = 'participant/ON_UPDATED';
     this.ON_START_TALKING = 'participant/ON_START_TALKING';
@@ -76,6 +80,7 @@ class Participant extends Emitter {
     this.ON_EXTRA_CHANGE = 'participant/ON_EXTRA_CHANGE';
     this.ON_HOLD = 'participant/ON_HOLD';
     this.ON_RESUME = 'participant/ON_RESUME';
+    this.ON_BAN = 'participant/ON_BAN';
   }
 
   triggerEvent(name: string, ...args: any[]) {
@@ -116,6 +121,10 @@ class Participant extends Emitter {
         status.extra = this.extra;
         break;
       }
+      case this.ON_BAN: {
+        status.banned = true;
+        break;
+      }
       default:
         break;
     }
@@ -220,6 +229,11 @@ class Participant extends Emitter {
     this.triggerUpdate(this.ON_RESUME, broadcast);
   }
 
+  onBan(broadcast: boolean = true) {
+    this.banned = true;
+    this.triggerUpdate(this.ON_BAN, broadcast);
+  }
+
   getStatus() {
     return {
       callId: this.callId,
@@ -266,6 +280,10 @@ class Participant extends Emitter {
       }
     }
 
+    if (status.banned) {
+      this.onBan(false);
+    }
+
     // Poor man's object comparison
     if (typeof status.extra !== 'undefined' && JSON.stringify(this.extra) !== JSON.stringify(status.extra)) {
       this.extra = { ...this.extra, ...status.extra };
@@ -293,6 +311,28 @@ class Participant extends Emitter {
     this.streams = streams;
     this.videoStreams = streams;
   }
+
+  async ban(apiRequestDelay: ?number = null) {
+    const { meetingUuid } = this.room;
+    if (!meetingUuid) {
+      throw new Error('Attempting to ban a participant without a `meetingUuid`');
+    }
+
+    // this notifies all that someone is being banned
+    this.onBan(true);
+
+    // this allows to delay the actual ban, in order for the banned participant as well as others to react to the situation
+    if (apiRequestDelay) {
+      await this.delay(apiRequestDelay);
+    }
+
+    // proceed with the actual kick
+    return getApiClient().calld.banMeetingParticipant(meetingUuid, this.callId);
+  }
+
+  async delay(ms: number) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+  }
 }
 
 export default Participant;