Class Meeting

Constructors

constructor

new Meeting(): Meeting

Returns Meeting

Properties

activePresenterId

activePresenterId: string

This indicates the participant ID of the user who is currently sharing their screen in the meeting. If no one is presenting, the value is null.

activeSpeakerId

activeSpeakerId: string

This indicates the participant ID of the user who is currently speaking. If no participant is actively speaking, the value is null.

hlsState

hlsState: "HLS_STOPPED" | "HLS_STARTING" | "HLS_STARTED" | "HLS_STOPPING"

This represents the current state of the HLS stream.

hlsUrls

hlsUrls: {
    downstreamUrl?: string;
    livestreamUrl?: string;
    playbackHlsUrl?: string;
}

This represents the URLs associated with the ongoing HLS stream.

playbackHlsUrl – URL used for playback.
livestreamUrl – URL used for live streaming.
~~downstreamUrl~~ – Deprecated. Use playbackHlsUrl or livestreamUrl instead.

Note

downstreamUrl is deprecated and should no longer be used.

id

id: string

This represents the unique ID of the meeting that the participant has joined.

isE2EEEnabled

isE2EEEnabled: boolean

This represents whether End-to-End Encryption (E2EE) is enabled for the meeting.

livestreamState

livestreamState:
    | "LIVESTREAM_STOPPED"
    | "LIVESTREAM_STARTING"
    | "LIVESTREAM_STARTED"
    | "LIVESTREAM_STOPPING"

This represents the current state of the livestream.

localParticipant

localParticipant: Participant

This represents the local participant (you) who joined the meeting.

mainParticipantId

mainParticipantId: string

This represents the participant ID of the main participant in the meeting.

participants

participants: Map<string, Participant>

This represents a map of all remote participants currently in the meeting.

The key represents the participant ID.
The value represents the corresponding Participant instance.

This map does not include the local participant.

pinnedParticipants

pinnedParticipants: Map<string, { cam: boolean; share: boolean }>

This represents a map of all participants currently pinned in the meeting.

The key represents the participant ID.
The value represents the pin state, indicating whether the participant’s camera (cam) and/or screen share (share) is pinned.

pubSub

pubSub: pubSub

It allows access to the pubSub functionality.

realtimeStore

realtimeStore: realtimeStore

It allows access to the realtimeStore functionality.

recordingState

recordingState:
    | "RECORDING_STOPPED"
    | "RECORDING_STARTING"
    | "RECORDING_STARTED"
    | "RECORDING_STOPPING"

This represents the current state of the meeting recording.

selectedCameraDevice

selectedCameraDevice: CameraDeviceInfo

This represents the currently selected camera device used during the meeting,returned as a CameraDeviceInfo object containing details about the active camera.

selectedMicrophoneDevice

selectedMicrophoneDevice: MicrophoneDeviceInfo

This represents the currently selected microphone device used during the meeting,returned as a MicrophoneDeviceInfo object containing details about the active microphone.

transcriptionState

transcriptionState:
    | "TRANSCRIPTION_STARTING"
    | "TRANSCRIPTION_STARTED"
    | "TRANSCRIPTION_STOPPING"
    | "TRANSCRIPTION_STOPPED"

This represents the current state of real-time transcription.

Methods

changeMic

changeMic(object: string | MediaStream): Promise<void>
- This method can be used to change the active microphone device.
- If multiple microphones are available, this method allows switching between them dynamically during the meeting.
Parameters
- object: string | MediaStream
  Either:
  
  A deviceId string of the microphone to switch to, or
  
  A MediaStream to be used as the audio input source.
Returns Promise<void>
Throws
- Everything muteMic and unmuteMic can throw
- Errors.ERROR_NO_MICROPHONE_DEVICE_FOUND — no microphone device found for the given id
Example
```
let meeting;

// Initialize Meeting
meeting = VideoSDK.initMeeting({
  // ...
});

try {
  const mics = await meeting?.getMics();

  const { deviceId, label } = mics[0];

  await meeting?.changeMic(deviceId);
} catch (err) {
  console.log("Error in changeMic", err);
}
```
- Defined in meeting.d.ts:1367

changeMode

changeMode(
mode: "SEND_AND_RECV" | "SIGNALLING_ONLY" | "RECV_ONLY",
): Promise<void>
- This method can be used to change the local participant's mode.
- You can switch between the following modes: modes.
Info

Important changes introduced in JavaScript SDK v0.1.4:
- CONFERENCE has been replaced with SEND_AND_RECV
- VIEWER has been replaced with SIGNALLING_ONLY
Events associated with changeMode():
- The participant receives a participant-mode-changed event when the mode is successfully updated.
Parameters
- mode: "SEND_AND_RECV" | "SIGNALLING_ONLY" | "RECV_ONLY"
Returns Promise<void>
Throws
- Errors.ERROR_ACTION_PERFORMED_BEFORE_MEETING_JOINED — called before meeting is joined
- Errors.ERROR_ALREADY_IN_REQUESTED_STATE — already in that mode
- Errors.CHANGE_MODE_FAILED — server rejected the change-mode request
- Errors.ERROR_OPERATION_TIMED_OUT — the request timed out
Example
```
let meeting;

// Initialize Meeting
meeting = VideoSDK.initMeeting({
  // ...
});

try {
  await meeting?.changeMode(VideoSDK.Constants.modes.SEND_AND_RECV);
} catch (err) {
  console.log("Error in changeMode", err);
}
```
- Defined in meeting.d.ts:220

changeWebcam

changeWebcam(object: string | MediaStream): Promise<void>
- This method can be used to change the active webcam device.
- If multiple cameras are connected, this method allows switching between them dynamically during the meeting.
Parameters
- object: string | MediaStream
  Either:
  
  A deviceId of the webcam to switch to, or
  
  A MediaStream to be used as the video source.
Returns Promise<void>
Throws
- Everything disableWebcam and enableWebcam can throw
- Errors.ERROR_NO_WEBCAM_DEVICE_FOUND — no webcam device found for the given id
- Errors.ERROR_OPERATION_IN_PROGRESS — a webcam change/enable is already in flight
Example
```
let meeting;

// Initialize Meeting
meeting = VideoSDK.initMeeting({
  // ...
});

try {
  const webcams = await meeting?.getWebcams();

  const { deviceId, label } = webcams[0];

  await meeting?.changeWebcam(deviceId);
} catch (err) {
  console.log("Error in changeWebcam", err);
}
```
- Defined in meeting.d.ts:1402

disableAdaptiveSubscription

disableAdaptiveSubscription(): Promise<void>
- This method can be used to disable Adaptive Subscription.
- When disabled, all video streams remain subscribed regardless of visibility or network conditions.
Returns Promise<void>
Throws
- Errors.ERROR_ACTION_PERFORMED_BEFORE_MEETING_JOINED — called before meeting is joined
- Errors.ERROR_MEETING_RECONNECTING — meeting is reconnecting
- Errors.ADAPTIVE_SUBSCRIPTION_DISABLE_FAILED — adaptive subscription is already disabled
- Errors.ERROR_OPERATION_TIMED_OUT — the request timed out
Example
```
let meeting;

// Initialize Meeting
meeting = VideoSDK.initMeeting({
  // ...
});

try {
  await meeting?.disableAdaptiveSubscription();
} catch (err) {
  console.log("Error in disableAdaptiveSubscription", err);
}
```
- Defined in meeting.d.ts:1153

