@fishjam-cloud/js-server-sdk 0.27.0-rc.1 → 0.28.0-rc.0

package/dist/index.d.ts

@@ -12,13 +12,13 @@ interface AgentOutput {
      * @type {AudioFormat}
      * @memberof AgentOutput
      */
-    'audioFormat'?: AudioFormat;
+    audioFormat?: AudioFormat;
     /**
      *
      * @type {AudioSampleRate}
      * @memberof AgentOutput
      */
-    'audioSampleRate'?: AudioSampleRate;
+    audioSampleRate?: AudioSampleRate;
 }
 /**
  * The format of the output audio
@@ -28,7 +28,7 @@ interface AgentOutput {
 declare const AudioFormat: {
     readonly Pcm16: "pcm16";
 };
-type AudioFormat = typeof AudioFormat[keyof typeof AudioFormat];
+type AudioFormat = (typeof AudioFormat)[keyof typeof AudioFormat];
 /**
  * The sample rate of the output audio
  * @export
@@ -38,7 +38,7 @@ declare const AudioSampleRate: {
     readonly NUMBER_16000: 16000;
     readonly NUMBER_24000: 24000;
 };
-type AudioSampleRate = typeof AudioSampleRate[keyof typeof AudioSampleRate];
+type AudioSampleRate = (typeof AudioSampleRate)[keyof typeof AudioSampleRate];
 /**
  * Token for authorizing a MoQ relay connection
  * @export
@@ -50,7 +50,7 @@ interface MoqToken {
      * @type {string}
      * @memberof MoqToken
      */
-    'token': string;
+    token: string;
 }
 /**
  * MoQ token configuration
@@ -63,13 +63,13 @@ interface MoqTokenConfig {
      * @type {string}
      * @memberof MoqTokenConfig
      */
-    'publishPath'?: string | null;
+    publishPath?: string | null;
     /**
      * Path under the root the token grants subscribe access to
      * @type {string}
      * @memberof MoqTokenConfig
      */
-    'subscribePath'?: string | null;
+    subscribePath?: string | null;
 }
 /**
  * Describes peer status
@@ -82,43 +82,43 @@ interface Peer$1 {
      * @type {string}
      * @memberof Peer
      */
-    'id': string;
+    id: string;
     /**
      * Custom metadata set by the peer
      * @type {object}
      * @memberof Peer
      */
-    'metadata': object | null;
+    metadata: object | null;
     /**
      *
      * @type {PeerStatus}
      * @memberof Peer
      */
-    'status': PeerStatus;
+    status: PeerStatus;
     /**
      *
      * @type {SubscribeMode}
      * @memberof Peer
      */
-    'subscribeMode': SubscribeMode;
+    subscribeMode: SubscribeMode;
     /**
      *
      * @type {Subscriptions}
      * @memberof Peer
      */
-    'subscriptions': Subscriptions;
+    subscriptions: Subscriptions;
     /**
      * List of all peer\'s tracks
      * @type {Array<Track>}
      * @memberof Peer
      */
-    'tracks': Array<Track$1>;
+    tracks: Array<Track$2>;
     /**
      *
      * @type {PeerType}
      * @memberof Peer
      */
-    'type': PeerType;
+    type: PeerType$1;
 }
 /**
  * @type PeerOptions
@@ -137,13 +137,13 @@ interface PeerOptionsAgent {
      * @type {AgentOutput}
      * @memberof PeerOptionsAgent
      */
-    'output'?: AgentOutput;
+    output?: AgentOutput;
     /**
      *
      * @type {SubscribeMode}
      * @memberof PeerOptionsAgent
      */
-    'subscribeMode'?: SubscribeMode;
+    subscribeMode?: SubscribeMode;
 }
 /**
  * Options specific to the VAPI peer
@@ -156,19 +156,19 @@ interface PeerOptionsVapi {
      * @type {string}
      * @memberof PeerOptionsVapi
      */
-    'apiKey': string;
+    apiKey: string;
     /**
      * VAPI call ID
      * @type {string}
      * @memberof PeerOptionsVapi
      */
-    'callId': string;
+    callId: string;
     /**
      *
      * @type {SubscribeMode}
      * @memberof PeerOptionsVapi
      */
-    'subscribeMode'?: SubscribeMode;
+    subscribeMode?: SubscribeMode;
 }
 /**
  * Options specific to the WebRTC peer
@@ -181,7 +181,7 @@ interface PeerOptionsWebRTC {
      * @type {{ [key: string]: any; }}
      * @memberof PeerOptionsWebRTC
      */
