# isReady

Example

if (client.isReady) {
  // Safe to perform operations
  await client.createRoom({ roomName: 'my-room', userId: 'my-user' });
}

# async admitWaitingRoomUser(options) → {Promise.<void>}

Parameters:

Example

// Handle waiting room admit event
client.addEventListener(ClientEvents.ADMIT_WAITING_ROOM, async (e) => {
  const { userId, userName } = e.detail;
  if (confirm(`Admit ${userName}?`)) {
    await client.admitWaitingRoomUser({ userToAdmit: userId });
  }
});

# async applyAudioOutputToElement(element) → {Promise.<boolean>}

Parameters:

Example

client.addEventListener('media-track-added', async (event) => {
  const { userId, track, kind } = event.detail;
  if (kind === 'audio' || kind === 'video') {
    const element = document.getElementById(`remote-video-${userId}`);
    element.srcObject = new MediaStream([track]);
    await client.applyAudioOutputToElement(element);
  }
});

# checkAudioDevice() → {boolean}

Example

if (!client.checkAudioDevice()) {
  console.warn('Audio not supported on this device');
}

# checkVideoDevice() → {boolean}

Example

if (!client.checkVideoDevice()) {
  console.warn('Video not supported on this device');
}

# async closeConnection() → {Promise.<void>}

Example

document.getElementById('leave-btn').onclick = async () => {
  await client.closeConnection();
  console.log('Left the room');
  window.location.href = '/';
};

# async closeNoVideoRoom() → {Promise.<void>}

Example

await client.closeNoVideoRoom();
console.log('Audio-only room closed');

# async connectTransports(params) → {Promise.<void>}

Parameters:

Examples

// Standard connection with video
await client.connectTransports({
  localVideoElementId: 'local-video',
  options: { enableGainControl: true }
});

// Audio-only mode (no camera)
await client.connectTransports({
  localVideoElementId: 'local-video',
  audioOnly: true
});

// Video-only mode (no microphone — e.g. phone used as extra camera)
await client.connectTransports({
  localVideoElementId: 'local-video',
  videoOnly: true
});

# async copyPublicFileToPrivate(params) → {Promise.<object>}

Parameters:

# async createFolder(options) → {Promise.<FileMetadata>}

Parameters:

Example

const folder = await fileManager.createFolder({
  location: "/presentations/quarterly"
});
console.log(`Created folder with ID: ${folder.fileId}`);

# async createJoinToken(options) → {Promise.<Object>}

Parameters:

Example

// Create a group join token (anyone with this token can join)
const { joinToken, roomRegion } = await client.createJoinToken({
  userId: 'host123',
  roomName: 'team-meeting',
  expiresIn: 3600, // 1 hour
  type: 'group'
});
const inviteUrl = `https://app.com/join?token=${joinToken}&region=${roomRegion}`;

# async createNoVideoRoom(options) → {Promise.<Room>}

Parameters:

Example

const room = await client.createNoVideoRoom({
  roomName: 'audio-conference',
  userId: 'host123'
});
console.log('Audio-only room created:', room.name);

# async createRoom(options) → {Promise.<Room>}

Parameters:

Example

const room = await client.createRoom({
  roomName: 'team-standup',
  userId: 'host123',
  externalUserId: 'app-user-abc',
  options: {
    inactivityTimeout: 120,
    requireWaitingRoom: true
  }
});
console.log('Room created:', room.name);

# async deleteFile(options) → {Promise.<boolean>}

Parameters:

Example

await fileManager.deleteFile({
  fileId: "abc123"
});

# async deleteFolder(options) → {Promise.<boolean>}

Parameters:

Example

await fileManager.deleteFolder({
  location: "/old-documents"
});

# async getAllUsersFiles() → {Promise.<Array.<FileMetadata>>}

Example

const allFiles = await fileManager.getAllUsersFiles();
console.log(`Found ${allFiles.length} files`);

# async getAllUsersFilesSinceLastSync(options) → {Promise.<Array.<FileMetadata>>}

Parameters:

Example

const changedFiles = await fileManager.getAllUsersFilesSinceLastSync({
  lastSyncTime: Date.now() - 3600000 // Changes in the last hour
});

# async getAttendees() → {Promise.<Array>}

Example

const attendees = await client.getAttendees();
console.log(`${attendees.length} participants in room`);
attendees.forEach(a => console.log('User:', a.userId));

# getAudioGainControl() → {GainProcessor|null}

Example