disableScreenShare

disableScreenShare(): Promise<void>
- This method can be used to disable screen sharing for the local participant.
Events associated with disableScreenShare():
- A stream-disabled event is emitted with the corresponding Stream object.
- A presenter-changed event is emitted with null as the presenter.
Returns Promise<void>
Throws
- Errors.ERROR_ACTION_PERFORMED_BEFORE_MEETING_JOINED — called before meeting is joined
- Errors.ERROR_MEETING_RECONNECTING — meeting is reconnecting
- Errors.ERROR_ACTION_NOT_SUPPORTED_IN_MODE — not allowed in viewer/RECV_ONLY mode
- Errors.ERROR_OPERATION_IN_PROGRESS — share-enable is in flight or share is already disabling
- Errors.ERROR_ALREADY_IN_REQUESTED_STATE — screen share is already disabled
Example
```
let meeting;

// Initialize Meeting
meeting = VideoSDK.initMeeting({
  // ...
});

try {
  await meeting?.disableScreenShare();
} catch (err) {
  console.log("Error in disableScreenShare", err);
}
```
- Defined in meeting.d.ts:478

disableWebcam

disableWebcam(): Promise<void>
- This method can be used to disable the local participant’s webcam.
Events associated with disableWebcam():
- A stream-disabled event is emitted with the corresponding Stream object.
Returns Promise<void>
Throws
- Errors.ERROR_ACTION_PERFORMED_BEFORE_MEETING_JOINED — called before meeting is joined
- Errors.ERROR_MEETING_RECONNECTING — meeting is reconnecting
- Errors.ERROR_ACTION_NOT_SUPPORTED_IN_MODE — not allowed in viewer/RECV_ONLY mode
- Errors.ERROR_OPERATION_IN_PROGRESS — change-mode / webcam-enable / webcam-disable already in flight
- Errors.ERROR_ALREADY_IN_REQUESTED_STATE — webcam is already disabled
- Errors.ERROR_WEBCAM_CLOSE_PRODUCER_FAILED — The webcam could not be turned off.
- Errors.ERROR_OPERATION_TIMED_OUT — the request timed out
Example
```
let meeting;

// Initialize Meeting
meeting = VideoSDK.initMeeting({
  // ...
});

try {
  await meeting?.disableWebcam();
} catch (err) {
  console.log("Error in disableWebcam", err);
}
```
- Defined in meeting.d.ts:402

enableAdaptiveSubscription

enableAdaptiveSubscription(): Promise<void>
- This method can be used to enable Adaptive Subscription.
- Adaptive Subscription dynamically adjusts which video streams are subscribed to, based on participant visibility and current network conditions.
Returns Promise<void>
Throws
- Errors.ERROR_ACTION_PERFORMED_BEFORE_MEETING_JOINED — called before meeting is joined
- Errors.ERROR_MEETING_RECONNECTING — meeting is reconnecting
- Errors.ADAPTIVE_SUBSCRIPTION_ENABLE_FAILED — adaptive subscription is already enabled
- Errors.ERROR_OPERATION_TIMED_OUT — the request timed out
Example
```
let meeting;

// Initialize Meeting
meeting = VideoSDK.initMeeting({
  // ...
});

try {
  await meeting?.enableAdaptiveSubscription();
} catch (err) {
  console.log("Error in enableAdaptiveSubscription", err);
}
```
- Defined in meeting.d.ts:1126

enableScreenShare

enableScreenShare(customScreenSharingTrack?: MediaStream): Promise<void>
- This method can be used to enable screen sharing for the local participant.
Events associated with enableScreenShare():
- A stream-enabled event is emitted with the corresponding Stream object.
- A presenter-changed event is emitted with the presenterId.
Parameters
- OptionalcustomScreenSharingTrack: MediaStream
  An optional custom screen share track to be used instead of the default one.
  
  To learn more checkout this reference
Returns Promise<void>
Throws
- Errors.ERROR_ACTION_PERFORMED_BEFORE_MEETING_JOINED — called before meeting is joined
- Errors.ERROR_MEETING_RECONNECTING — meeting is reconnecting
- Errors.ERROR_ACTION_NOT_SUPPORTED_IN_MODE — not allowed in viewer/RECV_ONLY mode
- Errors.ERROR_OPERATION_IN_PROGRESS — share-disable is in flight
- Errors.ERROR_MEDIA_DEVICE_NOT_INITIALIZED — media device not initialized
- Errors.ERROR_MEDIA_DEVICE_NOT_LOADED — media device not loaded
- Errors.ERROR_GET_DISPLAY_MEDIA — browser cannot getDisplayMedia
- Errors.ERROR_MEDIA_NOT_READY — transport not ready
- Errors.ERROR_SCREENSHARE_PRODUCE_FAILED — screen-share track could not be published
- Errors.ERROR_OPERATION_TIMED_OUT — the request timed out
Example
```
let meeting;

// Initialize Meeting
meeting = VideoSDK.initMeeting({
  // ...
});

try {
  await meeting?.enableScreenShare();
} catch (err) {
  console.log("Error in enableScreenShare", err);
}
```
- Defined in meeting.d.ts:519

enableWebcam

enableWebcam(customVideoTrack?: MediaStream): Promise<void>
- This method can be used to enable the local participant’s webcam.
Events associated with enableWebcam():
- A stream-enabled event is emitted with the corresponding Stream object.
Parameters
- OptionalcustomVideoTrack: MediaStream
  An optional custom video track to be used instead of the default one.
  
  To learn more, checkout this reference
Returns Promise<void>
Throws
- Errors.ERROR_ACTION_PERFORMED_BEFORE_MEETING_JOINED — called before meeting is joined
- Errors.ERROR_MEETING_RECONNECTING — meeting is reconnecting
- Errors.ERROR_ACTION_NOT_SUPPORTED_IN_MODE — not allowed in viewer/RECV_ONLY mode
- Errors.ERROR_OPERATION_IN_PROGRESS — change-mode / webcam-enable / webcam-disable already in flight
- Errors.ERROR_ALREADY_IN_REQUESTED_STATE — webcam is already enabled
- Errors.ERROR_MEDIA_DEVICE_NOT_LOADED — media device not loaded
- Errors.ERROR_CAMERA_ACCESS_UNAVAILABLE — camera access unavailable
- Errors.ERROR_MEDIA_DEVICE_NOT_INITIALIZED — media device not initialized
- Errors.ERROR_NO_WEBCAM_DEVICE_FOUND — no webcam device found
- Errors.ERROR_NO_SUPPORTED_VIDEO_CODEC — no supported video codec available
- Errors.ERROR_MEDIA_NOT_READY — transport not ready
- Errors.ERROR_WEBCAM_PRODUCE_FAILED — webcam track could not be published
- Errors.ERROR_OPERATION_TIMED_OUT — the request timed out
Example
```
let meeting;

// Initialize Meeting
meeting = VideoSDK.initMeeting({
  // ...
});

try {
  await meeting?.enableWebcam();
} catch (err) {
  console.log("Error in enableWebcam", err);
}
```
- Defined in meeting.d.ts:446

end

