@fishjam-cloud/js-server-sdk 0.20.0 → 0.22.0

package/dist/index.d.mts

@@ -1,6 +1,5 @@
-import { ServerMessage } from './proto.mjs';
+import { BinaryWriter, BinaryReader } from '@bufbuild/protobuf/wire';
 import axios from 'axios';
-import '@bufbuild/protobuf/wire';
 
 /**
  * Describes peer status
@@ -16,35 +15,99 @@ interface Peer$1 {
     'id': string;
     /**
      * Custom metadata set by the peer
-     * @type {any}
+     * @type {object}
      * @memberof Peer
      */
-    'metadata': any | null;
+    'metadata': object | null;
     /**
      *
      * @type {PeerStatus}
      * @memberof Peer
      */
     'status': PeerStatus;
+    /**
+     *
+     * @type {SubscribeMode}
+     * @memberof Peer
+     */
+    'subscribeMode': SubscribeMode;
+    /**
+     * Describes peer\'s subscriptions in manual mode
+     * @type {Array<string>}
+     * @memberof Peer
+     */
+    'subscriptions': Array<string>;
     /**
      * List of all peer\'s tracks
      * @type {Array<Track>}
      * @memberof Peer
      */
-    'tracks': Array<Track>;
+    'tracks': Array<Track$1>;
     /**
-     * Peer type
-     * @type {string}
+     *
+     * @type {PeerType}
      * @memberof Peer
      */
-    'type': string;
+    'type': PeerType;
 }
 /**
  * @type PeerOptions
  * Peer-specific options
  * @export
  */
-type PeerOptions = PeerOptionsWebRTC;
+type PeerOptions = PeerOptionsAgent | PeerOptionsWebRTC;
+/**
+ * Options specific to the Agent peer
+ * @export
+ * @interface PeerOptionsAgent
+ */
+interface PeerOptionsAgent {
+    /**
+     *
+     * @type {PeerOptionsAgentOutput}
+     * @memberof PeerOptionsAgent
+     */
+    'output'?: PeerOptionsAgentOutput;
+    /**
+     * Configuration of peer\'s subscribing policy
+     * @type {string}
+     * @memberof PeerOptionsAgent
+     */
+    'subscribeMode'?: PeerOptionsAgentSubscribeModeEnum;
+}
+declare const PeerOptionsAgentSubscribeModeEnum: {
+    readonly Auto: "auto";
+    readonly Manual: "manual";
+};
+type PeerOptionsAgentSubscribeModeEnum = typeof PeerOptionsAgentSubscribeModeEnum[keyof typeof PeerOptionsAgentSubscribeModeEnum];
+/**
+ * Output audio options
+ * @export
+ * @interface PeerOptionsAgentOutput
+ */
+interface PeerOptionsAgentOutput {
+    /**
+     * The format of the output audio
+     * @type {string}
+     * @memberof PeerOptionsAgentOutput
+     */
+    'audioFormat'?: PeerOptionsAgentOutputAudioFormatEnum;
+    /**
+     * The sample rate of the output audio
+     * @type {number}
+     * @memberof PeerOptionsAgentOutput
+     */
+    'audioSampleRate'?: PeerOptionsAgentOutputAudioSampleRateEnum;
+}
+declare const PeerOptionsAgentOutputAudioFormatEnum: {
+    readonly Pcm16: "pcm16";
+};
+type PeerOptionsAgentOutputAudioFormatEnum = typeof PeerOptionsAgentOutputAudioFormatEnum[keyof typeof PeerOptionsAgentOutputAudioFormatEnum];
+declare const PeerOptionsAgentOutputAudioSampleRateEnum: {
+    readonly NUMBER_16000: 16000;
+    readonly NUMBER_24000: 24000;
+};
+type PeerOptionsAgentOutputAudioSampleRateEnum = typeof PeerOptionsAgentOutputAudioSampleRateEnum[keyof typeof PeerOptionsAgentOutputAudioSampleRateEnum];
 /**
  * Options specific to the WebRTC peer
  * @export
@@ -65,7 +128,18 @@ interface PeerOptionsWebRTC {
     'metadata'?: {
         [key: string]: any;
     };
+    /**
+     * Configuration of peer\'s subscribing policy
+     * @type {string}
+     * @memberof PeerOptionsWebRTC
+     */
+    'subscribeMode'?: PeerOptionsWebRTCSubscribeModeEnum;
 }