// Adjust microphone volume
const gainControl = client.getAudioGainControl();
if (gainControl) {
  document.getElementById('volume-slider').oninput = (e) => {
    gainControl.setGain(e.target.value / 100);
  };
}

# getAudioInputMonitor() → {AudioInputProcessor|null}

Example

// Create audio level visualization
const monitor = client.getAudioInputMonitor();
if (monitor) {
  monitor.on('level', (level) => {
    volumeMeter.style.width = (level * 100) + '%';
  });
}

# getAudioMode() → {string}

Example

const mode = client.getAudioMode();
console.log('Audio mode:', mode); // 'default', 'music', 'presentation', or 'custom'

# getAudioOutputDeviceId() → {string|null}

Example

const speakerId = client.getAudioOutputDeviceId();
console.log('Current speaker:', speakerId);

# getAudioValidation() → {Object|null}

Example

const validation = client.getAudioValidation();
if (!validation.isValid) {
  console.warn('Audio issues:', validation.issues);
  console.info('Recommendations:', validation.recommendations);
}

# getBandwidthMonitor() → {BandwidthMonitor|null}

Example

// Monitor video quality in real-time
const monitor = client.getBandwidthMonitor();
if (monitor) {
  monitor.on('stats', (stats) => {
    console.log('Bitrate:', stats.bitrate, 'FPS:', stats.fps);
  });
}

# async getChatHistory(options) → {Promise.<Object>}

Parameters:

Example

// Load chat history with pagination
let cursor = null;
const loadMessages = async () => {
  const { messages, nextCursor } = await client.getChatHistory({ cursor });
  messages.forEach(msg => console.log(msg.userId + ': ' + msg.message));
  cursor = nextCursor;
};

# async getCompositionList(options) → {Promise.<Array>}

Parameters:

Example

// List all compositions for a room
const compositions = await client.getCompositionList({
  roomName: 'my-room',
  userId: 'user456'
});
compositions.forEach(c => console.log('Composition:', c.recordingId));

# async getCompositionStatus(options) → {Promise.<String>}

Parameters:

Example

// Poll composition status until complete
const checkStatus = async () => {
  const status = await client.getCompositionStatus({
    recordingId: 'rec123',
    roomName: 'my-room',
    userId: 'user456'
  });
  console.log('Composition status:', status);
};

# async getCompositionUrl(options) → {Promise.<String>}

Parameters:

Example

// Get the composed video URL for playback
const url = await client.getCompositionUrl({
  recordingId: 'rec123',
  roomName: 'my-room',
  userId: 'user456'
});
videoPlayer.src = url;

# async getFileMetadata(options) → {Promise.<FileMetadata>}

Parameters:

Example

const metadata = await fileManager.getFileMetadata({
  fileId: "abc123"
});
console.log(`File name: ${metadata.fileName}`);

# async getFileURL(options) → {Promise.<string>}

Parameters:

Example

// Download URL (default)
const downloadUrl = await fileManager.getFileURL({ fileId: "abc123" });

// Inline streaming URL (for video playback, image preview, etc.)
const streamUrl = await fileManager.getFileURL({ fileId: "abc123", stream: true });
videoEl.src = streamUrl;

# getLocalAudioConstraints() → {AudioConstraints|null}

Example

const constraints = client.getLocalAudioConstraints();
console.log('Echo cancellation:', constraints?.echoCancellation);

# getLocalAudioInputDeviceId() → {string|null}

Example

const micId = client.getLocalAudioInputDeviceId();
console.log('Current microphone:', micId);

# getLocalVideoDeviceId() → {string|null}

Example

const cameraId = client.getLocalVideoDeviceId();
console.log('Current camera:', cameraId);

# async getLookupUrls() → {Promise.<(Object|undefined)>}

Example

const urls = await client.getLookupUrls();
console.log('Lookup URLs:', urls);

# async getPublicFiles(params) → {Promise.<{files: Array.<object>}>}

Parameters:

# getRecordingId() → {string|null}

Example

const recordingId = client.getRecordingId();
if (recordingId) {
  console.log('Currently recording:', recordingId);
}

# async getRecordingUrls(options) → {Promise.<Array>}

Parameters:

Example

// Get individual recording URLs for each participant
const urls = await client.getRecordingUrls({
  recordingId: 'rec123',
  roomName: 'my-room',
  userId: 'user456'
});
urls.forEach(url => console.log('Recording:', url));

# async getRelayToken(options) → {Promise.<{token: string, url: string, certHashes: Array.<{algorithm: string, valueHex: string}>, expiresAt: number}>}