end(): Promise<void>
- This method can be used to end the current meeting session for all participants.
- Calling end() removes all participants, including the local participant, and permanently terminates the meeting.
Events associated with end():
- All participants receive the meeting-left event.
Returns Promise<void>
Throws
- Errors.ERROR_ACTION_PERFORMED_BEFORE_MEETING_JOINED — called before meeting is joined
- Errors.ERROR_MEETING_RECONNECTING — meeting is reconnecting
- Errors.ERROR_END_MEETING_FAILED — server rejected the end request (reason bubbled up)
- Errors.ERROR_OPERATION_TIMED_OUT — the request timed out
Example
```
let meeting;

// Initialize Meeting
meeting = VideoSDK.initMeeting({
  // ...
});

try {
  await meeting?.end();
} catch (err) {
  console.log("Error in end", err);
}
```
- Defined in meeting.d.ts:253

fetchBase64File

fetchBase64File(options: { token: string; url: string }): Promise<string>
- This method can be used to retrieve a previously uploaded file from VideoSDK's temporary storage.
- The returned value is a Base64-encoded string.
Parameters
- options: { token: string; url: string }
  - token: string
    
    VideoSDK authentication token.
  - url: string
    
    The file URL returned by uploadBase64File().
Returns Promise<string>
A Base64-encoded string of the requested file.
Throws
- Errors.ERROR_INVALID_PARAMETER — missing or invalid options (url / token)
- Errors.ERROR_FILE_FETCH_FAILED — server rejected the fetch request
Example
```
let meeting;

// Initialize Meeting
meeting = VideoSDK.initMeeting({
  // ...
});

try {
  const base64 = await meeting.fetchBase64File({
    url: "<FILE_URL>", // Provide fileUrl which is returned by uploadBase64File(),
    token: "<VIDEOSDK_TOKEN>",
  });

  console.log("Base64:", base64);
} catch (err) {
  console.log("Error in fetchBase64File", err);
}
```
- Defined in meeting.d.ts:1601

getMics

getMics(): Promise<{ deviceId: string; label: string }[]>
- This method can be used to retrieve all available microphone devices connected to the system.
Returns Promise<{ deviceId: string; label: string }[]>
Example
```
let meeting;

// Initialize Meeting
meeting = VideoSDK.initMeeting({
  // ...
});

try {
  const mics = await meeting?.getMics();
  console.log(mics);
} catch (err) {
  console.log("Error in getMics", err);
}
```
- Defined in meeting.d.ts:1064

getWebcams

getWebcams(): Promise<
{ deviceId: string; facingMode: "environment"
| "front"; label: string }[],
>
- This method can be used to retrieve all available camera devices connected to the system.
Returns Promise<
{ deviceId: string; facingMode: "environment"
| "front"; label: string }[],
>
Example
```
let meeting;

// Initialize Meeting
meeting = VideoSDK.initMeeting({
  // ...
});

try {
  const webcams = await meeting?.getWebcams();
  console.log(webcams);
} catch (err) {
  console.log("Error in getWebcams", err);
}
```
- Defined in meeting.d.ts:1093

join

join(): Promise<void>
- This method can be used to join the meeting.
- After initializing a meeting using initMeeting(), calling join() is required to enter the meeting.
Events associated with join():
- The local participant receives a meeting-joined event once the meeting is successfully joined.
- Remote participants receive a participant-joined event containing the newly joined participant.
Returns Promise<void>
Throws
- Errors.ERROR_OPERATION_IN_PROGRESS — join is already in progress
- Errors.ERROR_ALREADY_IN_REQUESTED_STATE — already joined
- Errors.ERROR_UNABLE_TO_JOIN_MEETING — server/network failure (invalid token, unauthorized meetingId, media connection failed, etc.)
Example
```
let meeting;

// Initialize Meeting
meeting = VideoSDK.initMeeting({
  // ...
});

try {
  await meeting?.join();
} catch (err) {
  console.log("Error in join", err);
}
```
- Defined in meeting.d.ts:154

leave

leave(): Promise<void>
- This method can be used to leave the currently joined meeting.
Events associated with leave():
- The local participant receives a meeting-left event.
- All remote participants receive a participant-left event containing the participant ID of the user who left.
Returns Promise<void>
Throws
- Errors.ERROR_ALREADY_IN_REQUESTED_STATE — already left (double leave, host closed, disconnected)
- Errors.ERROR_ACTION_PERFORMED_BEFORE_MEETING_JOINED — never joined
Example
```
let meeting;

// Initialize Meeting
meeting = VideoSDK.initMeeting({
  // ...
});

try {
  await meeting?.leave();
} catch (err) {
  console.log("Error in leave", err);
}
```
- Defined in meeting.d.ts:183

muteMic

muteMic(): Promise<void>
- This method can be used to disable the local participant’s microphone.
Events associated with muteMic():
- A stream-disabled event is emitted with the corresponding Stream object.
Returns Promise<void>
Throws
- Errors.ERROR_ACTION_PERFORMED_BEFORE_MEETING_JOINED — called before meeting is joined
- Errors.ERROR_MEETING_RECONNECTING — meeting is reconnecting
- Errors.ERROR_ACTION_NOT_SUPPORTED_IN_MODE — not allowed in viewer/RECV_ONLY mode
- Errors.ERROR_OPERATION_IN_PROGRESS — change-mode / mic-enable / mic-disable already in flight
- Errors.ERROR_ALREADY_IN_REQUESTED_STATE — mic is already disabled
- Errors.ERROR_MICROPHONE_CLOSE_PRODUCER_FAILED — The microphone could not be turned off
- Errors.ERROR_OPERATION_TIMED_OUT — the request timed out
Example
```
let meeting;

// Initialize Meeting
meeting = VideoSDK.initMeeting({
  // ...
});

try {
  await meeting?.muteMic();
} catch (err) {
  console.log("Error in muteMic", err);
}
```
- Defined in meeting.d.ts:326

off

off(
    eventType:
        | "participant-joined"
        | "participant-left"
        | "participant-mode-changed"
        | "speaker-changed"
        | "presenter-changed"
        | "main-participant-changed"
        | "entry-requested"
        | "entry-responded"
        | "recording-state-changed"
        | "livestream-state-changed"
        | "hls-state-changed"
        | "whiteboard-started"
        | "whiteboard-stopped"
        | "meeting-joined"
        | "meeting-left"
        | "mic-requested"
        | "webcam-requested"
        | "pin-state-changed"
        | "meeting-state-changed"
        | "error"
        | "transcription-state-changed"
        | "transcription-text"
        | "paused-all-streams"
        | "resumed-all-streams"
        | "media-relay-started"
        | "media-relay-stopped"
        | "media-relay-error"
        | "media-relay-request-response"
        | "media-relay-request-received"
        | "quality-limitation"
        | "audio-input-silence"
        | "data"
        | "codec-changed",
    listener: (data: any) => void,
): void
Removes an event listener that was previously registered.
Parameters
- eventType:
      | "participant-joined"
      | "participant-left"
      | "participant-mode-changed"
      | "speaker-changed"
      | "presenter-changed"
      | "main-participant-changed"
      | "entry-requested"
      | "entry-responded"
      | "recording-state-changed"
      | "livestream-state-changed"
      | "hls-state-changed"
      | "whiteboard-started"
      | "whiteboard-stopped"
      | "meeting-joined"
      | "meeting-left"
      | "mic-requested"
      | "webcam-requested"
      | "pin-state-changed"
      | "meeting-state-changed"
      | "error"
      | "transcription-state-changed"
      | "transcription-text"
      | "paused-all-streams"
      | "resumed-all-streams"
      | "media-relay-started"
      | "media-relay-stopped"
      | "media-relay-error"
      | "media-relay-request-response"
      | "media-relay-request-received"
      | "quality-limitation"
      | "audio-input-silence"
      | "data"
      | "codec-changed"
  Event name to which you want to unsubscribe.