+declare const PeerOptionsWebRTCSubscribeModeEnum: {
+    readonly Auto: "auto";
+    readonly Manual: "manual";
+};
+type PeerOptionsWebRTCSubscribeModeEnum = typeof PeerOptionsWebRTCSubscribeModeEnum[keyof typeof PeerOptionsWebRTCSubscribeModeEnum];
 /**
  * Informs about the peer status
  * @export
@@ -76,6 +150,16 @@ declare const PeerStatus: {
     readonly Disconnected: "disconnected";
 };
 type PeerStatus = typeof PeerStatus[keyof typeof PeerStatus];
+/**
+ * Peer type
+ * @export
+ * @enum {string}
+ */
+declare const PeerType: {
+    readonly Webrtc: "webrtc";
+    readonly Agent: "agent";
+};
+type PeerType = typeof PeerType[keyof typeof PeerType];
 /**
  * Room configuration
  * @export
@@ -105,7 +189,7 @@ interface RoomConfig {
      * @type {string}
      * @memberof RoomConfig
      */
-    'videoCodec'?: RoomConfigVideoCodecEnum | null;
+    'videoCodec'?: RoomConfigVideoCodecEnum;
     /**
      * URL where Fishjam notifications will be sent
      * @type {string}
@@ -119,6 +203,7 @@ declare const RoomConfigRoomTypeEnum: {
     readonly Broadcaster: "broadcaster";
     readonly Livestream: "livestream";
     readonly Conference: "conference";
+    readonly AudioOnlyLivestream: "audio_only_livestream";
 };
 type RoomConfigRoomTypeEnum = typeof RoomConfigRoomTypeEnum[keyof typeof RoomConfigRoomTypeEnum];
 declare const RoomConfigVideoCodecEnum: {
@@ -140,23 +225,33 @@ interface StreamerToken {
     'token': string;
 }
 /**
- * Describes media track of a Peer or Component
+ * Configuration of peer\'s subscribing policy
+ * @export
+ * @enum {string}
+ */
+declare const SubscribeMode: {
+    readonly Auto: "auto";
+    readonly Manual: "manual";
+};
+type SubscribeMode = typeof SubscribeMode[keyof typeof SubscribeMode];
+/**
+ * Describes media track of a Peer
  * @export
  * @interface Track
  */
