@fishjam-cloud/js-server-sdk 0.19.0 → 0.21.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,41 @@ 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 {SubscribeOptions}
+     * @memberof Peer
+     */
+    'subscribe': SubscribeOptions | null;
     /**
      * 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 = PeerOptionsWebRTC | object;
 /**
  * Options specific to the WebRTC peer
  * @export
@@ -65,6 +70,12 @@ interface PeerOptionsWebRTC {
     'metadata'?: {
         [key: string]: any;
     };
+    /**
+     *
+     * @type {SubscribeOptions1}
+     * @memberof PeerOptionsWebRTC
+     */
+    'subscribe'?: SubscribeOptions1 | null;
 }
 /**
  * Informs about the peer status
@@ -76,6 +87,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 +126,7 @@ interface RoomConfig {
      * @type {string}
      * @memberof RoomConfig
      */
-    'videoCodec'?: RoomConfigVideoCodecEnum | null;
+    'videoCodec'?: RoomConfigVideoCodecEnum;
     /**
      * URL where Fishjam notifications will be sent
      * @type {string}
@@ -126,12 +147,81 @@ declare const RoomConfigVideoCodecEnum: {
     readonly Vp8: "vp8";
 };
 type RoomConfigVideoCodecEnum = typeof RoomConfigVideoCodecEnum[keyof typeof RoomConfigVideoCodecEnum];
+/**
+ * Token for authorizing broadcaster streamer connection
+ * @export
+ * @interface StreamerToken
+ */
+interface StreamerToken {
+    /**
+     *
+     * @type {string}
+     * @memberof StreamerToken
+     */
+    'token': string;
+}
+/**
+ * Configuration of server-side subscriptions to the peer\'s tracks
+ * @export
+ * @interface SubscribeOptions
+ */
+interface SubscribeOptions {
+    /**
+     * The format of the output audio
+     * @type {string}
+     * @memberof SubscribeOptions
+     */
+    'audioFormat'?: SubscribeOptionsAudioFormatEnum;
+    /**
+     * The sample rate of the output audio
+     * @type {number}
+     * @memberof SubscribeOptions
+     */
+    'audioSampleRate'?: SubscribeOptionsAudioSampleRateEnum;
+}
+declare const SubscribeOptionsAudioFormatEnum: {
+    readonly Pcm16: "pcm16";
+};
+type SubscribeOptionsAudioFormatEnum = typeof SubscribeOptionsAudioFormatEnum[keyof typeof SubscribeOptionsAudioFormatEnum];
+declare const SubscribeOptionsAudioSampleRateEnum: {
+    readonly NUMBER_16000: 16000;
+    readonly NUMBER_24000: 24000;
+};
+type SubscribeOptionsAudioSampleRateEnum = typeof SubscribeOptionsAudioSampleRateEnum[keyof typeof SubscribeOptionsAudioSampleRateEnum];
+/**
+ * Configuration of server-side subscriptions to the peer\'s tracks
+ * @export
+ * @interface SubscribeOptions1
+ */
+interface SubscribeOptions1 {
+    /**
+     * The format of the output audio
+     * @type {string}
+     * @memberof SubscribeOptions1
+     */
+    'audioFormat'?: SubscribeOptions1AudioFormatEnum;
+    /**
+     * The sample rate of the output audio
+     * @type {number}
+     * @memberof SubscribeOptions1
+     */
+    'audioSampleRate'?: SubscribeOptions1AudioSampleRateEnum;
+}
+declare const SubscribeOptions1AudioFormatEnum: {
+    readonly Pcm16: "pcm16";
+};
+type SubscribeOptions1AudioFormatEnum = typeof SubscribeOptions1AudioFormatEnum[keyof typeof SubscribeOptions1AudioFormatEnum];
+declare const SubscribeOptions1AudioSampleRateEnum: {
+    readonly NUMBER_16000: 16000;
+    readonly NUMBER_24000: 24000;
+};
+type SubscribeOptions1AudioSampleRateEnum = typeof SubscribeOptions1AudioSampleRateEnum[keyof typeof SubscribeOptions1AudioSampleRateEnum];
 /**
  * Describes media track of a Peer or Component
  * @export
  * @interface Track
  */
-interface Track {
+interface Track$1 {
     /**
      *
      * @type {string}
@@ -140,10 +230,10 @@ interface Track {
     'id'?: string;
     /**
      *
-     * @type {any}
+     * @type {object}
      * @memberof Track
      */
-    'metadata'?: any | null;
+    'metadata'?: object | null;
     /**
      *
      * @type {string}
@@ -170,6 +260,285 @@ 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;
+    streamConnected?: ServerMessage_StreamConnected | undefined;
+    streamDisconnected?: ServerMessage_StreamDisconnected | undefined;
+    viewerConnected?: ServerMessage_ViewerConnected | undefined;
+    viewerDisconnected?: ServerMessage_ViewerDisconnected | 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>;
+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
 }
@@ -237,14 +606,58 @@ type Room = {
     config: RoomConfig;
 };
 type FishjamConfig = {
-    fishjamUrl: string;
+    fishjamId?: string;
+    fishjamUrl?: 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.
@@ -252,7 +665,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;
@@ -266,6 +727,8 @@ declare class FishjamWSNotifier extends FishjamWSNotifier_base {
 declare class FishjamClient {
     private readonly roomApi;
     private readonly viewerApi;
+    private readonly streamerApi;
+    private readonly fishjamConfig;
     /**
      * Create new instance of Fishjam Client.
      *
@@ -297,6 +760,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.
      */
@@ -316,8 +786,16 @@ declare class FishjamClient {
      * @returns a livestream viewer token
      */
     createLivestreamViewerToken(roomId: RoomId): Promise<ViewerToken>;
+    /**
+     * Creates a livestream streamer token for the given room.
+     * @returns a livestream streamer token
+     */
+    createLivestreamStreamerToken(roomId: RoomId): Promise<StreamerToken>;
 }
 
+declare class MissingFishjamIdException extends Error {
+    constructor();
+}
 declare class FishjamBaseException extends Error {
     statusCode: number;
     axiosCode?: string;
@@ -341,4 +819,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, type NotificationEvents, type Peer, type PeerId, PeerNotFoundException, type PeerOptions, PeerStatus, type Room, type RoomConfig, RoomConfigRoomTypeEnum, RoomConfigVideoCodecEnum, type RoomId, RoomNotFoundException, ServiceUnavailableException, 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 };