- listener: (data: any) => void
  Callback function which was passed while subscribing to the event
  
  To view the complete list of available events and their details, refer to MeetingEvent.
Returns void
- Defined in meeting.d.ts:1658

on

on(
    eventType:
        | "participant-joined"
        | "participant-left"
        | "participant-mode-changed"
        | "speaker-changed"
        | "presenter-changed"
        | "main-participant-changed"
        | "entry-requested"
        | "entry-responded"
        | "recording-state-changed"
        | "livestream-state-changed"
        | "hls-state-changed"
        | "whiteboard-started"
        | "whiteboard-stopped"
        | "meeting-joined"
        | "meeting-left"
        | "mic-requested"
        | "webcam-requested"
        | "pin-state-changed"
        | "meeting-state-changed"
        | "error"
        | "transcription-state-changed"
        | "transcription-text"
        | "paused-all-streams"
        | "resumed-all-streams"
        | "media-relay-started"
        | "media-relay-stopped"
        | "media-relay-error"
        | "media-relay-request-response"
        | "media-relay-request-received"
        | "quality-limitation"
        | "audio-input-silence"
        | "data"
        | "codec-changed",
    listener: (data: any) => void,
): void
Registers an event listener.
Parameters
- eventType:
      | "participant-joined"
      | "participant-left"
      | "participant-mode-changed"
      | "speaker-changed"
      | "presenter-changed"
      | "main-participant-changed"
      | "entry-requested"
      | "entry-responded"
      | "recording-state-changed"
      | "livestream-state-changed"
      | "hls-state-changed"
      | "whiteboard-started"
      | "whiteboard-stopped"
      | "meeting-joined"
      | "meeting-left"
      | "mic-requested"
      | "webcam-requested"
      | "pin-state-changed"
      | "meeting-state-changed"
      | "error"
      | "transcription-state-changed"
      | "transcription-text"
      | "paused-all-streams"
      | "resumed-all-streams"
      | "media-relay-started"
      | "media-relay-stopped"
      | "media-relay-error"
      | "media-relay-request-response"
      | "media-relay-request-received"
      | "quality-limitation"
      | "audio-input-silence"
      | "data"
      | "codec-changed"
  Event name to which you want to subscribe.
- listener: (data: any) => void
  Callback function which will be triggered when the event happens
  
  To view the complete list of available events and their details, refer to MeetingEvent.
Returns void
- Defined in meeting.d.ts:1613

pauseAllStreams

pauseAllStreams(
kind?: "audio" | "video" | "share" | "shareAudio" | "all",
): Promise<void>
- This method can be used to pause active media streams in the meeting.
- The local participant will receive the paused-all-streams event.
Parameters
- Optionalkind: "audio" | "video" | "share" | "shareAudio" | "all"
  Specifies which type of media stream should be paused. If not provided, all media streams (audio, video, and screen share) will be paused.
Returns Promise<void>
Throws
- Errors.PAUSE_ALL_STREAMS_FAILED — server rejected the request
- Errors.ERROR_OPERATION_TIMED_OUT — the request timed out
Example
```
let meeting;

// Initialize Meeting
meeting = VideoSDK.initMeeting({
  // ...
});

try {
  await meeting?.pauseAllStreams("video");
} catch (err) {
  console.log("Error in pauseAllStreams", err);
}
```
- Defined in meeting.d.ts:1301

replaceWebcamStream

replaceWebcamStream(stream: MediaStream): Promise<void>
- This method can be used to replace the currently published webcam stream with a new MediaStream.
- Useful when swapping the outgoing video track (for example, when applying a virtual background).
Parameters
- stream: MediaStream
  The new MediaStream to publish as the webcam.
Returns Promise<void>
Throws
- Everything enableWebcam can throw (publish failure is re-thrown)
- Errors.ERROR_WEBCAM_PRODUCE_FAILED — new webcam track could not be published
Example
```
let meeting;

// Initialize Meeting
meeting = VideoSDK.initMeeting({
  // ...
});

try {
  await meeting?.replaceWebcamStream(newStream);
} catch (err) {
  console.log("Error in replaceWebcamStream", err);
}
```
- Defined in meeting.d.ts:1430

requestMediaRelay

requestMediaRelay(
    options: {
        destinationMeetingId: string;
        kinds?: ("audio" | "video" | "share")[];
        token?: string;
    },
): Promise<void>
- This method can be used to start relaying selected media streams from the current meeting to another destination meeting.
- Once the relay is successfully initiated, the local participant receives the media-relay-started event.
Parameters
- options: {
      destinationMeetingId: string;
      kinds?: ("audio" | "video" | "share")[];
      token?: string;
  }
  Configuration for media relay.
  - destinationMeetingId: string
    
    The ID of the destination meeting where media will be relayed.
  - Optionalkinds?: ("audio" | "video" | "share")[]
    
    Specifies which media tracks should be relayed.
  - Optionaltoken?: string
    
    Authentication token for the destination meeting.
Returns Promise<void>
A promise that resolves once the relay request is successfully processed.
Throws
- Errors.ERROR_INVALID_PARAMETER — missing destinationMeetingId
- Errors.ERROR_ACTION_PERFORMED_BEFORE_MEETING_JOINED — called before meeting is joined
- Errors.ERROR_MEETING_RECONNECTING — meeting is reconnecting
- Errors.REQUEST_MEDIA_RELAY_FAILED — server rejected the request
- Errors.ERROR_OPERATION_TIMED_OUT — the request timed out
Example
```
let meeting;

// Initialize Meeting
meeting = VideoSDK.initMeeting({
  // ...
});

try {
  await meeting?.requestMediaRelay({
    destinationMeetingId: "destination-meeting-id",
    token: "auth-token",
    kinds: ["audio", "video"],
  });
} catch (err) {
  console.log("Error in requestMediaRelay", err);
}
```
- Defined in meeting.d.ts:1238

respondEntry

respondEntry(
participantId: string,
decision: "allowed" | "denied",
): Promise<void>
- This method can be used to respond to a participant’s request to enter the meeting.
- Call this from a host / co-host to allow or deny an entry request received via the entry-requested event.
Parameters
- participantId: string
  The ID of the participant whose entry request is being responded to.
- decision: "allowed" | "denied"
  The final decision for the entry request.
  
  Possible values:
  
  "allowed" – Allow the participant to join.
  
  "denied" – Deny the participant’s entry request.
Returns Promise<void>
Throws
- Errors.ERROR_ACTION_PERFORMED_BEFORE_MEETING_JOINED — called before meeting is joined
- Errors.ERROR_MEETING_RECONNECTING — meeting is reconnecting
- Errors.RESPOND_ENTRY_FAILED — server rejected the entry-response
- Errors.ERROR_OPERATION_TIMED_OUT — the request timed out
Example
```
let meeting;

// Initialize Meeting
meeting = VideoSDK.initMeeting({
  // ...
});

try {
  await meeting?.respondEntry("participant-id", "allowed");
} catch (err) {
  console.log("Error in respondEntry", err);
}
```
- Defined in meeting.d.ts:290