-interface Track {
+interface Track$1 {
     /**
-     *
+     * Assigned track id
      * @type {string}
      * @memberof Track
      */
     'id'?: string;
     /**
      *
-     * @type {any}
+     * @type {object}
      * @memberof Track
      */
-    'metadata'?: any | null;
+    'metadata'?: object | null;
     /**
      *
      * @type {string}
@@ -183,6 +278,299 @@ interface ViewerToken {
     'token': string;
 }
 
+/** Defines types of tracks being published by peers and component */
+declare enum TrackType$1 {
+    TRACK_TYPE_UNSPECIFIED = 0,
+    TRACK_TYPE_VIDEO = 1,
+    TRACK_TYPE_AUDIO = 2,
+    UNRECOGNIZED = -1
+}
+/** Describes a media track */
+interface Track {
+    id: string;
+    type: TrackType$1;
+    metadata: string;
+}
+declare const Track: MessageFns$2<Track>;
+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]>;
+} : Partial<T>;
+type KeysOfUnion$2<T> = T extends T ? keyof T : never;
+type Exact$2<P, I extends P> = P extends Builtin$2 ? P : P & {
+    [K in keyof P]: Exact$2<P[K], I[K]>;
+} & {
+    [K in Exclude<keyof I, KeysOfUnion$2<P>>]: never;
+};
+interface MessageFns$2<T> {
+    encode(message: T, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): T;
+    fromJSON(object: any): T;
+    toJSON(message: T): unknown;
+    create<I extends Exact$2<DeepPartial$2<T>, I>>(base?: I): T;
+    fromPartial<I extends Exact$2<DeepPartial$2<T>, I>>(object: I): T;
+}
+
+declare enum ServerMessage_PeerType {
+    PEER_TYPE_UNSPECIFIED = 0,
+    PEER_TYPE_WEBRTC = 1,
+    PEER_TYPE_AGENT = 2,
+    UNRECOGNIZED = -1
+}
+/** Defines message groups for which peer can subscribe */
+declare enum ServerMessage_EventType {
+    EVENT_TYPE_UNSPECIFIED = 0,
+    EVENT_TYPE_SERVER_NOTIFICATION = 1,
+    UNRECOGNIZED = -1
+}
+/** Defines any type of message passed between FJ and server peer */
+interface ServerMessage {
+    roomCrashed?: ServerMessage_RoomCrashed | undefined;
+    peerConnected?: ServerMessage_PeerConnected | undefined;
+    peerDisconnected?: ServerMessage_PeerDisconnected | undefined;
+    peerCrashed?: ServerMessage_PeerCrashed | undefined;
+    componentCrashed?: ServerMessage_ComponentCrashed | undefined;
+    authenticated?: ServerMessage_Authenticated | undefined;
+    authRequest?: ServerMessage_AuthRequest | undefined;
+    subscribeRequest?: ServerMessage_SubscribeRequest | undefined;
+    subscribeResponse?: ServerMessage_SubscribeResponse | undefined;
+    roomCreated?: ServerMessage_RoomCreated | undefined;
+    roomDeleted?: ServerMessage_RoomDeleted | undefined;
+    hlsPlayable?: ServerMessage_HlsPlayable | undefined;
+    hlsUploaded?: ServerMessage_HlsUploaded | undefined;
+    hlsUploadCrashed?: ServerMessage_HlsUploadCrashed | undefined;
+    peerMetadataUpdated?: ServerMessage_PeerMetadataUpdated | undefined;
+    trackAdded?: ServerMessage_TrackAdded | undefined;
+    trackRemoved?: ServerMessage_TrackRemoved | undefined;
+    trackMetadataUpdated?: ServerMessage_TrackMetadataUpdated | undefined;
+    peerAdded?: ServerMessage_PeerAdded | undefined;
+    peerDeleted?: ServerMessage_PeerDeleted | undefined;
+    /** @deprecated */
+    streamConnected?: ServerMessage_StreamConnected | undefined;
+    /** @deprecated */
+    streamDisconnected?: ServerMessage_StreamDisconnected | undefined;
+    viewerConnected?: ServerMessage_ViewerConnected | undefined;
+    viewerDisconnected?: ServerMessage_ViewerDisconnected | undefined;
+    streamerConnected?: ServerMessage_StreamerConnected | undefined;
+    streamerDisconnected?: ServerMessage_StreamerDisconnected | undefined;
+}
+declare const ServerMessage: MessageFns$1<ServerMessage>;
+/** Notification sent when a room crashes */
+interface ServerMessage_RoomCrashed {
+    roomId: string;
+}
+declare const ServerMessage_RoomCrashed: MessageFns$1<ServerMessage_RoomCrashed>;
+/** Notification sent when a peer is added */
+interface ServerMessage_PeerAdded {
+    roomId: string;
+    peerId: string;
+    peerType: ServerMessage_PeerType;
+}
+declare const ServerMessage_PeerAdded: MessageFns$1<ServerMessage_PeerAdded>;
+/** Notification sent when a peer is removed */
+interface ServerMessage_PeerDeleted {
+    roomId: string;
+    peerId: string;
+    peerType: ServerMessage_PeerType;
+}
+declare const ServerMessage_PeerDeleted: MessageFns$1<ServerMessage_PeerDeleted>;
+/** Notification sent when a peer connects */
+interface ServerMessage_PeerConnected {
+    roomId: string;
+    peerId: string;
+    peerType: ServerMessage_PeerType;
+}
+declare const ServerMessage_PeerConnected: MessageFns$1<ServerMessage_PeerConnected>;
+/** Notification sent when a peer disconnects from FJ */
+interface ServerMessage_PeerDisconnected {
+    roomId: string;
+    peerId: string;
+    peerType: ServerMessage_PeerType;
+}
+declare const ServerMessage_PeerDisconnected: MessageFns$1<ServerMessage_PeerDisconnected>;
+/** Notification sent when a peer crashes */
+interface ServerMessage_PeerCrashed {
+    roomId: string;
+    peerId: string;
+    reason: string;
+    peerType: ServerMessage_PeerType;
+}
+declare const ServerMessage_PeerCrashed: MessageFns$1<ServerMessage_PeerCrashed>;
+/** Notification sent when a component crashes */
+interface ServerMessage_ComponentCrashed {
+    roomId: string;
+    componentId: string;
+}
+declare const ServerMessage_ComponentCrashed: MessageFns$1<ServerMessage_ComponentCrashed>;
+/** Response sent by FJ, confirming successfull authentication */
+interface ServerMessage_Authenticated {
+}
+declare const ServerMessage_Authenticated: MessageFns$1<ServerMessage_Authenticated>;
+/** Request sent by peer, to authenticate to FJ server */
+interface ServerMessage_AuthRequest {
+    token: string;
+}
+declare const ServerMessage_AuthRequest: MessageFns$1<ServerMessage_AuthRequest>;
+/** Request sent by peer to subsribe for certain message type */
+interface ServerMessage_SubscribeRequest {
+    eventType: ServerMessage_EventType;
+}
+declare const ServerMessage_SubscribeRequest: MessageFns$1<ServerMessage_SubscribeRequest>;
+/** Response sent by FJ, confirming subscription for message type */
+interface ServerMessage_SubscribeResponse {
+    eventType: ServerMessage_EventType;
+}
+declare const ServerMessage_SubscribeResponse: MessageFns$1<ServerMessage_SubscribeResponse>;
+/** Notification sent when a room is created */
+interface ServerMessage_RoomCreated {
+    roomId: string;
+}
+declare const ServerMessage_RoomCreated: MessageFns$1<ServerMessage_RoomCreated>;
+/** Notification sent when a room is deleted */
+interface ServerMessage_RoomDeleted {
+    roomId: string;
+}
+declare const ServerMessage_RoomDeleted: MessageFns$1<ServerMessage_RoomDeleted>;
+/** Notification sent when the HLS stream becomes available in a room */
+interface ServerMessage_HlsPlayable {
+    roomId: string;
+    componentId: string;
+}
+declare const ServerMessage_HlsPlayable: MessageFns$1<ServerMessage_HlsPlayable>;
+/** Notification sent when the HLS recording is successfully uploded to AWS S3 */
+interface ServerMessage_HlsUploaded {
+    roomId: string;
+}
+declare const ServerMessage_HlsUploaded: MessageFns$1<ServerMessage_HlsUploaded>;
+/** Notification sent when the upload of HLS recording to AWS S3 fails */
+interface ServerMessage_HlsUploadCrashed {
+    roomId: string;
+}
+declare const ServerMessage_HlsUploadCrashed: MessageFns$1<ServerMessage_HlsUploadCrashed>;
+/** Notification sent when peer updates its metadata */
+interface ServerMessage_PeerMetadataUpdated {
+    roomId: string;
+    peerId: string;
+    metadata: string;
+    peerType: ServerMessage_PeerType;
+}
+declare const ServerMessage_PeerMetadataUpdated: MessageFns$1<ServerMessage_PeerMetadataUpdated>;
+/** Notification sent when peer or component adds new track */
+interface ServerMessage_TrackAdded {
+    roomId: string;
+    peerId?: string | undefined;
+    componentId?: string | undefined;
+    track: Track | undefined;
+}
+declare const ServerMessage_TrackAdded: MessageFns$1<ServerMessage_TrackAdded>;
+/** Notification sent when a track is removed */
+interface ServerMessage_TrackRemoved {
+    roomId: string;
+    peerId?: string | undefined;
+    componentId?: string | undefined;
+    track: Track | undefined;
+}
+declare const ServerMessage_TrackRemoved: MessageFns$1<ServerMessage_TrackRemoved>;
+/** Notification sent when metadata of a multimedia track is updated */
+interface ServerMessage_TrackMetadataUpdated {
+    roomId: string;
+    peerId?: string | undefined;
+    componentId?: string | undefined;
+    track: Track | undefined;
+}
+declare const ServerMessage_TrackMetadataUpdated: MessageFns$1<ServerMessage_TrackMetadataUpdated>;
+/** Notification sent when streamer successfully connects */
+interface ServerMessage_StreamConnected {
+    streamId: string;
+}
+declare const ServerMessage_StreamConnected: MessageFns$1<ServerMessage_StreamConnected>;
+/** Notification sent when streamer disconnects */
+interface ServerMessage_StreamDisconnected {
+    streamId: string;
+}
+declare const ServerMessage_StreamDisconnected: MessageFns$1<ServerMessage_StreamDisconnected>;
+/** Notification sent when viewer successfully connects */
+interface ServerMessage_ViewerConnected {
+    streamId: string;
+    viewerId: string;
+}
+declare const ServerMessage_ViewerConnected: MessageFns$1<ServerMessage_ViewerConnected>;
+/** Notification sent when viewer disconnects */
+interface ServerMessage_ViewerDisconnected {
+    streamId: string;
+    viewerId: string;
+}
+declare const ServerMessage_ViewerDisconnected: MessageFns$1<ServerMessage_ViewerDisconnected>;
+interface ServerMessage_StreamerConnected {
+    streamId: string;
+    streamerId: string;
+}
+declare const ServerMessage_StreamerConnected: MessageFns$1<ServerMessage_StreamerConnected>;
+interface ServerMessage_StreamerDisconnected {
+    streamId: string;
+    streamerId: string;
+}
+declare const ServerMessage_StreamerDisconnected: MessageFns$1<ServerMessage_StreamerDisconnected>;
+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]>;
+} : Partial<T>;
+type KeysOfUnion$1<T> = T extends T ? keyof T : never;
+type Exact$1<P, I extends P> = P extends Builtin$1 ? P : P & {
+    [K in keyof P]: Exact$1<P[K], I[K]>;
+} & {
+    [K in Exclude<keyof I, KeysOfUnion$1<P>>]: never;
+};
+interface MessageFns$1<T> {
+    encode(message: T, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): T;
+    fromJSON(object: any): T;
+    toJSON(message: T): unknown;
+    create<I extends Exact$1<DeepPartial$1<T>, I>>(base?: I): T;
+    fromPartial<I extends Exact$1<DeepPartial$1<T>, I>>(object: I): T;
+}
+/** Notification containing a chunk of an agent's track's data stream */
+interface AgentRequest_TrackData {
+    trackId: string;
+    data: Uint8Array;
+}
+declare const AgentRequest_TrackData: MessageFns<AgentRequest_TrackData>;
+/** Defines any type of message passed from Fishjam to agent peer */
+interface AgentResponse {
+    authenticated?: AgentResponse_Authenticated | undefined;
+    trackData?: AgentResponse_TrackData | undefined;
+}
+declare const AgentResponse: MessageFns<AgentResponse>;
+/** Response confirming successful authentication */
+interface AgentResponse_Authenticated {
+}
+declare const AgentResponse_Authenticated: MessageFns<AgentResponse_Authenticated>;
+/** Notification containing a chunk of a track's data stream */
+interface AgentResponse_TrackData {
+    peerId: string;
+    track: Track | undefined;
+    data: Uint8Array;
+}
+declare const AgentResponse_TrackData: MessageFns<AgentResponse_TrackData>;
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+type DeepPartial<T> = T extends Builtin ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {} ? {
+    [K in keyof T]?: DeepPartial<T[K]>;
+} : Partial<T>;
+type KeysOfUnion<T> = T extends T ? keyof T : never;
+type Exact<P, I extends P> = P extends Builtin ? P : P & {
+    [K in keyof P]: Exact<P[K], I[K]>;
+} & {
+    [K in Exclude<keyof I, KeysOfUnion<P>>]: never;
+};
+interface MessageFns<T> {
+    encode(message: T, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): T;
+    fromJSON(object: any): T;
+    toJSON(message: T): unknown;
+    create<I extends Exact<DeepPartial<T>, I>>(base?: I): T;
+    fromPartial<I extends Exact<DeepPartial<T>, I>>(object: I): T;
+}
+
 type EventMap = {
   [key: string]: (...args: any[]) => void
 }