Parameters:

Examples

// Authenticated (caller already joined the room via createRoom/joinRoom):
const bundle = await client.getRelayToken({
  roomName: room.roomName,
  userId: room.userId,
  roomRegion: room.roomRegion,
});

// Guest (caller arrived via invite link):
const bundle = await client.getRelayToken({
  roomName: room.roomName,
  userId: 'guest-display-name',
  roomRegion: 'us-west-2',
  joinToken: params.get('joinToken'),
});

# getRemoteUserMediaStatus(userId) → {Object}

Parameters:

Example

const status = client.getRemoteUserMediaStatus('user123');
if (!status.hasVideo) {
  showAudioOnlyAvatar('user123');
}

# async getRoomNameFromToken(options) → {Promise.<Object>}

Parameters:

Example

const { roomName, isActive } = await client.getRoomNameFromToken({
  joinToken: params.get('token'),
  roomRegion: params.get('region'),
  userId: 'guest789'
});
if (isActive) {
  showJoinButton(roomName);
} else {
  showRoomInactiveMessage();
}

# async getRoomSummary(fileId) → {Promise.<Object>}

Parameters:

# async getRoomUserIds() → {Promise.<Array.<string>>}

Example

// Get all users who have participated in this room
const userIds = await client.getRoomUserIds();
console.log('Past participants:', userIds);

# async getSignedCompositionUrl(options) → {Promise.<String>}

Parameters:

Example

// Get a signed URL for downloading a composition
const compositionUrl = await client.getCompositionUrl({...});
const signedUrl = await client.getSignedCompositionUrl({
  url: compositionUrl
});
window.location.href = signedUrl; // Trigger download

# async getStats() → {Promise.<Object>}

Example

// Display connection stats in debug panel
const stats = await client.getStats();
console.log('Transport stats:', stats);

# getStreamingId() → {string|null}

Example

const streamingId = client.getStreamingId();
if (streamingId) {
  console.log('Currently streaming:', streamingId);
}

# async getStreamingUrls(options) → {Promise.<Array>}

Parameters:

Example

// Get streaming playback URLs
const urls = await client.getStreamingUrls({
  streamingId: 'stream123',
  roomName: 'my-room',
  userId: 'user456'
});
console.log('Stream URLs:', urls);

# async getSymbols()

# getTranscribingId() → {string|null}

Example

const transcribingId = client.getTranscribingId();
if (transcribingId) {
  console.log('Transcription active:', transcribingId);
}

# async getTranscriptionStatus(options) → {Promise.<String>}

Parameters:

Example

// Check transcription status
const status = await client.getTranscriptionStatus({
  recordingId: 'rec123',
  roomName: 'my-room',
  userId: 'user456'
});
console.log('Transcription status:', status);

# async getTranscriptionSummary(options) → {Promise.<Object>}

Parameters:

Example

// Display meeting summary after transcription completes
const summary = await client.getTranscriptionSummary({
  recordingId: 'rec123',
  userId: 'user456'
});
document.getElementById('summary').textContent = summary.text;

# async getUsersFileTypes() → {Promise.<Array.<string>>}

Example

const fileTypes = await fileManager.getUsersFileTypes();
console.log("Available file types:", fileTypes);
// Example output: ["document", "image", "presentation"]

# async getUsersFilesOfType(options) → {Promise.<Array.<FileMetadata>>}

Parameters:

Example

const presentations = await fileManager.getUsersFilesOfType({
  resourceType: "presentation"
});
console.log(`Found ${presentations.length} presentations`);

# async initFileOps(options) → {Promise.<void>}

Parameters:

Example

const client = new Client({ roomToken: 'your-token' });
await client.initFileOps({ userId: 'user@example.com' });
await client.shareFile({ fileId: 'abc', userIds: ['other@example.com'], sharedRoom: 'my-room' });

# isAudioOnly() → {boolean}

Example

if (client.isAudioOnly()) {
  hideCameraControls();
}

# isAudioOutputSelectionSupported() → {boolean}

Example

if (client.isAudioOutputSelectionSupported()) {
  showSpeakerSelector();
} else {
  console.log('Speaker selection not supported');
}

# isConnected() → {boolean}

Example

if (client.isConnected()) {
  console.log('Connected to room');
  await client.sendChatMessage({ message: 'Hello!' });
} else {
  console.log('Not connected - attempting to reconnect');
}

# isLocalAudioPaused() → {boolean}

Example