resumeAllStreams

resumeAllStreams(
kind?: "audio" | "video" | "share" | "shareAudio" | "all",
): Promise<void>
- This method can be used to resume media streams that were previously paused.
- The local participant will receive the resumed-all-streams event.
Parameters
- Optionalkind: "audio" | "video" | "share" | "shareAudio" | "all"
  Specifies which type of media stream should be resumed.If not provided, all media streams (audio, video, and screen share) will be resumed.
Returns Promise<void>
Throws
- Errors.RESUME_ALL_STREAMS_FAILED — server rejected the request
- Errors.ERROR_OPERATION_TIMED_OUT — the request timed out
Example
```
let meeting;

// Initialize Meeting
meeting = VideoSDK.initMeeting({
  // ...
});

try {
  await meeting?.resumeAllStreams("video");
} catch (err) {
  console.log("Error in resumeAllStreams", err);
}
```
- Defined in meeting.d.ts:1331

send

send(
payload: string | Blob | ArrayBuffer | ArrayBufferView<ArrayBufferLike>,
options?: { reliability?: "RELIABLE" | "UNRELIABLE" },
): Promise<boolean>
- This method can be used to send a message to all participants in the meeting using the data channel.
Parameters
- payload: string | Blob | ArrayBuffer | ArrayBufferView<ArrayBufferLike>
  The data to be sent.
  
  Supported types: string, Blob, ArrayBuffer, ArrayBufferView
  
  Maximum allowed size: 15 KiB
- Optionaloptions: { reliability?: "RELIABLE" | "UNRELIABLE" }
  - Optionalreliability?: "RELIABLE" | "UNRELIABLE"
    
    Determines how the message is delivered:
    
    reliabilityMode.RELIABLE — Guarantees delivery and preserves order (may introduce latency).
    
    reliabilityMode.UNRELIABLE — Faster delivery but messages may be dropped under poor network conditions.
Returns Promise<boolean>
Throws
- Errors.ERROR_ACTION_NOT_SUPPORTED — invalid or too-large payload
- Errors.ERROR_MEDIA_NOT_READY — transport not ready
- Errors.ERROR_ACTION_NOT_SUPPORTED_IN_MODE — not allowed in viewer/RECV_ONLY mode
- Errors.ERROR_ACTION_PERFORMED_BEFORE_MEETING_JOINED — called before meeting is joined
- Errors.ERROR_MEETING_RECONNECTING — meeting is reconnecting
- Errors.ERROR_SEND_FAILED — data-producer / send failed
Example
```
let meeting;

// Initialize Meeting
meeting = VideoSDK.initMeeting({
  // ...
});

try {
  await meeting?.send("Hello everyone!", {
    reliability: VideoSDK.Constants.reliabilityMode.UNRELIABLE,
  });
} catch (err) {
  console.log("Error in send", err);
}
```
- Defined in meeting.d.ts:563

setWebcamQuality

setWebcamQuality(quality: "low" | "med" | "high"): Promise<void>
- This method can be used to set the webcam video quality for the local participant.
- This method allows you to dynamically adjust the outgoing webcam video quality during the meeting.
Parameters
- quality: "low" | "med" | "high"
  Specifies the desired webcam quality.
  
  Allowed values:
  
  "low" – Low video quality
  
  "med" – Medium video quality
  
  "high" – High video quality
Returns Promise<void>
Throws
- Errors.ERROR_ACTION_PERFORMED_BEFORE_MEETING_JOINED — called before meeting is joined
- Errors.ERROR_MEETING_RECONNECTING — meeting is reconnecting
- Errors.ERROR_WEBCAM_NOT_ENABLED — the webcam is not enabled
- Errors.ERROR_ALREADY_IN_REQUESTED_STATE — already at that quality
- Errors.ERROR_SET_WEBCAM_QUALITY_FAILED — invalid quality or layer switch failed
Example
```
let meeting;

// Initialize Meeting
meeting = VideoSDK.initMeeting({
  // ...
});

try {
  await meeting?.setWebcamQuality("high");
} catch (err) {
  console.log("Error in setWebcamQuality", err);
}
```
- Defined in meeting.d.ts:1466

startHls

startHls(
    config?: {
        layout?: {
            gridSize?: number;
            priority?: "SPEAKER" | "PIN";
            type?: "GRID" | "SPOTLIGHT" | "SIDEBAR";
        };
        mode?: "video-and-audio"
        | "audio";
        quality?: "low" | "med" | "high";
        recording?: { enabled: boolean };
        theme?: "DARK" | "LIGHT" | "DEFAULT";
    },
    transcription?: {
        enabled: boolean;
        summary?: { enabled: boolean; prompt?: string };
    },
): Promise<void>
- This method can be used to start HLS streaming for the meeting.
- This allows participants and viewers to watch the meeting via HLS playback.
- All participants, including the local participant, will receive the HLS_STARTING event state in the hls-state-changed event.
Parameters
- Optionalconfig: {
      layout?: {
          gridSize?: number;
          priority?: "SPEAKER" | "PIN";
          type?: "GRID" | "SPOTLIGHT" | "SIDEBAR";
      };
      mode?: "video-and-audio"
      | "audio";
      quality?: "low" | "med" | "high";
      recording?: { enabled: boolean };
      theme?: "DARK" | "LIGHT" | "DEFAULT";
  }
  Configuration used to control the HLS stream.
  - Optionallayout?: {
        gridSize?: number;
        priority?: "SPEAKER" | "PIN";
        type?: "GRID" | "SPOTLIGHT" | "SIDEBAR";
    }
    
    OptionalgridSize?: number
    
    Specifies the maximum number of participants shown in the grid.
    
    Optionalpriority?: "SPEAKER" | "PIN"
    
    Determines participant priority when composing the layout.
    
    Optionaltype?: "GRID" | "SPOTLIGHT" | "SIDEBAR"
    
    Defines the layout used in the HLS stream.
  - Optionalmode?: "video-and-audio" | "audio"
    
    Determines whether the stream includes video and audio or audio only.
  - Optionalquality?: "low" | "med" | "high"
    
    Defines the output video quality of the HLS stream.
  - Optionalrecording?: { enabled: boolean }
    
    This can be used to enable or disable recording.
  - Optionaltheme?: "DARK" | "LIGHT" | "DEFAULT"
    
    Defines the visual theme of the HLS stream.
- Optionaltranscription: { enabled: boolean; summary?: { enabled: boolean; prompt?: string } }
  Configuration for post-meeting transcription and summary generation.
  - enabled: boolean
    
    Enables or disables transcription.
  - Optionalsummary?: { enabled: boolean; prompt?: string }
    
    enabled: boolean
    
    Enables or disables summary generation.
    
    Optionalprompt?: string
    
    Custom prompt used for generating the summary.