@@ -250,15 +638,57 @@ type Room = {
     config: RoomConfig;
 };
 type FishjamConfig = {
-    fishjamId?: string;
-    fishjamUrl?: string;
+    fishjamId: string;
     managementToken: string;
 };
-
-type ExpectedEvents = 'roomCreated' | 'roomDeleted' | 'roomCrashed' | 'peerAdded' | 'peerDeleted' | 'peerConnected' | 'peerDisconnected' | 'peerMetadataUpdated' | 'peerCrashed' | 'trackAdded' | 'trackRemoved' | 'trackMetadataUpdated';
-type ErrorEventHandler = (msg: Error) => void;
+type ErrorEventHandler = (msg: Event) => void;
 type CloseEventHandler = (code: number, reason: string) => void;
-type NotificationEvents = Record<ExpectedEvents, (message: ServerMessage) => void>;
+
+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];
+};
+
+type ExpectedEvents = 'roomCreated' | 'roomDeleted' | 'roomCrashed' | 'peerAdded' | 'peerDeleted' | 'peerConnected' | 'peerDisconnected' | 'peerMetadataUpdated' | 'peerCrashed' | 'streamConnected' | 'streamDisconnected' | 'viewerConnected' | 'viewerDisconnected' | 'trackAdded' | 'trackRemoved' | 'trackMetadataUpdated';
+/**
+ * @inline
+ */
+type MessageWithIds = WithPeerId<WithRoomId<ServerMessage>>;
+/**
+ * @inline
+ */
+type Notifications = {
+    [K in ExpectedEvents]: NonNullable<MessageWithIds[K]>;
+};
+type RoomCreated = Notifications['roomCreated'];
+type RoomDeleted = Notifications['roomDeleted'];
+type RoomCrashed = Notifications['roomCrashed'];
+type PeerAdded = Notifications['peerAdded'];
+type PeerDeleted = Notifications['peerDeleted'];
+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 ViewerConnected = Notifications['viewerConnected'];
+type ViewerDisconnected = Notifications['viewerDisconnected'];
+type TrackAdded = Notifications['trackAdded'];
+type TrackRemoved = Notifications['trackRemoved'];
+type TrackMetadataUpdated = Notifications['trackMetadataUpdated'];
+type NotificationEvents = {
+    [K in ExpectedEvents]: (message: NonNullable<MessageWithIds[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.
@@ -266,7 +696,55 @@ declare const FishjamWSNotifier_base: new () => TypedEventEmitter<NotificationEv
  */
 declare class FishjamWSNotifier extends FishjamWSNotifier_base {
     private readonly client;
-    constructor(config: FishjamConfig, onError: ErrorEventHandler, onClose: CloseEventHandler, onConnectionFailed: ErrorEventHandler);
+    constructor(config: FishjamConfig, onError: ErrorEventHandler, onClose: CloseEventHandler);
+    private dispatchNotification;
+    private setupConnection;
+    private isExpectedEvent;
+}
+
+declare const expectedEventsList: readonly ["trackData"];
+/**
+ * @useDeclaredType
+ */
+type ExpectedAgentEvents = (typeof expectedEventsList)[number];
+type IncomingTrackData = Omit<NonNullable<AgentResponse_TrackData>, 'peerId'> & {
+    peerId: PeerId;
+};
+type OutgoingTrackData = Omit<NonNullable<AgentRequest_TrackData>, 'peerId'> & {
+    peerId: PeerId;
+};
+type AgentTrack = Track;
+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;
+};
+declare const FishjamAgent_base: new () => TypedEventEmitter<AgentEvents>;
+declare class FishjamAgent extends FishjamAgent_base {
+    private readonly client;
+    constructor(config: FishjamConfig, agentToken: string, onError: ErrorEventHandler, onClose: CloseEventHandler);
+    /**
+     * Creates an outgoing audio track for the agent
+     * @returns a new audio track
+     */
+    createTrack(codecParameters: AudioCodecParameters, metadata?: object): AgentTrack;
+    /**
+     * Deletes an outgoing audio track for the agent
+     */
+    deleteTrack(trackId: TrackId): void;
+    /**
+     * Send audio data for the given track
+     */
+    sendData(trackId: TrackId, data: Uint8Array): void;
     private dispatchNotification;
     private setupConnection;
     private isExpectedEvent;
@@ -274,20 +752,21 @@ declare class FishjamWSNotifier extends FishjamWSNotifier_base {
 
 /**
  * Client class that allows to manage Rooms and Peers for a Fishjam App.
- * It requires the Fishjam URL and management token that can be retrieved from the Fishjam Dashboard.
+ * It requires the Fishjam ID and management token that can be retrieved from the Fishjam Dashboard.
  * @category Client
  */
 declare class FishjamClient {
     private readonly roomApi;
     private readonly viewerApi;
     private readonly streamerApi;
+    private readonly fishjamConfig;
     /**
      * Create new instance of Fishjam Client.
      *
      * Example usage:
      * ```
      * const fishjamClient = new FishjamClient({
-     *   fishjamUrl: fastify.config.FISHJAM_URL,
+     *   fishjamId: fastify.config.FISHJAM_ID,
      *   managementToken: fastify.config.FISHJAM_MANAGEMENT_TOKEN,
      * });
      * ```
@@ -312,6 +791,13 @@ declare class FishjamClient {
         peer: Peer;
         peerToken: string;
     }>;
+    /**
+     * Create a new agent assigned to a room.
+     */
+    createAgent(roomId: RoomId, options: PeerOptions | undefined, onError: ErrorEventHandler, onClose: CloseEventHandler): Promise<{
+        agent: FishjamAgent;
+        peer: Peer;
+    }>;
     /**
      * Get details about a given room.
      */
@@ -320,6 +806,16 @@ declare class FishjamClient {
      * Delete a peer - this will also disconnect the peer from the room.
      */
     deletePeer(roomId: RoomId, peerId: PeerId): Promise<void>;
+    /**
+     * Subscribe a peer to another peer - this will make all tracks from the publisher available to the subscriber.
+     * Using this function only makes sense if subscribeMode is set to manual
+     */
+    subscribePeer(roomId: RoomId, subscriberPeerId: PeerId, publisherPeerId: PeerId): Promise<void>;
+    /**
+     * Subscribe a peer to specific tracks from another peer - this will make only the specified tracks from the publisher available to the subscriber.
+     * Using this function only makes sense if subscribeMode is set to manual
+     */
+    subscribeTracks(roomId: RoomId, subscriberPeerId: PeerId, tracks: TrackId[]): Promise<void>;
     /**
      * Refresh the peer token for an already existing peer.
      * If an already created peer has not been connected to the room for more than 24 hours, the token will become invalid. This method can be used to generate a new peer token for the existing peer.
@@ -364,4 +860,4 @@ declare class ServiceUnavailableException extends FishjamBaseException {
 declare class UnknownException extends FishjamBaseException {
 }
 
-export { BadRequestException, type Brand, type CloseEventHandler, type ErrorEventHandler, type ExpectedEvents, FishjamBaseException, FishjamClient, type FishjamConfig, FishjamNotFoundException, FishjamWSNotifier, ForbiddenException, MissingFishjamIdException, type NotificationEvents, type Peer, type PeerId, PeerNotFoundException, type PeerOptions, PeerStatus, type Room, type RoomConfig, RoomConfigRoomTypeEnum, RoomConfigVideoCodecEnum, type RoomId, RoomNotFoundException, ServiceUnavailableException, type StreamerToken, UnauthorizedException, UnknownException, type ViewerToken };
+export { 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, MissingFishjamIdException, type NotificationEvents, type OutgoingTrackData, type Peer, type PeerAdded, type PeerConnected, type PeerCrashed, type PeerDeleted, type PeerDisconnected, type PeerId, type PeerMetadataUpdated, PeerNotFoundException, type PeerOptions, PeerStatus, type Room, type RoomConfig, RoomConfigRoomTypeEnum, RoomConfigVideoCodecEnum, type RoomCrashed, type RoomCreated, type RoomDeleted, type RoomId, RoomNotFoundException, ServerMessage, ServiceUnavailableException, type StreamConnected, type StreamDisconnected, type StreamerToken, type TrackAdded, type TrackId, type TrackMetadataUpdated, type TrackRemoved, type TrackType, UnauthorizedException, UnknownException, type ViewerConnected, type ViewerDisconnected, type ViewerToken };