JitsiConference

const conference = connection.initJitsiConference('room-name', {
    openBridgeChannel: 'websocket',
    p2p: { enabled: true },
    startAudioMuted: 10,
    startVideoMuted: 10
});

// Join the conference
await conference.join(password?);

conference.on(JitsiConferenceEvents.CONFERENCE_JOINED, () => {
    console.log('Successfully joined conference');
});

// Leave the conference
await conference.leave();

conference.on(JitsiConferenceEvents.CONFERENCE_LEFT, () => {
    console.log('Left conference');
});

/**
 * A new user joined the conference.
 */
USER_JOINED = 'conference.userJoined',

/**
 * A user has left the conference.
 */
USER_LEFT = 'conference.userLeft',

/**
 * User role changed.
 */
USER_ROLE_CHANGED = 'conference.roleChanged',

/**
 * A new media track was added to the conference.
 * @param {JitsiTrack} track the added JitsiTrack
 */
TRACK_ADDED = 'conference.trackAdded',

/**
 * Audio levels of a media track (attached to the conference) was changed.
 */
TRACK_AUDIO_LEVEL_CHANGED = 'conference.audioLevelsChanged',

/**
 * A media track (attached to the conference) mute status was changed.
 * @param {JitsiParticipant|null} the participant that initiated the mute if it is a remote mute.
 */
TRACK_MUTE_CHANGED = 'conference.trackMuteChanged',

/**
 * The media track was removed from the conference.
 * @param {JitsiTrack} track the removed JitsiTrack
 */
TRACK_REMOVED = 'conference.trackRemoved',

/**
 * Indicates that the connection to the conference has been established
 * XXX This is currently fired when the *ICE* connection enters 'connected' state for the first time.
 */
CONNECTION_ESTABLISHED = 'conference.connectionEstablished',

/**
 * Indicates that the connection to the conference has been interrupted
 * XXX This is currently fired when the *ICE* connection is interrupted.
 */
CONNECTION_INTERRUPTED = 'conference.connectionInterrupted',

/**
 * Indicates that the connection to the conference has been restored.
 * XXX This is currently fired when the *ICE* connection is restored.
 */
CONNECTION_RESTORED = 'conference.connectionRestored',

// Get all participants (excluding local)
const participants = conference.getParticipants();

// Get participant by ID  
const participant = conference.getParticipantById(participantId);

// Get participant count
const count = conference.getParticipantCount();

// Get local participant ID
const myId = conference.myUserId();

/**
 * List of all the participants in the conference.
 * @type {Map<string, JitsiParticipant>}
 */
this.participants = new Map();

await conference.kickParticipant(participantId, reason);

// Mute participant's audio
await conference.muteParticipant(participantId, MediaType.AUDIO);

// Mute participant's video
await conference.muteParticipant(participantId, MediaType.VIDEO);

const localTracks = await JitsiMeetJS.createLocalTracks({
    devices: ['audio', 'video']
});

for (const track of localTracks) {
    await conference.addTrack(track);
}

await conference.removeTrack(localTrack);

// Replace a track (e.g., switch camera)
await conference.replaceTrack(oldTrack, newTrack);

// Get all local tracks
const localTracks = conference.getLocalTracks();

// Get local tracks by media type
const audioTracks = conference.getLocalTracks(MediaType.AUDIO);
const videoTracks = conference.getLocalTracks(MediaType.VIDEO);

interface IConferenceProperties {
    'audio-limit-reached'?: string;
    'bridge-count'?: string;
    'video-limit-reached'?: string;
    'visitor-codecs'?: string;
    'visitor-count'?: number;
}

const properties = conference.getProperties();

/**
 * Flag set to <tt>true</tt> when P2P session has been established
 * and this conference is currently in the peer to peer mode.
 * @type {boolean}
 */
this.p2p = false;

conference.on(JitsiConferenceEvents.P2P_STATUS, (conference, isP2P) => {
    console.log('P2P mode:', isP2P);
});

// Receive video from 5 participants  
conference.setLastN(5);

// Receive video from all participants
conference.setLastN(-1);

// Get current LastN
const lastN = conference.getLastN();

conference.setReceiverConstraints({
    lastN: 5,
    selectedEndpoints: ['endpoint1', 'endpoint2'],
    onStageEndpoints: ['endpoint1'],
    defaultConstraints: { maxHeight: 720 },
    constraints: {
        'endpoint1': { maxHeight: 1080 }
    }
});

// Lock with password
await conference.lock(password);

// Unlock
await conference.lock();

// Check lock state
const isLocked = conference.lock();

// Set subject
conference.setSubject('Team Standup Meeting');

// Get subject  
const subject = conference.getSubject();

// Start recording
await conference.startRecording({
    mode: 'file',  // or 'stream'
    appData: JSON.stringify({ customData: 'value' })
});

// Stop recording
await conference.stopRecording(sessionID);

// Listen for recording state
conference.on(JitsiConferenceEvents.RECORDER_STATE_CHANGED, (session) => {
    console.log('Recording state:', session.getStatus());
});

// Start transcription
conference.setLocalParticipantProperty('transcription_language', 'en-US');

if (this.isE2EESupported()) {
    logger.info('End-to-End Encryption is supported');
    this._e2eEncryption = new E2EEncryption(this);
}

if (conference.isE2EESupported()) {
    // Enable E2EE
    conference.toggleE2EE(true);
}