Returns Promise<void>
Throws
- Errors.ERROR_ACTION_PERFORMED_BEFORE_MEETING_JOINED — called before meeting is joined
- Errors.ERROR_MEETING_RECONNECTING — meeting is reconnecting
- Errors.START_HLS_FAILED — server rejected the request
- Errors.ERROR_OPERATION_TIMED_OUT — the request timed out
Example
```
let meeting;

// Initialize Meeting
meeting = VideoSDK.initMeeting({
  // ...
});

const config = {
  layout: {
    type: "SPOTLIGHT",
    priority: "PIN",
    gridSize: 9,
  },
  theme: "DEFAULT",
  recording : {
    enabled: true,
  };
};

const transcription = {
  enabled: true,
  summary: {
    enabled: true,
  },
};

try {
  await meeting?.startHls(config, transcription);
} catch (err) {
  console.log("Error in startHls", err);
}
```
- Defined in meeting.d.ts:992

startLivestream

startLivestream(
    outputs: { streamKey: string; url: string }[],
    config?: {
        layout?: {
            gridSize?: number;
            priority?: "SPEAKER" | "PIN";
            type?: "GRID" | "SPOTLIGHT" | "SIDEBAR";
        };
        recording?: { enabled: boolean };
        theme?: "DARK" | "LIGHT" | "DEFAULT";
    },
): Promise<void>
- This method can be used to start live streaming the meeting.
- This allows you to stream the meeting to external platforms such as YouTube, Facebook, or any service that supports RTMP.
- All participants, including the local participant, will receive the LIVESTREAM_STARTING state in the livestream-state-changed event.
Parameters
- outputs: { streamKey: string; url: string }[]
  An array of RTMP output destinations where the livestream will be broadcast.
- Optionalconfig: {
      layout?: {
          gridSize?: number;
          priority?: "SPEAKER" | "PIN";
          type?: "GRID" | "SPOTLIGHT" | "SIDEBAR";
      };
      recording?: { enabled: boolean };
      theme?: "DARK" | "LIGHT" | "DEFAULT";
  }
  Configuration options for the RTMP livestream.
  - Optionallayout?: {
        gridSize?: number;
        priority?: "SPEAKER" | "PIN";
        type?: "GRID" | "SPOTLIGHT" | "SIDEBAR";
    }
    
    OptionalgridSize?: number
    
    Specifies the maximum number of participants displayed in the grid.
    
    Optionalpriority?: "SPEAKER" | "PIN"
    
    Determines participant priority when composing the livestream layout.
    
    Optionaltype?: "GRID" | "SPOTLIGHT" | "SIDEBAR"
    
    Defines the layout used for the livestream.
  - Optionalrecording?: { enabled: boolean }
    
    This can be used to enable or disable recording.
  - Optionaltheme?: "DARK" | "LIGHT" | "DEFAULT"
    
    Defines the color theme of the livestream.
Returns Promise<void>
Throws
- Errors.ERROR_ACTION_PERFORMED_BEFORE_MEETING_JOINED — called before meeting is joined
- Errors.ERROR_MEETING_RECONNECTING — meeting is reconnecting
- Errors.START_LIVESTREAM_FAILED — server rejected the request
- Errors.ERROR_OPERATION_TIMED_OUT — the request timed out
Example
```
let meeting;

// Initialize Meeting
meeting = VideoSDK.initMeeting({
  // ...
});

const outputs = [
  {
    url: "rtmp://a.rtmp.youtube.com/live2",
    streamKey: "<STREAM_KEY>",
  },
  {
    url: "rtmps://",
    streamKey: "<STREAM_KEY>",
  },
];

const config = {
  layout: {
    type: "SPOTLIGHT",
    priority: "PIN",
    gridSize: 9,
  },
  theme: "DEFAULT",
  recording: {
    enabled: true,
  },
};

try {
  await meeting?.startLivestream(outputs, config);
} catch (err) {
  console.log("Error in startLivestream", err);
}
```
- Defined in meeting.d.ts:867

startRecording

startRecording(
    webhookUrl?: string,
    awsDirPath?: string,
    config?: {
        layout?: {
            gridSize?: number;
            priority?: "SPEAKER" | "PIN";
            type?: "GRID" | "SPOTLIGHT" | "SIDEBAR";
        };
        mode?: "video-and-audio"
        | "audio";
        quality?: "low" | "med" | "high";
        theme?: "DARK" | "LIGHT" | "DEFAULT";
    },
    transcription?: {
        enabled: boolean;
        summary?: { enabled: boolean; prompt?: string };
    },
): Promise<void>
- This method can be used to start recording the meeting.
- All participants, including the local participant, will receive the RECORDING_STARTING event state in the recording-state-changed event.
Parameters
- OptionalwebhookUrl: string
  Webhook URL triggered when the recording state changes.
- OptionalawsDirPath: string
  Path to the directory in your S3 bucket where recordings are stored.
- Optionalconfig: {
      layout?: {
          gridSize?: number;
          priority?: "SPEAKER" | "PIN";
          type?: "GRID" | "SPOTLIGHT" | "SIDEBAR";
      };
      mode?: "video-and-audio"
      | "audio";
      quality?: "low" | "med" | "high";
      theme?: "DARK" | "LIGHT" | "DEFAULT";
  }
  Recording configuration options.
  - Optionallayout?: {
        gridSize?: number;
        priority?: "SPEAKER" | "PIN";
        type?: "GRID" | "SPOTLIGHT" | "SIDEBAR";
    }
    
    Defines how participants are arranged in the recording.
    
    OptionalgridSize?: number
    
    Maximum number of participants displayed simultaneously.
    
    Optionalpriority?: "SPEAKER" | "PIN"
    
    Determines participant prioritization.
    
    Optionaltype?: "GRID" | "SPOTLIGHT" | "SIDEBAR"
    
    Layout type for the recording.
  - Optionalmode?: "video-and-audio" | "audio"
    
    Defines whether the recording includes video or audio only.
  - Optionalquality?: "low" | "med" | "high"
    
    Controls the output quality of the recording.
  - Optionaltheme?: "DARK" | "LIGHT" | "DEFAULT"
    
    Visual theme applied to the recording.
- Optionaltranscription: { enabled: boolean; summary?: { enabled: boolean; prompt?: string } }
  Configuration for post-recording transcription and summary generation.
  - enabled: boolean
    
    Enables or disables transcription.
  - Optionalsummary?: { enabled: boolean; prompt?: string }
    
    enabled: boolean
    
    Enables or disables summary generation.
    
    Optionalprompt?: string
    
    Custom prompt used for generating transcription summaries.
Returns Promise<void>
Throws
- Errors.ERROR_ACTION_PERFORMED_BEFORE_MEETING_JOINED — called before meeting is joined
- Errors.ERROR_MEETING_RECONNECTING — meeting is reconnecting
- Errors.START_RECORDING_FAILED — server rejected the request
- Errors.ERROR_OPERATION_TIMED_OUT — the request timed out
Example
```
let meeting;

// Initialize Meeting
meeting = VideoSDK.initMeeting({
  // ...
});

const webhookUrl = "https://webhook.your-api-server.com";

const awsDirPath = "/meeting-recordings/";

const config = {
  layout: {
    type: "SPOTLIGHT",
    priority: "PIN",
    gridSize: 9,
  },
  theme: "DEFAULT",
};

const transcription = {
  enabled: true,
  summary: {
    enabled: true,
  },
};

try {
  await meeting?.startRecording(webhookUrl, awsDirPath, config, transcription);
} catch (err) {
  console.log("Error in startRecording", err);
}
```
- Defined in meeting.d.ts:747