-    'metadata'?: {
+    metadata?: {
         [key: string]: any;
     };
     /**
@@ -189,7 +189,7 @@ interface PeerOptionsWebRTC {
      * @type {SubscribeMode}
      * @memberof PeerOptionsWebRTC
      */
-    'subscribeMode'?: SubscribeMode;
+    subscribeMode?: SubscribeMode;
 }
 /**
  * Informs about the peer status
@@ -200,54 +200,60 @@ declare const PeerStatus: {
     readonly Connected: "connected";
     readonly Disconnected: "disconnected";
 };
-type PeerStatus = typeof PeerStatus[keyof typeof PeerStatus];
+type PeerStatus = (typeof PeerStatus)[keyof typeof PeerStatus];
 /**
  * Peer type
  * @export
  * @enum {string}
  */
-declare const PeerType: {
+declare const PeerType$1: {
     readonly Webrtc: "webrtc";
     readonly Agent: "agent";
     readonly Vapi: "vapi";
 };
-type PeerType = typeof PeerType[keyof typeof PeerType];
+type PeerType$1 = (typeof PeerType$1)[keyof typeof PeerType$1];
 /**
  * Room configuration
  * @export
  * @interface RoomConfig
  */
 interface RoomConfig {
+    /**
+     * If true, webhook notifications for this room are coalesced into a single NotificationBatch per HTTP send instead of one request per notification. VAD notifications are unaffected.
+     * @type {boolean}
+     * @memberof RoomConfig
+     */
+    batchWebhookNotifications?: boolean;
     /**
      * Maximum amount of peers allowed into the room
      * @type {number}
      * @memberof RoomConfig
      */
-    'maxPeers'?: number | null;
+    maxPeers?: number | null;
     /**
      * True if livestream viewers can omit specifying a token.
      * @type {boolean}
      * @memberof RoomConfig
      */
-    'public'?: boolean;
+    public?: boolean;
     /**
      *
      * @type {RoomType}
      * @memberof RoomConfig
      */
-    'roomType'?: RoomType;
+    roomType?: RoomType;
     /**
      *
      * @type {VideoCodec}
      * @memberof RoomConfig
      */
-    'videoCodec'?: VideoCodec;
+    videoCodec?: VideoCodec;
     /**
      * URL where Fishjam notifications will be sent
      * @type {string}
      * @memberof RoomConfig
      */
-    'webhookUrl'?: string | null;
+    webhookUrl?: string | null;
 }
 /**
  * The use-case of the room. If not provided, this defaults to conference.
@@ -262,19 +268,19 @@ declare const RoomType: {
     readonly Conference: "conference";
     readonly AudioOnlyLivestream: "audio_only_livestream";
 };
-type RoomType = typeof RoomType[keyof typeof RoomType];
+type RoomType = (typeof RoomType)[keyof typeof RoomType];
 /**
- * Token for authorizing broadcaster streamer connection
+ * Streamer authorization token
  * @export
  * @interface StreamerToken
  */
 interface StreamerToken {
     /**
-     *
+     * Token streamer should authorize with
      * @type {string}
      * @memberof StreamerToken
      */
-    'token': string;
+    token: string;
 }
 /**
  * Configuration of peer\'s subscribing policy
@@ -285,7 +291,7 @@ declare const SubscribeMode: {
     readonly Auto: "auto";
     readonly Manual: "manual";
 };
-type SubscribeMode = typeof SubscribeMode[keyof typeof SubscribeMode];
+type SubscribeMode = (typeof SubscribeMode)[keyof typeof SubscribeMode];
 /**
  * Describes peer\'s subscriptions in manual mode
  * @export
@@ -297,41 +303,41 @@ interface Subscriptions {
      * @type {Array<string>}
      * @memberof Subscriptions
      */
-    'peers': Array<string>;
+    peers: Array<string>;
     /**
      * List of track IDs this peer subscribes to
      * @type {Array<string>}
      * @memberof Subscriptions
      */
-    'tracks': Array<string>;
+    tracks: Array<string>;
 }
 /**
- * Describes media track of a Peer
+ * Media track of a Peer
  * @export
  * @interface Track
  */