const micBtn = document.getElementById('mic-btn');
micBtn.classList.toggle('muted', client.isLocalAudioPaused());

# isLocalOutputPaused() → {boolean}

Example

const speakerBtn = document.getElementById('speaker-btn');
speakerBtn.classList.toggle('muted', client.isLocalOutputPaused());

# isLocalUserRoomOwner() → {boolean}

Example

if (client.isLocalUserRoomOwner()) {
  // Show host controls
  showRecordingButton();
  showMuteAllButton();
}

# isLocalVideoPaused() → {boolean}

Example

const camBtn = document.getElementById('cam-btn');
camBtn.classList.toggle('off', client.isLocalVideoPaused());

# isRemoteUserAudioOnly(userId) → {boolean}

Parameters:

Example

if (client.isRemoteUserAudioOnly('user123')) {
  showAudioOnlyIndicator('user123');
}

# isScreenShareActive() → {boolean}

Example

const shareBtn = document.getElementById('share-btn');
shareBtn.textContent = client.isScreenShareActive() ? 'Stop Sharing' : 'Share Screen';

# async joinNoVideoRoom(options) → {Promise.<Room>}

Parameters:

Example

const room = await client.joinNoVideoRoom({
  roomName: 'audio-conference',
  userId: 'participant456'
});
console.log('Joined audio-only room:', room.name);

# async joinRoom(options) → {Promise.<Room>}

Parameters:

Example

try {
  const room = await client.joinRoom({
    roomName: 'team-standup',
    userId: 'participant456',
    externalUserId: 'app-user-xyz'
  });
  console.log('Joined room:', room.name);
} catch (err) {
  console.error('Failed to join room:', err.message);
}

# async joinRoomWithToken(options) → {Promise.<Room>}

Parameters:

Example

// Parse token and region from invite URL
const params = new URLSearchParams(window.location.search);
const room = await client.joinRoomWithToken({
  joinToken: params.get('token'),
  roomRegion: params.get('region'),
  userId: 'guest789'
});

# joinRoomWithTokenAndWait(options) → {Object}

Parameters:

Example

// Basic usage
const { abortController, promise } = client.joinRoomWithTokenAndWait({
  joinToken: 'abc123',
  userId: 'user1',
  roomRegion: 'us-east-1',
  timeout: 300000 // 5 minutes
});

// Listen for status events
client.addEventListener('wait-for-host-started', (e) => {
  showUI(`Waiting for host to start "${e.detail.roomName}"...`);
});

client.addEventListener('wait-for-host-room-ready', () => {
  showUI('Host has started the meeting, joining...');
});

// Cancel button handler
cancelButton.onclick = () => abortController.abort();

// Await the result
try {
  const room = await promise;
  console.log('Joined room:', room.name);
} catch (err) {
  if (err.name === 'AbortError') {
    console.log('User cancelled');
  } else {
    console.error('Failed to join:', err.message);
  }
}

# async listAudioInputDevices() → {Promise.<Array.<MediaDeviceInfo>>}

Example

const mics = await client.listAudioInputDevices();
mics.forEach(mic => {
  console.log(`${mic.label} (${mic.deviceId})`);
});

# async listAudioOutputDevices() → {Promise.<Array.<MediaDeviceInfo>>}

Example

const speakers = await client.listAudioOutputDevices();
speakers.forEach(spk => {
  console.log(`${spk.label} (${spk.deviceId})`);
});

# async listVideoDevices() → {Promise.<Array.<MediaDeviceInfo>>}

Example

const cameras = await client.listVideoDevices();
cameras.forEach(cam => {
  console.log(`${cam.label} (${cam.deviceId})`);
});

# mergeAudioInput(options)

Parameters:

Example

// Add background music to the call
const audio = new Audio('background-music.mp3');
const musicStream = audio.captureStream();
client.mergeAudioInput({ stream: musicStream });

# async modifyFile(options) → {Promise.<FileMetadata>}

Parameters:

Example

await fileManager.modifyFile({
  file: updatedFileObject,
  fileId: "abc123"
});

The file object must contain:
- type: the file extension
- mimeType: the file mime type
- name: the file name
- owner: the file owner

# async moveFile(options) → {Promise.<FileMetadata>}

Parameters:

Example

await fileManager.moveFile({
  fileId: "abc123",
  newLocation: "/archive/2024"
});

# async muteLocalAudio(muteAudio, overRideopt) → {Promise.<Object>}

Parameters:

Example