startTranscription

startTranscription(
    options?: {
        modelConfig?: object;
        summary?: { enabled: boolean; prompt?: string };
        webhookUrl?: string;
    },
): Promise<void>
- This method can be used to start real-time transcription for the meeting.
- All participants, including the local participant, will receive the TRANSCRIPTION_STARTING state in the transcription-state-changed event.
Parameters
- Optionaloptions: {
      modelConfig?: object;
      summary?: { enabled: boolean; prompt?: string };
      webhookUrl?: string;
  }
  - OptionalmodelConfig?: object
    
    Optional model configuration used during transcription.
  - Optionalsummary?: { enabled: boolean; prompt?: string }
    
    Configuration for real-time transcription summary generation.
    
    enabled: boolean
    
    Enables or disables summary generation.
    
    Optionalprompt?: string
    
    Custom instructions used to guide summary generation.
  - OptionalwebhookUrl?: string
    
    A webhook URL that will be called whenever the transcription state changes.
Returns Promise<void>
Throws
- Errors.ERROR_ACTION_PERFORMED_BEFORE_MEETING_JOINED — called before meeting is joined
- Errors.ERROR_MEETING_RECONNECTING — meeting is reconnecting
- Errors.START_TRANSCRIPTION_FAILED — server rejected the request
- Errors.ERROR_OPERATION_TIMED_OUT — the request timed out
Example
```
let meeting;

// Initialize Meeting
meeting = VideoSDK.initMeeting({
  // ...
});

const config = {
  webhookUrl: "https://webhook.your-api-server.com",
  summary: {
    enabled: true,
    prompt: "Write summary in sections like Title, Agenda, Speakers, Action Items, and Notes",
  },
};

try {
  await meeting?.startTranscription(config);
} catch (err) {
  console.log("Error in startTranscription", err);
}
```
- Defined in meeting.d.ts:622

startWhiteboard

startWhiteboard(): Promise<void>
- This method can be used to start the whiteboard session.
- All participants, including the local participant, will receive the whiteboard-started event.
Returns Promise<void>
Throws
- Errors.ERROR_ACTION_PERFORMED_BEFORE_MEETING_JOINED — called before meeting is joined
- Errors.ERROR_MEETING_RECONNECTING — meeting is reconnecting
- Errors.START_WHITEBOARD_FAILED — server rejected the request
- Errors.ERROR_OPERATION_TIMED_OUT — the request timed out
- Errors.WHITEBOARD_OPERATION_IN_PROGRESS — a whiteboard operation is already in progress
Example
```
let meeting;

// Initialize Meeting
meeting = VideoSDK.initMeeting({
  // ...
});

try {
  await meeting?.startWhiteboard();
} catch (err) {
  console.log("Error in startWhiteboard", err);
}
```
- Defined in meeting.d.ts:1494

stopHls

stopHls(): Promise<void>
- This method can be used to stop the active HLS stream.
- All participants, including the local participant, will receive the HLS_STOPPING event state in the hls-state-changed event.
Returns Promise<void>
Throws
- Errors.ERROR_ACTION_PERFORMED_BEFORE_MEETING_JOINED — called before meeting is joined
- Errors.ERROR_MEETING_RECONNECTING — meeting is reconnecting
- Errors.STOP_HLS_FAILED — server rejected the request
- Errors.ERROR_OPERATION_TIMED_OUT — the request timed out
Example
```
let meeting;

// Initialize Meeting
meeting = VideoSDK.initMeeting({
  // ...
});

try {
  await meeting?.stopHls();
} catch (err) {
  console.log("Error in stopHls", err);
}
```
- Defined in meeting.d.ts:1040

stopLivestream

stopLivestream(): Promise<void>
- This method can be used to stop the ongoing livestream.
- All participants, including the local participant, will receive the LIVESTREAM_STOPPING state in the livestream-state-changed event.
Returns Promise<void>
Throws
- Errors.ERROR_ACTION_PERFORMED_BEFORE_MEETING_JOINED — called before meeting is joined
- Errors.ERROR_MEETING_RECONNECTING — meeting is reconnecting
- Errors.STOP_LIVESTREAM_FAILED — server rejected the request
- Errors.ERROR_OPERATION_TIMED_OUT — the request timed out
Example
```
let meeting;

// Initialize Meeting
meeting = VideoSDK.initMeeting({
  // ...
});

try {
  await meeting?.stopLivestream();
} catch (err) {
  console.log("Error in stopLivestream", err);
}
```
- Defined in meeting.d.ts:910

stopMediaRelay

stopMediaRelay(destinationMeetingId: string): Promise<void>
- This method can be used to stop the ongoing media relay to a destination meeting.
- Once stopped, the local participant will receive the media-relay-stopped event.
Parameters
- destinationMeetingId: string
  The ID of the destination meeting where media relay should be stopped.
Returns Promise<void>
Throws
- Errors.ERROR_INVALID_PARAMETER — missing destinationMeetingId
- Errors.ERROR_ACTION_PERFORMED_BEFORE_MEETING_JOINED — called before meeting is joined
- Errors.ERROR_MEETING_RECONNECTING — meeting is reconnecting
- Errors.STOP_MEDIA_RELAY_FAILED — server rejected the request
- Errors.ERROR_OPERATION_TIMED_OUT — the request timed out
Example
```
let meeting;

// Initialize Meeting
meeting = VideoSDK.initMeeting({
  // ...
});

try {
  await meeting?.stopMediaRelay("destination-meeting-id");
} catch (err) {
  console.log("Error in stopMediaRelay", err);
}
```
- Defined in meeting.d.ts:1273

stopRecording

stopRecording(): Promise<void>
- This method can be used to stop the ongoing meeting recording.
- All participants, including the local participant, will receive the RECORDING_STOPPING event state in the recording-state-changed event.
Returns Promise<void>
Throws
- Errors.ERROR_ACTION_PERFORMED_BEFORE_MEETING_JOINED — called before meeting is joined
- Errors.ERROR_MEETING_RECONNECTING — meeting is reconnecting
- Errors.STOP_RECORDING_FAILED — server rejected the request
- Errors.ERROR_OPERATION_TIMED_OUT — the request timed out
Example
```
let meeting;

// Initialize Meeting
meeting = VideoSDK.initMeeting({
  // ...
});

try {
  await meeting?.stopRecording();
} catch (err) {
  console.log("Error in stopRecording", err);
}
```
- Defined in meeting.d.ts:795

stopTranscription

stopTranscription(): Promise<void>
- This method can be used to stop the ongoing real-time transcription.
- All participants, including the local participant, will receive the TRANSCRIPTION_STOPPING state in the transcription-state-changed event.
Returns Promise<void>
Throws
- Errors.ERROR_ACTION_PERFORMED_BEFORE_MEETING_JOINED — called before meeting is joined
- Errors.ERROR_MEETING_RECONNECTING — meeting is reconnecting
- Errors.STOP_TRANSCRIPTION_FAILED — server rejected the request
- Errors.ERROR_OPERATION_TIMED_OUT — the request timed out
Example
```
let meeting;

// Initialize Meeting
meeting = VideoSDK.initMeeting({
  // ...
});

try {
  await meeting?.stopTranscription();
} catch (err) {
  console.log("Error in stopTranscription", err);
}
```
- Defined in meeting.d.ts:657