-interface Track$1 {
+interface Track$2 {
     /**
      * Assigned track id
      * @type {string}
      * @memberof Track
      */
-    'id'?: string;
+    id?: string;
     /**
-     *
+     * Metadata attached to the track by the peer
      * @type {object}
      * @memberof Track
      */
-    'metadata'?: object | null;
+    metadata?: object | null;
     /**
      *
      * @type {TrackType}
      * @memberof Track
      */
-    'type'?: TrackType$2;
+    type?: TrackType$2;
 }
 /**
- *
+ * Media type carried by the track
  * @export
  * @enum {string}
  */
@@ -339,7 +345,7 @@ declare const TrackType$2: {
     readonly Audio: "audio";
     readonly Video: "video";
 };
-type TrackType$2 = typeof TrackType$2[keyof typeof TrackType$2];
+type TrackType$2 = (typeof TrackType$2)[keyof typeof TrackType$2];
 /**
  * Enforces video codec for each peer in the room
  * @export
@@ -349,19 +355,19 @@ declare const VideoCodec: {
     readonly H264: "h264";
     readonly Vp8: "vp8";
 };
-type VideoCodec = typeof VideoCodec[keyof typeof VideoCodec];
+type VideoCodec = (typeof VideoCodec)[keyof typeof VideoCodec];
 /**
- * Token for authorizing broadcaster viewer connection
+ * Viewer authorization token
  * @export
  * @interface ViewerToken
  */
 interface ViewerToken {
     /**
-     *
+     * Token viewer should authorize with
      * @type {string}
      * @memberof ViewerToken
      */
-    'token': string;
+    token: string;
 }
 
 /** Defines types of tracks being published by peers and component */
@@ -372,12 +378,12 @@ declare enum TrackType$1 {
     UNRECOGNIZED = -1
 }
 /** Describes a media track */
-interface Track {
+interface Track$1 {
     id: string;
     type: TrackType$1;
     metadata: string;
 }
-declare const Track: MessageFns$2<Track>;
+declare const Track$1: MessageFns$2<Track$1>;
 type Builtin$2 = Date | Function | Uint8Array | string | number | boolean | undefined;
 type DeepPartial$2<T> = T extends Builtin$2 ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial$2<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial$2<U>> : T extends {} ? {
     [K in keyof T]?: DeepPartial$2<T[K]>;
@@ -443,6 +449,8 @@ interface ServerMessage {
     viewerDisconnected?: ServerMessage_ViewerDisconnected | undefined;
     streamerConnected?: ServerMessage_StreamerConnected | undefined;
     streamerDisconnected?: ServerMessage_StreamerDisconnected | undefined;
+    /** Batch */
+    notificationBatch?: ServerMessage_NotificationBatch | undefined;
     /** @deprecated */
     streamConnected?: ServerMessage_StreamConnected | undefined;
     /** @deprecated */
@@ -562,7 +570,7 @@ interface ServerMessage_TrackAdded {
     roomId: string;
     peerId?: string | undefined;
     componentId?: string | undefined;
-    track: Track | undefined;
+    track: Track$1 | undefined;
 }
 declare const ServerMessage_TrackAdded: MessageFns$1<ServerMessage_TrackAdded>;
 /** Notification sent when a track is removed */
@@ -570,7 +578,7 @@ interface ServerMessage_TrackRemoved {
     roomId: string;
     peerId?: string | undefined;
     componentId?: string | undefined;
-    track: Track | undefined;
+    track: Track$1 | undefined;
 }
 declare const ServerMessage_TrackRemoved: MessageFns$1<ServerMessage_TrackRemoved>;
 /** Notification sent when metadata of a multimedia track is updated */
@@ -578,7 +586,7 @@ interface ServerMessage_TrackMetadataUpdated {
     roomId: string;
     peerId?: string | undefined;
     componentId?: string | undefined;
-    track: Track | undefined;
+    track: Track$1 | undefined;
 }
 declare const ServerMessage_TrackMetadataUpdated: MessageFns$1<ServerMessage_TrackMetadataUpdated>;
 /** Notification sent when a peer creates a channel */
@@ -604,8 +612,8 @@ interface ServerMessage_TrackForwarding {
     compositionUrl: string;
     inputId: string;
     /** Track has id, type, and metadata */
-    audioTrack?: Track | undefined;
-    videoTrack?: Track | undefined;
+    audioTrack?: Track$1 | undefined;
+    videoTrack?: Track$1 | undefined;
 }
 declare const ServerMessage_TrackForwarding: MessageFns$1<ServerMessage_TrackForwarding>;
 /** Sent when track forwarding is removed */
@@ -656,6 +664,23 @@ interface ServerMessage_StreamerDisconnected {
     streamerId: string;
 }
 declare const ServerMessage_StreamerDisconnected: MessageFns$1<ServerMessage_StreamerDisconnected>;
+/**
+ * Carries multiple notifications in a single wire frame.
+ *
+ * Constraints (documented, not schema-enforced):
+ *   - Each element's `content` MUST be a notification variant — never
+ *     Authenticated, AuthRequest, SubscribeRequest, or SubscribeResponse.
+ *   - NotificationBatch MUST NOT be nested inside another NotificationBatch.
+ *     The schema technically permits this, but senders must not emit
+ *     recursive batches and receivers may treat them as a protocol violation.
+ *   - Notifications are delivered in array order; consumers must process
+ *     them in order.
+ *   - Sent only for webhooks, for peers that .
+ */
+interface ServerMessage_NotificationBatch {
+    notifications: ServerMessage[];
+}
+declare const ServerMessage_NotificationBatch: MessageFns$1<ServerMessage_NotificationBatch>;
 type Builtin$1 = Date | Function | Uint8Array | string | number | boolean | undefined;
 type DeepPartial$1<T> = T extends Builtin$1 ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial$1<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial$1<U>> : T extends {} ? {
     [K in keyof T]?: DeepPartial$1<T[K]>;
@@ -694,7 +719,7 @@ declare const AgentResponse_Authenticated: MessageFns<AgentResponse_Authenticate
 /** Notification containing a chunk of a track's data stream */
 interface AgentResponse_TrackData {
     peerId: string;
-    track: Track | undefined;
+    track: Track$1 | undefined;
     data: Uint8Array;
 }
 declare const AgentResponse_TrackData: MessageFns<AgentResponse_TrackData>;
@@ -772,6 +797,21 @@ declare const brand: unique symbol;
 type Brand<T, TBrand extends string> = T & {
     [brand]: TBrand;
 };
+/**
+ * Replaces the types of fields in `T` whose names appear in `M`, leaving the rest untouched.
+ * Produces a flat object type (single mapped type, no `Omit & {...}` chain) so editor hover
+ * displays the resulting properties directly.
+ *
+ * Keys present in `M` but not in `T` are ignored — only fields that already exist on `T`
+ * are overridden, so a shared override map can be reused across multiple source types.
+ *
+ * `undefined` is re-added to the override when the original field allowed it, so optional
+ * fields on generated proto types (e.g. `peerId?: string | undefined`) remain assignable
+ * from `undefined` under `exactOptionalPropertyTypes`.
+ */
+type Override<T, M> = {
+    [K in keyof T]: K extends keyof M ? (undefined extends T[K] ? M[K] | undefined : M[K]) : T[K];
+};
 /**
  * ID of the Room.
  * Room can be created with {@link FishjamClient.createRoom}.
@@ -781,9 +821,19 @@ type RoomId = Brand<string, 'RoomId'>;
  * ID of Peer. Peer is associated with Room and can be created with {@link FishjamClient.createPeer}.
  */
 type PeerId = Brand<string, 'PeerId'>;
-type Peer = Omit<Peer$1, 'id'> & {
+type Peer = Override<Peer$1, {
     id: PeerId;
-};
+}>;
+/**
+ * Peer type as emitted by {@link FishjamWSNotifier}. Matches the REST API's `PeerType`,
+ * with the addition of `'unspecified'` for messages whose peer type is not set on the wire.
+ */
+type PeerType = PeerType$1 | 'unspecified';
+/**
+ * Track type as emitted by {@link FishjamWSNotifier}. Matches the REST API's `TrackType`,
+ * with the addition of `'unspecified'` for messages whose track type is not set on the wire.
+ */
+type TrackType = TrackType$2 | 'unspecified';
 type Room = {
     id: RoomId;
     peers: Peer[];
@@ -800,31 +850,60 @@ type AgentCallbacks = {
     onClose?: CloseEventHandler;
 };
 
-type WithRoomId<T> = {
-    [P in keyof T]: NonNullable<T[P]> extends {
-        roomId: string;
-    } ? Omit<NonNullable<T[P]>, 'roomId'> & {
-        roomId: RoomId;
-    } : T[P];
-};
-type WithPeerId<T> = {
-    [P in keyof T]: NonNullable<T[P]> extends {
-        peerId: string;
-    } ? Omit<NonNullable<T[P]>, 'peerId'> & {
-        peerId: PeerId;
-    } : T[P];
+/**
+ * Track payload embedded in {@link TrackAdded}, {@link TrackRemoved}, {@link TrackMetadataUpdated}.
+ */
+type Track = {
+    id: string;
+    type: TrackType;
+    metadata: string;
 };
-
-type ExpectedEvents = 'roomCreated' | 'roomDeleted' | 'roomCrashed' | 'peerAdded' | 'peerDeleted' | 'peerConnected' | 'peerDisconnected' | 'peerMetadataUpdated' | 'peerCrashed' | 'streamConnected' | 'streamDisconnected' | 'viewerConnected' | 'viewerDisconnected' | 'trackAdded' | 'trackRemoved' | 'trackMetadataUpdated';
+declare const expectedEventsList$1: readonly ["roomCreated", "roomDeleted", "roomCrashed", "peerAdded", "peerDeleted", "peerConnected", "peerDisconnected", "peerMetadataUpdated", "peerCrashed", "streamerConnected", "streamerDisconnected", "viewerConnected", "viewerDisconnected", "trackAdded", "trackRemoved", "trackMetadataUpdated", "channelAdded", "channelRemoved"];
+type ExpectedEvents = (typeof expectedEventsList$1)[number];
+/**
+ * `ServerMessage` oneof members that are intentionally NOT emitted to users.
+ * Grouped with a brief rationale so the classification stays reviewable.
+ * Mirrors the Python SDK's `IGNORED_NOTIFICATIONS` partition (FCE-3215).
+ */
+declare const ignoredEventsList: readonly ["authenticated", "authRequest", "subscribeRequest", "subscribeResponse", "trackForwarding", "trackForwardingRemoved", "vadNotification", "notificationBatch", "streamConnected", "streamDisconnected", "hlsPlayable", "hlsUploaded", "hlsUploadCrashed", "componentCrashed"];
+type IgnoredEvents = (typeof ignoredEventsList)[number];
 /**
+ * Field-level overrides applied to every notification payload: branded ID types
+ * and the user-facing enums replace their raw protobuf counterparts. {@link Override}
+ * only swaps keys that exist on the source type, so a single map covers all variants.
+ *
  * @inline
  */
-type MessageWithIds = WithPeerId<WithRoomId<ServerMessage>>;
+type NotificationOverrides = {
+    roomId: RoomId;
+    peerId: PeerId;
+    peerType: PeerType;
+    track: Track | undefined;
+};
+/** @inline */
+type Notification<K extends keyof ServerMessage> = Override<NonNullable<ServerMessage[K]>, NotificationOverrides>;
 /**
  * @inline
  */
 type Notifications = {
-    [K in ExpectedEvents]: NonNullable<MessageWithIds[K]>;
+    roomCreated: Notification<'roomCreated'>;
+    roomDeleted: Notification<'roomDeleted'>;
+    roomCrashed: Notification<'roomCrashed'>;
+    peerAdded: Notification<'peerAdded'>;
+    peerDeleted: Notification<'peerDeleted'>;
+    peerConnected: Notification<'peerConnected'>;
+    peerDisconnected: Notification<'peerDisconnected'>;
+    peerMetadataUpdated: Notification<'peerMetadataUpdated'>;
+    peerCrashed: Notification<'peerCrashed'>;
+    streamerConnected: Notification<'streamerConnected'>;
+    streamerDisconnected: Notification<'streamerDisconnected'>;
+    viewerConnected: Notification<'viewerConnected'>;
+    viewerDisconnected: Notification<'viewerDisconnected'>;
+    trackAdded: Notification<'trackAdded'>;
+    trackRemoved: Notification<'trackRemoved'>;
+    trackMetadataUpdated: Notification<'trackMetadataUpdated'>;
+    channelAdded: Notification<'channelAdded'>;
+    channelRemoved: Notification<'channelRemoved'>;
 };
 type RoomCreated = Notifications['roomCreated'];
 type RoomDeleted = Notifications['roomDeleted'];
@@ -835,16 +914,19 @@ type PeerConnected = Notifications['peerConnected'];
 type PeerDisconnected = Notifications['peerDisconnected'];
 type PeerMetadataUpdated = Notifications['peerMetadataUpdated'];
 type PeerCrashed = Notifications['peerCrashed'];
-type StreamConnected = Notifications['streamConnected'];
-type StreamDisconnected = Notifications['streamDisconnected'];
+type StreamerConnected = Notifications['streamerConnected'];
+type StreamerDisconnected = Notifications['streamerDisconnected'];
 type ViewerConnected = Notifications['viewerConnected'];
 type ViewerDisconnected = Notifications['viewerDisconnected'];
 type TrackAdded = Notifications['trackAdded'];
 type TrackRemoved = Notifications['trackRemoved'];
 type TrackMetadataUpdated = Notifications['trackMetadataUpdated'];
+type ChannelAdded = Notifications['channelAdded'];
+type ChannelRemoved = Notifications['channelRemoved'];
 type NotificationEvents = {
-    [K in ExpectedEvents]: (message: NonNullable<MessageWithIds[K]>) => void;
+    [K in ExpectedEvents]: (message: Notifications[K]) => void;
 };
+
 declare const FishjamWSNotifier_base: new () => TypedEventEmitter<NotificationEvents>;
 /**
  * Notifier object that can be used to get notified about various events related to the Fishjam App.
@@ -863,29 +945,26 @@ declare const expectedEventsList: readonly ["trackData"];
  * @useDeclaredType
  */
 type ExpectedAgentEvents = (typeof expectedEventsList)[number];
-type IncomingTrackData = Omit<NonNullable<AgentResponse_TrackData>, 'peerId'> & {
+type IncomingTrackData = Override<NonNullable<AgentResponse_TrackData>, {
     peerId: PeerId;
-};
+}>;
 type IncomingTrackImage = NonNullable<AgentResponse_TrackImage>;
-type OutgoingTrackData = Omit<NonNullable<AgentRequest_TrackData>, 'peerId'> & {
+type OutgoingTrackData = Override<NonNullable<AgentRequest_TrackData>, {
     peerId: PeerId;
-};
-type AgentTrack = Omit<Track, 'id'> & {
+}>;
+type AgentTrack = Override<Track$1, {
     id: TrackId;
-};
-type TrackType = 'audio' | 'video';
+}>;
 type AudioCodecParameters = {
     encoding: 'opus' | 'pcm16';
     sampleRate: 16000 | 24000 | 48000;
     channels: 1;
 };
 type TrackId = Brand<string, 'TrackId'>;
-/**
- * @inline
- */
-type ResponseWithPeerId = WithPeerId<AgentResponse>;
 type AgentEvents = {
-    [K in ExpectedAgentEvents]: (message: NonNullable<ResponseWithPeerId[K]>) => void;
+    [K in ExpectedAgentEvents]: (message: Override<NonNullable<AgentResponse[K]>, {
+        peerId: PeerId;
+    }>) => void;
 };
 declare const FishjamAgent_base: new () => TypedEventEmitter<AgentEvents>;
 declare class FishjamAgent extends FishjamAgent_base {
@@ -926,7 +1005,7 @@ declare class FishjamAgent extends FishjamAgent_base {
      * @param timeoutMs - timeout in milliseconds (default: 5000)
      * @returns a promise that resolves with the captured image data
      */
-    captureImage(trackId: string, timeoutMs?: number): Promise<IncomingTrackImage>;
+    captureImage(trackId: TrackId, timeoutMs?: number): Promise<IncomingTrackImage>;
     disconnect(): void;
     private handleTrackImageMessage;
     private rejectPendingCaptures;
@@ -945,11 +1024,16 @@ declare class FishjamClient {
     private readonly roomApi;
     private readonly viewerApi;
     private readonly streamerApi;
+    private readonly credentialsApi;
     private readonly fishjamConfig;
     private deprecationWarningShown;
     /**
      * Create new instance of Fishjam Client.
      *
+     * Does not verify credentials against the backend — use
+     * {@link FishjamClient.create} or call
+     * {@link FishjamClient.checkCredentials} afterwards for that.
+     *
      * Example usage:
      * ```
      * const fishjamClient = new FishjamClient({
@@ -959,6 +1043,29 @@ declare class FishjamClient {
      * ```
      */
     constructor(config: FishjamConfig);
+    /**
+     * Async factory: constructs a client and verifies credentials against
+     * the backend.
+     *
+     * Throws {@link InvalidFishjamCredentialsException} when the
+     * `fishjamId` / `managementToken` pair is rejected by the backend.
+     *
+     * Example:
+     * ```
+     * const client = await FishjamClient.create({
+     *   fishjamId: process.env.FISHJAM_ID!,
+     *   managementToken: process.env.FISHJAM_MANAGEMENT_TOKEN!,
+     * });
+     * ```
+     */
+    static create(config: FishjamConfig): Promise<FishjamClient>;
+    /**
+     * Verifies the configured credentials by making a single lightweight
+     * call to the Fishjam backend. Resolves on success, throws
+     * {@link InvalidFishjamCredentialsException} on 401/404 from the backend,
+     * otherwise rethrows the standard mapped exception.
+     */
+    checkCredentials(): Promise<void>;
     private handleDeprecationHeader;
     /**
      * Create a new room. All peers connected to the same room will be able to send/receive streams to each other.
@@ -1052,11 +1159,15 @@ declare class RoomNotFoundException extends FishjamBaseException {
 }
 declare class FishjamNotFoundException extends FishjamBaseException {
 }
+declare class InvalidFishjamCredentialsException extends FishjamBaseException {
+}
 declare class PeerNotFoundException extends FishjamBaseException {
 }
 declare class ServiceUnavailableException extends FishjamBaseException {
 }
+declare class QuotaExceededException extends FishjamBaseException {
+}
 declare class UnknownException extends FishjamBaseException {
 }
 
-export { type AgentCallbacks, type AgentEvents, type AgentTrack, type AudioCodecParameters, BadRequestException, type Brand, type CloseEventHandler, type ErrorEventHandler, type ExpectedAgentEvents, type ExpectedEvents, FishjamAgent, FishjamBaseException, FishjamClient, type FishjamConfig, FishjamNotFoundException, FishjamWSNotifier, ForbiddenException, type IncomingTrackData, type IncomingTrackImage, MissingFishjamIdException, type MoqToken, type MoqTokenConfig, type NotificationEvents, type OutgoingTrackData, type Peer, type PeerAdded, type PeerConnected, type PeerCrashed, type PeerDeleted, type PeerDisconnected, type PeerId, type PeerMetadataUpdated, PeerNotFoundException, type PeerOptions, type PeerOptionsAgent, type PeerOptionsVapi, type PeerOptionsWebRTC, PeerStatus, type Room, type RoomConfig, type RoomCrashed, type RoomCreated, type RoomDeleted, type RoomId, RoomNotFoundException, RoomType, ServerMessage, ServiceUnavailableException, type StreamConnected, type StreamDisconnected, type StreamerToken, type TrackAdded, type TrackId, type TrackMetadataUpdated, type TrackRemoved, type TrackType, UnauthorizedException, UnknownException, VideoCodec, type ViewerConnected, type ViewerDisconnected, type ViewerToken };
+export { type AgentCallbacks, type AgentEvents, type AgentTrack, type AudioCodecParameters, BadRequestException, type Brand, type ChannelAdded, type ChannelRemoved, type CloseEventHandler, type ErrorEventHandler, type ExpectedAgentEvents, type ExpectedEvents, FishjamAgent, FishjamBaseException, FishjamClient, type FishjamConfig, FishjamNotFoundException, FishjamWSNotifier, ForbiddenException, type IgnoredEvents, type IncomingTrackData, type IncomingTrackImage, InvalidFishjamCredentialsException, MissingFishjamIdException, type MoqToken, type MoqTokenConfig, type NotificationEvents, type OutgoingTrackData, type Override, type Peer, type PeerAdded, type PeerConnected, type PeerCrashed, type PeerDeleted, type PeerDisconnected, type PeerId, type PeerMetadataUpdated, PeerNotFoundException, type PeerOptions, type PeerOptionsAgent, type PeerOptionsVapi, type PeerOptionsWebRTC, PeerStatus, type PeerType, QuotaExceededException, type Room, type RoomConfig, type RoomCrashed, type RoomCreated, type RoomDeleted, type RoomId, RoomNotFoundException, RoomType, ServerMessage, ServiceUnavailableException, type StreamerConnected, type StreamerDisconnected, type StreamerToken, type Track, type TrackAdded, type TrackId, type TrackMetadataUpdated, type TrackRemoved, type TrackType, UnauthorizedException, UnknownException, VideoCodec, type ViewerConnected, type ViewerDisconnected, type ViewerToken };