// Toggle microphone mute
document.getElementById('mic-btn').onclick = async () => {
  const isMuted = client.isLocalAudioPaused();
  await client.muteLocalAudio(!isMuted);
};

# async muteLocalOutput(muteOutput, overRideopt) → {Promise.<Object>}

Parameters:

Example

// Toggle speaker mute
document.getElementById('speaker-btn').onclick = async () => {
  const isMuted = client.isLocalOutputPaused();
  await client.muteLocalOutput(!isMuted);
};

# async muteLocalVideo(muteVideo, overRideopt) → {Promise.<Object>}

Parameters:

Example

// Toggle camera on/off
document.getElementById('cam-btn').onclick = async () => {
  const isOff = client.isLocalVideoPaused();
  await client.muteLocalVideo(!isOff);
};

# async muteRemoteAudio(options) → {Promise.<Object>}

Parameters:

Example

// Host mutes a participant's microphone
if (client.isLocalUserRoomOwner()) {
  await client.muteRemoteAudio({ room, userId: 'user123', muteAudio: true });
}

# async muteRemoteOutput(options) → {Promise.<Object>}

Parameters:

Example

// Host mutes a participant's speakers
if (client.isLocalUserRoomOwner()) {
  await client.muteRemoteOutput({ room, userId: 'user123', muteOutput: true });
}

# async muteRemoteVideo(options) → {Promise.<Object>}

Parameters:

Example

// Host turns off a participant's camera
if (client.isLocalUserRoomOwner()) {
  await client.muteRemoteVideo({ room, userId: 'user123', muteVideo: true });
}

# async ready() → {Promise.<Client>}

Example

const client = new Client({ roomToken: 'your-token' });
await client.ready(); // Wait for browser-specific initialization
const devices = await client.listVideoDevices(); // Now safe to enumerate

# async reconnect(params) → {Promise.<void>}

Parameters:

Example

client.addEventListener(ClientEvents.DISCONNECTED, async () => {
  console.log('Connection lost, attempting reconnect...');
  await client.reconnect({ options: { enableGainControl: true } });
});

# async rejectWaitingRoomUser(options) → {Promise.<void>}

Parameters:

Example

// Reject a user from the waiting room
await client.rejectWaitingRoomUser({ userToReject: 'user123' });

# async sendChatMessage(options) → {Promise.<void>}

Parameters:

Example

// Send a text message to all participants
document.getElementById('send-btn').onclick = async () => {
  const text = document.getElementById('chat-input').value;
  await client.sendChatMessage({ message: text });
};

# async sendDataMessage(options) → {Promise.<void>}

Parameters:

Example

// Send custom data to all participants
await client.sendDataMessage({
  message: { type: 'cursor', x: 100, y: 200 }
});
// Or send to specific user
await client.sendDataMessage({
  userId: 'user123',
  message: { type: 'private', data: 'hello' }
});

# setActiveRoom(roomName)

Parameters:

Example

await client.createNoVideoRoom({ roomName: 'room-a', userId: 'user1' });
// later, switch to a different room for file ops
client.setActiveRoom('room-b');
await client.uploadFile({ file, location: '/' });

# setAudioMode(mode)

Parameters:

Example

// Set to music mode for better fidelity without echo cancellation
client.setAudioMode('music');

// Set to presentation mode for optimized voice with echo cancellation
client.setAudioMode('presentation');

# async setAudioOutputDevice(options) → {Promise.<{success: boolean, updatedElements: number, errors: Array}>}

Parameters:

Example

const speakers = await client.listAudioOutputDevices();
const result = await client.setAudioOutputDevice({
  audioOutputDeviceId: speakers[0].deviceId
});
console.log(`Updated ${result.updatedElements} elements`);

# setCustomAudioConfig(config)

Parameters:

Example

client.setCustomAudioConfig({
  echoCancellation: true,
  noiseSuppression: false,
  autoGainControl: true
});

# setFileOpsRoomName(roomName)

Parameters:

# async setLocalAudioInputDevice(options) → {Promise.<(MediaStream|null)>}

Parameters:

Example

const mics = await client.listAudioInputDevices();
await client.setLocalAudioInputDevice({
  audioInputDeviceId: mics[0].deviceId,
  constraints: { echoCancellation: true }
});

# async setLocalVideoDevice(options)

Parameters:

Example

const cameras = await client.listVideoDevices();
await client.setLocalVideoDevice({
  videoDeviceId: cameras[1].deviceId // Switch to second camera
});