stopWhiteboard

stopWhiteboard(): Promise<void>
- This method can be used to stop the ongoing whiteboard session.
- All participants, including the local participant, will receive the whiteboard-stopped event.
Returns Promise<void>
Throws
- Errors.ERROR_ACTION_PERFORMED_BEFORE_MEETING_JOINED — called before meeting is joined
- Errors.ERROR_MEETING_RECONNECTING — meeting is reconnecting
- Errors.STOP_WHITEBOARD_FAILED — server rejected the request
- Errors.ERROR_OPERATION_TIMED_OUT — the request timed out
- Errors.WHITEBOARD_OPERATION_IN_PROGRESS — a whiteboard operation is already in progress
Example
```
let meeting;

// Initialize Meeting
meeting = VideoSDK.initMeeting({
  // ...
});

try {
  await meeting?.stopWhiteboard();
} catch (err) {
  console.log("Error in stopWhiteboard", err);
}
```
- Defined in meeting.d.ts:1522

switchTo

switchTo(options: { meetingId: string; token?: string }): Promise<void>
- This method can be used to switch the current session to another meeting without disconnecting.
- This allows a seamless transition between meetings while preserving the active session context.
Parameters
- options: { meetingId: string; token?: string }
  Configuration for switching meetings.
  - meetingId: string
    
    The ID of the meeting to switch to.
  - Optionaltoken?: string
    
    Authentication token for the destination meeting.
Returns Promise<void>
Throws
- Errors.ERROR_INVALID_PARAMETER — invalid meetingId
- Errors.SWITCH_MEETING_FAILED — server rejected the switch-meeting request
- Errors.ERROR_OPERATION_TIMED_OUT — the request timed out
- Errors.ERROR_ACTION_PERFORMED_BEFORE_MEETING_JOINED — called before meeting is joined
- Errors.ERROR_MEETING_RECONNECTING — meeting is reconnecting
Example
```
let meeting;

// Initialize Meeting
meeting = VideoSDK.initMeeting({
  // ...
});

try {
  await meeting?.switchTo({
    meetingId: "new-meeting-id",
    token: "optional-auth-token",
  });
} catch (err) {
  console.log("Error in switchTo", err);
}
```
- Defined in meeting.d.ts:1192

unmuteMic

unmuteMic(customAudioTrack?: MediaStream): Promise<void>
- This method can be used to enable the local participant’s microphone.
Events associated with unmuteMic():
- A stream-enabled event is emitted with the corresponding Stream object.
Parameters
- OptionalcustomAudioTrack: MediaStream
  An optional custom audio track to be used instead of the default one.
  
  To learn more, checkout this reference
Returns Promise<void>
Throws
- Errors.ERROR_ACTION_PERFORMED_BEFORE_MEETING_JOINED — called before meeting is joined
- Errors.ERROR_MEETING_RECONNECTING — meeting is reconnecting
- Errors.ERROR_ACTION_NOT_SUPPORTED_IN_MODE — not allowed in viewer/RECV_ONLY mode
- Errors.ERROR_OPERATION_IN_PROGRESS — change-mode / mic-enable / mic-disable already in flight
- Errors.ERROR_ALREADY_IN_REQUESTED_STATE — mic is already enabled
- Errors.ERROR_MEDIA_DEVICE_NOT_LOADED — media device not loaded
- Errors.ERROR_MICROPHONE_ACCESS_UNAVAILABLE — microphone access unavailable
- Errors.ERROR_MEDIA_DEVICE_NOT_INITIALIZED — media device not initialized
- Errors.ERROR_NO_MICROPHONE_DEVICE_FOUND — no microphone device found
- Errors.ERROR_MEDIA_NOT_READY — transport not ready
- Errors.ERROR_MICROPHONE_PRODUCE_FAILED — microphone track could not be published
- Errors.ERROR_OPERATION_TIMED_OUT — the request timed out
Example
```
let meeting;

// Initialize Meeting
meeting = VideoSDK.initMeeting({
  // ...
});

try {
  await meeting?.unmuteMic();
} catch (err) {
  console.log("Error in unmuteMic", err);
}
```
- Defined in meeting.d.ts:369

uploadBase64File

uploadBase64File(
options: { base64Data: string; fileName: string; token: string },
): Promise<string>
- This method can be used to upload a file to VideoSDK's temporary storage.
- This method returns a fileUrl, which can later be used to retrieve the uploaded file.
Parameters
- options: { base64Data: string; fileName: string; token: string }
  - base64Data: string
    
    Base64-encoded representation of the file.
  - fileName: string
    
    Name of the file including its extension.
  - token: string
    
    VideoSDK authentication token. Learn more about tokens here.
Returns Promise<string>
Throws
- Errors.ERROR_INVALID_PARAMETER — missing or invalid options (base64Data / token / fileName)
- Errors.ERROR_FILE_UPLOAD_FAILED — server rejected the upload request
Example
```
try {
  const fileUrl = await meeting.uploadBase64File({
    base64Data: "<BASE64_DATA>", // Convert your file to base64 and pass here
    token: "<VIDEOSDK_TOKEN>",
    fileName: "image.jpeg", // Provide name with extension here,
  });

  console.log("File URL:", fileUrl);
} catch (err) {
  console.log("Error in uploadBase64File", err);
}
```
- Defined in meeting.d.ts:1557

Class Meeting

Index

Constructors

Properties

Methods

Constructors

constructor

Returns Meeting

Properties

activePresenterId

activeSpeakerId

hlsState

hlsUrls

id

isE2EEEnabled

livestreamState

localParticipant

mainParticipantId

participants

pinnedParticipants

pubSub

realtimeStore

recordingState

selectedCameraDevice

selectedMicrophoneDevice

transcriptionState

Methods

changeMic

Parameters

Returns Promise<void>

Throws

Example

changeMode

Parameters

Returns Promise<void>

Throws

Example

changeWebcam

Parameters

Returns Promise<void>

Throws

Example

disableAdaptiveSubscription

Returns Promise<void>

Throws

Example

disableScreenShare

Returns Promise<void>

Throws

Example

disableWebcam

Returns Promise<void>

Throws

Example

enableAdaptiveSubscription

Returns Promise<void>

Throws

Example

enableScreenShare

Parameters

Returns Promise<void>

Throws

Example

enableWebcam

Parameters

Returns Promise<void>

Throws

Example

end

Returns Promise<void>

Throws

Example

fetchBase64File

Parameters

token: string

url: string

Returns Promise<string>

Throws

Example

getMics

Returns Promise<
{ deviceId: string; facingMode: "environment"
| "front"; label: string }[],
>

`Optional`kinds?: ("audio" | "video" | "share")[]

`Optional`token?: string

`Optional`reliability?: "RELIABLE" | "UNRELIABLE"

`Optional`layout?: {
gridSize?: number;
priority?: "SPEAKER" | "PIN";
type?: "GRID" | "SPOTLIGHT" | "SIDEBAR";
}

`Optional`gridSize?: number

`Optional`priority?: "SPEAKER" | "PIN"

`Optional`type?: "GRID" | "SPOTLIGHT" | "SIDEBAR"

`Optional`mode?: "video-and-audio" | "audio"

`Optional`quality?: "low" | "med" | "high"