Media API v1 › Enums

Enums

String-backed enums used across the API. Both the enum constant and the underlying string value are accepted everywhere — pick whichever style you prefer.

MediaKind

Identifies the kind of media. Used in subscribe / unsubscribe calls.

Screen audio is bundled into Screen — there is no separate ScreenAudio kind. Whether screen audio is included is controlled at publish time via PublishScreenOpts.audio.

import { MediaKind } from '@videosdk/js';

await p.subscribe([MediaKind.Audio, MediaKind.Video]);
await p.subscribe(['audio', 'video']);  // strings also work

StreamState

Combined state of a remote stream. Read via stream.streamState; transitions are delivered via the stream's state-changed event. Two sources are merged into one value: server-driven routing state (always present) and client-observed decoder health (RemoteVideoStream / RemoteScreenStream).

Per-stream-type unions — each subtype only ever produces values that make sense for its medium:

• RemoteVideoStream: "active" | "paused" | "frozen" | "stuck" | "ended"
• RemoteScreenStream: "active" | "paused" | "frozen" | "stuck" | "ended"
• RemoteAudioStream: "active" | "paused" | "ended"

No separate frozen / unfrozen / stuck / ended events. All transitions flow through the single state-changed event with the corresponding state value.

Bandwidth-driven simulcast layer changes are a separate axis — see MediaQuality and the quality-changed event on RemoteVideoStream / RemoteScreenStream. The stream stays "active" when the layer switches.

Routing vs decoder priority: when both axes have non-default values (e.g. routing is paused AND decoder was frozen at the time), the merged streamState reports the routing value — routing is server-authoritative.

MediaQuality

Receive-side simulcast layer selection. Used in setPreferredQuality (pick preferred layer to receive) and reported back via currentQuality + the quality-changed event.

Receive-side only. Publish-side layer count is configured via PublishVideoOpts.maxLayer + multiStream; capture height via resolution; bitrate via bitrateMode / maxBitrate.

"auto" is only an input value (to setPreferredQuality). The reported currentQuality getter and quality-changed event payload always carry a concrete layer — "high", "medium", or "low".

VideoCodec

Preferred video codec for publishing. Used in PublishVideoOpts.codec. Best-effort — if the chosen codec isn't supported by the browser or SFU, the SDK falls back silently. Apps that need a guarantee read stream.codec after publish.

DegradationPreference

What to drop first under bandwidth pressure. Used in PublishVideoOpts.degradationPreference. Maps to the WebRTC native RTCDegradationPreference concept; values renamed for brevity.

ContentHint

Encoder optimization hint. Used in PublishVideoOpts.contentHint. Mirrors the WebRTC MediaStreamTrack.contentHint property.

PreCallPhase

Phases of the pre-call diagnostic. Used in PreCallTestOpts.tests to select which to run, and on onProgress events to identify which phase fired.

NetworkQuality

Quality score for a network direction (uplink or downlink) and per-kind (audio / video). Returned in PreCallTestResult.quality.

QualityFactor

Reasons a quality score is degraded. Populated in quality.uplink.factors / quality.downlink.factors when the score is Fair or below.

Protocol

Network transport preference. Set via JoinOptions.preferredProtocol. Useful for restrictive networks (corporate firewalls that block UDP).

LogLevel

SDK logging verbosity. Set via VideoSDK.setLogLevel(). Affects console / dashboard logging only — does not affect data sent to apps.

ConnectionState

Current connection state of a Room. Read sync via room.state; observe transitions via connection-state-changed. Only three values — idle / connecting are unobservable in our one-step model since VideoSDK.join() returns the Room only after it's connected.

DisconnectReason

Why the room transitioned to ConnectionState.Disconnected. Delivered as reason on the connection-state-changed event when the new state is Disconnected (and on the disconnected alias event). Mirrors v0's reason codes 1001–1104, converted from numeric to string for refactor-safety.

ServiceState

Run state of a room server-side service — recording, HLS, livestream, transcription. Read via Room.recordingState / hlsState / livestreamState / transcriptionState; transitions are delivered via the matching *-state-changed event.

Generic lifecycle. A normal run progresses stopped → starting → started, then started → stopping → stopped. Any active state can transition to failed on error. A fresh start call from failed (or stopped) goes back to starting.

HLS lifecycle extends this with one extra step: stopped → starting → started → playable → stopping → stopped. The buffer-fill phase between started and playable is intrinsic to HLS segment delivery and isn't a transition apps can shorten — they listen for playable to know when to call hls.loadSource(room.hlsUrls.playbackUrl).

ErrorKind

Category of an SDKError. Lets apps write a single handler for an entire class of errors without listing every code. Read via err.kind on every error the SDK surfaces (Promise rejections, event payloads).

LocalEvent

Event names fired on LocalParticipant. Both the enum value and the underlying string work in .on() / .off(). Three categories: publish lifecycle (your own publishes), incoming requests from other participants, and pin events.

Operational events (frozen, unfrozen, stuck, ended, silent-detected) fire on the stream object itself — see LocalVideoStream / LocalAudioStream / LocalScreenStream.

import { LocalEvent, MediaKind } from '@videosdk/js';

me.on(LocalEvent.StreamPublishRequested, async (req) => {
  // req: PublishRequest — { kind, from, accept, reject }
  const label = req.kind === MediaKind.Video ? 'camera' : 'microphone';
  if (confirm(`${req.from.displayName} asks you to enable ${label}`)) {
    const pub = await req.accept();   // resolves with LocalPublication
    if (pub.video) pub.video.attach(localCamEl);
  } else {
    req.reject();
  }
});
me.on('stream-publish-requested', async (req) => await req.accept());  // identical

RemoteEvent

Event names fired on RemoteParticipant. Both the enum value and the underlying string work in .on() / .off(). Three categories: publish notifications (remote published a kind), subscribe-completion events (your subscribe got the stream), pin events.

import { RemoteEvent, MediaKind } from '@videosdk/js';

p.on(RemoteEvent.StreamPublished, ({ kind }) => p.subscribe(kind));
p.on('stream-published',          ({ kind }) => p.subscribe(kind));   // identical

p.on(RemoteEvent.StreamSubscribed, sub => sub.video?.attach(el));
p.on('stream-subscribed',          sub => sub.video?.attach(el));     // identical

See also: Types LocalParticipant RemoteParticipant