# async shareFile(options) → {Promise.<FileMetadata>}

Parameters:

Example

// Share a file with two users
await fileManager.shareFile({
  fileId: "abc123",
  userIds: ["user1", "user2"]
});

// Remove all sharing
await fileManager.shareFile({
  fileId: "abc123",
  userIds: []
});

# async startComposition(options) → {Promise.<void>}

Parameters:

Example

// Start composition after recording stops
const recordingId = client.getRecordingId();
await client.stopRecording();
await client.startComposition({ recordingId });

# async startRecording(params) → {Promise.<string>}

Parameters:

Example

// Start cloud recording with live transcription
document.getElementById('record-btn').onclick = async () => {
  try {
    const recordingId = await client.startRecording({
      type: 'cloud',
      options: {
        autoCompose: true,
        transcribe: true,
        postMeetingSummary: true
      }
    });
    console.log('Recording started:', recordingId);
  } catch (err) {
    console.error('Failed to start recording:', err.message);
  }
};

# async startScreenShare() → {Promise.<void>}

Example

document.getElementById('share-btn').onclick = async () => {
  if (client.isScreenShareActive()) {
    await client.stopScreenShare();
  } else {
    await client.startScreenShare();
  }
};

# async startStreaming(params) → {Promise.<string>}

Parameters:

Examples

// Start cloud streaming with MP4 file creation
document.getElementById('stream-btn').onclick = async () => {
  try {
    const streamingId = await client.startStreaming({
      type: 'cloud',
      options: { create_mp4: true }
    });
    console.log('Streaming started:', streamingId);
  } catch (err) {
    console.error('Failed to start streaming:', err.message);
  }
};

// Start streaming to YouTube with multi-participant view
// Note: create_mp4 is not available when using rtmpUrl
const streamingId = await client.startStreaming({
  type: 'cloud',
  options: {
    mode: 'multi',
    rtmpUrl: 'rtmp://a.rtmp.youtube.com/live2/your-stream-key'
  }
});

# async startTranscribing() → {Promise.<string>}

Example

// Start live transcription
document.getElementById('transcribe-btn').onclick = async () => {
  try {
    const transcribingId = await client.startTranscribing();
    console.log('Transcription started:', transcribingId);
  } catch (err) {
    console.error('Failed:', err.message);
  }
};

# async startTranscription(options) → {Promise.<void>}

Parameters:

Example

// Start post-recording transcription
await client.startTranscription({ recordingId: 'rec123' });
// Then poll getTranscriptionStatus() until complete

# stopDevices()

Example

// Stop camera and microphone before leaving page
window.addEventListener('beforeunload', () => {
  client.stopDevices();
});

# async stopRecording() → {Promise.<void>}

Example

// Stop recording and get URLs
document.getElementById('stop-record-btn').onclick = async () => {
  const recordingId = client.getRecordingId();
  await client.stopRecording();
  console.log('Recording stopped, use getRecordingUrls() to access files');
};

# async stopScreenShare() → {Promise.<void>}

Example

await client.stopScreenShare();
console.log('Screen sharing stopped');

# async stopStreaming() → {Promise.<void>}

Example

// Stop streaming
document.getElementById('stop-stream-btn').onclick = async () => {
  await client.stopStreaming();
  console.log('Streaming stopped');
};

# async stopTranscribing() → {Promise.<Object>}

Example

// Stop transcription
document.getElementById('stop-transcribe-btn').onclick = async () => {
  await client.stopTranscribing();
  console.log('Transcription stopped');
};

# async switchStreamingUser(options) → {Promise.<Object>}

Parameters:

Example

// Switch stream to a specific user
const switchToSpeaker = async (userId) => {
  await client.switchStreamingUser({ userToSwitchTo: userId });
  console.log('Stream now focused on:', userId);
};

# unmergeAudioInput(options)

Parameters:

Example

// Stop background music
client.unmergeAudioInput({ stream: musicStream });

# async updateFileAppData(options) → {Promise.<Object>}

Parameters:

# async updateFilename(options) → {Promise.<FileMetadata>}

Parameters:

Example

await fileManager.updateFilename({
  fileId: "abc123",
  newFilename: "new-name.txt"
});

# async uploadFile(options) → {Promise.<FileMetadata>}

Parameters:

Example

const fileMetadata = await fileManager.uploadFile({
  file: document.getElementById('fileInput').files[0],
  location: "/documents",
  resourceType: "presentation"
});
console.log(`Uploaded file with ID: ${fileMetadata.fileId}`);