@cloudflare/realtimekit 1.1.6 → 1.1.7-agent.1

package/dist/index.d.ts

@@ -3,6 +3,7 @@ import * as _dyteinternals_utils from '@dyteinternals/utils';
 import { MediaVideoQualityType, ViewType, LivestreamViewerMediaQualityType, MediaProductionPermissionType, WaitingRoomTypes, createNewFlagsmithInstance, PresetTypeV2, MediaScreenShareQualityType, PluginAccessControls, RecorderType as RecorderType$1, BorderRadius, BorderWidth, Theme } from '@dyteinternals/utils';
 import { MessageType as MessageType$1 } from '@protobuf-ts/runtime';
 import EventEmitter, { EventEmitter as EventEmitter$1 } from 'events';
+import * as transform from 'sdp-transform';
 import * as WorkerTimers from 'worker-timers';
 
 /**
@@ -115,6 +116,101 @@ interface SessionDescription {
  * @generated MessageType for protobuf message media.SessionDescription
  */
 declare const SessionDescription: SessionDescription$Type;
+declare class ProducerPayload$Type extends MessageType$1<ProducerPayload> {
+    constructor();
+}
+/**
+ * @generated from protobuf message media.ProducerPayload
+ */
+interface ProducerPayload {
+    /**
+     * @generated from protobuf field: string kind = 1;
+     */
+    kind: string;
+    /**
+     * @generated from protobuf field: bool paused = 2;
+     */
+    paused: boolean;
+    /**
+     * @generated from protobuf field: bool screen_share = 3;
+     */
+    screenShare: boolean;
+    /**
+     * @generated from protobuf field: string msid = 4;
+     */
+    msid: string;
+    /**
+     * @generated from protobuf field: optional string app_data = 5;
+     */
+    appData?: string;
+    /**
+     * @generated from protobuf field: optional string mime_type = 6;
+     */
+    mimeType?: string;
+}
+/**
+ * @generated MessageType for protobuf message media.ProducerPayload
+ */
+declare const ProducerPayload: ProducerPayload$Type;
+declare class CreateTransportRequest$Type extends MessageType$1<CreateTransportRequest> {
+    constructor();
+}
+/**
+ * @generated from protobuf message media.CreateTransportRequest
+ */
+interface CreateTransportRequest {
+    /**
+     * @generated from protobuf field: bool consuming = 1;
+     */
+    consuming: boolean;
+    /**
+     * @generated from protobuf field: optional bool force_tcp = 2;
+     */
+    forceTcp?: boolean;
+    /**
+     * @generated from protobuf field: media.SessionDescription description = 3;
+     */
+    description?: SessionDescription;
+    /**
+     * @generated from protobuf field: optional bool private_ice = 4;
+     */
+    privateIce?: boolean;
+    /**
+     * Batch create producers. SessionDescription can be blank,
+     * only need transport level SessionDescription
+     *
+     * @generated from protobuf field: repeated media.ProducerPayload producers = 5;
+     */
+    producers: ProducerPayload[];
+}
+/**
+ * @generated MessageType for protobuf message media.CreateTransportRequest
+ */
+declare const CreateTransportRequest: CreateTransportRequest$Type;
+declare class AudioActivityRequest$Type extends MessageType$1<AudioActivityRequest> {
+    constructor();
+}
+/**
+ * @generated from protobuf message media.AudioActivityRequest
+ */
+interface AudioActivityRequest {
+    /**
+     * @generated from protobuf field: string producer_id = 1;
+     */
+    producerId: string;
+    /**
+     * @generated from protobuf field: int32 energy = 2;
+     */
+    energy: number;
+    /**
+     * @generated from protobuf field: bool silent = 3;
+     */
+    silent: boolean;
+}
+/**
+ * @generated MessageType for protobuf message media.AudioActivityRequest
+ */
+declare const AudioActivityRequest: AudioActivityRequest$Type;
 declare class ProducerTrack$Type extends MessageType$1<ProducerTrack> {
     constructor();
 }
@@ -271,7 +367,291 @@ interface RtpCapabilitites {
  * @generated MessageType for protobuf message media.RtpCapabilitites
  */
 declare const RtpCapabilitites: RtpCapabilitites$Type;
+declare class PreferredCodec$Type extends MessageType$1<PreferredCodec> {
+    constructor();
+}
+/**
+ * @generated from protobuf message media.PreferredCodec
+ */
+interface PreferredCodec {
+    /**
+     * @generated from protobuf field: optional string audio = 1;
+     */
+    audio?: string;
+    /**
+     * @generated from protobuf field: optional string video = 2;
+     */
+    video?: string;
+}
+/**
+ * @generated MessageType for protobuf message media.PreferredCodec
+ */
+declare const PreferredCodec: PreferredCodec$Type;
+declare class Simulcast$Type extends MessageType$1<Simulcast> {
+    constructor();
+}
+/**
+ * @generated from protobuf message media.Simulcast
+ */
+interface Simulcast {
+    /**
+     * @generated from protobuf field: optional string preferred_rid = 1;
+     */
+    preferredRid?: string;
+    /**
+     * @generated from protobuf field: optional string priority_ordering = 2;
+     */
+    priorityOrdering?: string;
+    /**
+     * @generated from protobuf field: optional string rid_not_available = 3;
+     */
+    ridNotAvailable?: string;
+}
+/**
+ * @generated MessageType for protobuf message media.Simulcast
+ */
+declare const Simulcast: Simulcast$Type;
 
+declare class GeoLocation$Type extends MessageType$1<GeoLocation$1> {
+    constructor();
+}
+/**
+ * @generated from protobuf message media.edge.GeoLocation
+ */
+interface GeoLocation$1 {
+    /**
+     * @generated from protobuf field: float latitude = 1;
+     */
+    latitude: number;
+    /**
+     * @generated from protobuf field: float longitude = 2;
+     */
+    longitude: number;
+    /**
+     * @generated from protobuf field: optional string region = 3;
+     */
+    region?: string;
+}
+/**
+ * @generated MessageType for protobuf message media.edge.GeoLocation
+ */
+declare const GeoLocation$1: GeoLocation$Type;
+declare class ConsumePeerRequest$Type extends MessageType$1<ConsumePeerRequest> {
+    constructor();
+}
+/**
+ * @generated from protobuf message media.edge.ConsumePeerRequest
+ */
+interface ConsumePeerRequest {
+    /**
+     * @generated from protobuf field: string producing_peer_id = 1;
+     */
+    producingPeerId: string;
+    /**
+     * @generated from protobuf field: optional bool paused = 2;
+     */
+    paused?: boolean;
+    /**
+     * @generated from protobuf field: optional string producer_id = 3;
+     */
+    producerId?: string;
+    /**
+     * @generated from protobuf field: optional media.PreferredCodec preferred_codec = 4;
+     */
+    preferredCodec?: PreferredCodec;
+    /**
+     * @generated from protobuf field: optional string producing_transport_id = 5;
+     */
+    producingTransportId?: string;
+    /**
+     * @generated from protobuf field: optional media.Simulcast simulcast = 6;
+     */
+    simulcast?: Simulcast;
+}
+/**
+ * @generated MessageType for protobuf message media.edge.ConsumePeerRequest
+ */
+declare const ConsumePeerRequest: ConsumePeerRequest$Type;
+declare class ConsumePeersRequest$Type extends MessageType$1<ConsumePeersRequest> {
+    constructor();
+}
+/**
+ * @generated from protobuf message media.edge.ConsumePeersRequest
+ */
+interface ConsumePeersRequest {
+    /**
+     * @generated from protobuf field: repeated media.edge.ConsumePeerRequest requests = 1;
+     */
+    requests: ConsumePeerRequest[];
+    /**
+     * @generated from protobuf field: optional string consuming_transport_id = 2;
+     */
+    consumingTransportId?: string;
+}
+/**
+ * @generated MessageType for protobuf message media.edge.ConsumePeersRequest
+ */
+declare const ConsumePeersRequest: ConsumePeersRequest$Type;
+declare class UpdateConsumerSimulcastConfigRequest$Type extends MessageType$1<UpdateConsumerSimulcastConfigRequest> {
+    constructor();
+}
+/**
+ * @generated from protobuf message media.edge.UpdateConsumerSimulcastConfigRequest
+ */
+interface UpdateConsumerSimulcastConfigRequest {
+    /**
+     * @generated from protobuf field: string producer_id = 1;
+     */
+    producerId: string;
+    /**
+     * @generated from protobuf field: media.Simulcast simulcast = 2;
+     */
+    simulcast?: Simulcast;
+    /**
+     * @generated from protobuf field: string producing_transport_id = 3;
+     */
+    producingTransportId: string;
+    /**
+     * @generated from protobuf field: string mid = 4;
+     */
+    mid: string;
+}
+/**
+ * @generated MessageType for protobuf message media.edge.UpdateConsumerSimulcastConfigRequest
+ */
+declare const UpdateConsumerSimulcastConfigRequest: UpdateConsumerSimulcastConfigRequest$Type;
+declare class UpdateConsumersSimulcastConfigRequest$Type extends MessageType$1<UpdateConsumersSimulcastConfigRequest> {
+    constructor();
+}
+/**
+ * @generated from protobuf message media.edge.UpdateConsumersSimulcastConfigRequest
+ */
+interface UpdateConsumersSimulcastConfigRequest {
+    /**
+     * @generated from protobuf field: repeated media.edge.UpdateConsumerSimulcastConfigRequest requests = 1;
+     */
+    requests: UpdateConsumerSimulcastConfigRequest[];
+    /**
+     * @generated from protobuf field: optional string consuming_transport_id = 2;
+     */
+    consumingTransportId?: string;
+}
+/**
+ * @generated MessageType for protobuf message media.edge.UpdateConsumersSimulcastConfigRequest
+ */
+declare const UpdateConsumersSimulcastConfigRequest: UpdateConsumersSimulcastConfigRequest$Type;
+declare class ProducerCreateRequest$Type extends MessageType$1<ProducerCreateRequest> {
+    constructor();
+}
+/**
+ * @generated from protobuf message media.edge.ProducerCreateRequest
+ */
+interface ProducerCreateRequest {
+    /**
+     * @generated from protobuf field: string kind = 1;
+     */
+    kind: string;
+    /**
+     * @generated from protobuf field: bool paused = 2;
+     */
+    paused: boolean;
+    /**
+     * @generated from protobuf field: bool screen_share = 3;
+     */
+    screenShare: boolean;
+    /**
+     * @generated from protobuf field: media.SessionDescription description = 4;
+     */
+    description?: SessionDescription;
+    /**
+     * @generated from protobuf field: string msid = 5;
+     */
+    msid: string;
+    /**
+     * @generated from protobuf field: optional string app_data = 6;
+     */
+    appData?: string;
+    /**
+     * @generated from protobuf field: optional string mime_type = 7;
+     */
+    mimeType?: string;
+    /**
+     * @generated from protobuf field: optional string producing_transport_id = 8;
+     */
+    producingTransportId?: string;
+}
+/**
+ * @generated MessageType for protobuf message media.edge.ProducerCreateRequest
+ */
+declare const ProducerCreateRequest: ProducerCreateRequest$Type;
+declare class ProducerCloseRequest$Type extends MessageType$1<ProducerCloseRequest> {
+    constructor();
+}
+/**
+ * @generated from protobuf message media.edge.ProducerCloseRequest
+ */
+interface ProducerCloseRequest {
+    /**
+     * @generated from protobuf field: string producer_id = 1;
+     */
+    producerId: string;
+    /**
+     * @generated from protobuf field: media.SessionDescription description = 2;
+     */
+    description?: SessionDescription;
+    /**
+     * @generated from protobuf field: optional string producing_transport_id = 3;
+     */
+    producingTransportId?: string;
+}
+/**
+ * @generated MessageType for protobuf message media.edge.ProducerCloseRequest
+ */
+declare const ProducerCloseRequest: ProducerCloseRequest$Type;
+declare class ConsumerCloseRequest$Type extends MessageType$1<ConsumerCloseRequest> {
+    constructor();
+}
+/**
+ * @generated from protobuf message media.edge.ConsumerCloseRequest
+ */
+interface ConsumerCloseRequest {
+    /**
+     * @generated from protobuf field: repeated string consumer_ids = 1;
+     */
+    consumerIds: string[];
+    /**
+     * @generated from protobuf field: media.SessionDescription description = 2;
+     */
+    description?: SessionDescription;
+    /**
+     * @generated from protobuf field: optional string consuming_transport_id = 3;
+     */
+    consumingTransportId?: string;
+}
+/**
+ * @generated MessageType for protobuf message media.edge.ConsumerCloseRequest
+ */
+declare const ConsumerCloseRequest: ConsumerCloseRequest$Type;
+declare class PeerDisplayNameEditRequest$Type extends MessageType$1<PeerDisplayNameEditRequest> {
+    constructor();
+}
+/**
+ * @generated from protobuf message media.edge.PeerDisplayNameEditRequest
+ */
+interface PeerDisplayNameEditRequest {
+    /**
+     * @generated from protobuf field: string participant_id = 1;
+     */
+    participantId: string;
+    /**
+     * @generated from protobuf field: string display_name = 2;
+     */
+    displayName: string;
+}
+/**
+ * @generated MessageType for protobuf message media.edge.PeerDisplayNameEditRequest
+ */
+declare const PeerDisplayNameEditRequest: PeerDisplayNameEditRequest$Type;
 declare class GetRoomStateResponse$Type extends MessageType$1<GetRoomStateResponse> {
     constructor();
 }
@@ -842,6 +1222,22 @@ interface MovePeersBetweenRoomsRequest {
  * @generated MessageType for protobuf message socket.room.MovePeersBetweenRoomsRequest
  */
 declare const MovePeersBetweenRoomsRequest: MovePeersBetweenRoomsRequest$Type;
+declare class RemoveParticipantsRequest$Type extends MessageType$1<RemoveParticipantsRequest> {
+    constructor();
+}
+/**
+ * @generated from protobuf message socket.room.RemoveParticipantsRequest
+ */
+interface RemoveParticipantsRequest {
+    /**
+     * @generated from protobuf field: repeated string peer_ids = 1;
+     */
+    peerIds: string[];
+}
+/**
+ * @generated MessageType for protobuf message socket.room.RemoveParticipantsRequest
+ */
+declare const RemoveParticipantsRequest: RemoveParticipantsRequest$Type;
 declare class WaitingRoomRequest$Type extends MessageType$1<WaitingRoomRequest> {
     constructor();
 }
@@ -3017,14 +3413,298 @@ declare abstract class HandlerInterface<TransportPromiseEvents> extends Enhanced
     _addEventListeners(): void;
     addCustomEventListeners(): void;
 }
+type HandlerFactory<TransportPromiseEvents> = () => HandlerInterface<TransportPromiseEvents>;
 
+type ProducerOptions = {
+    track?: MediaStreamTrack;
+    encodings?: RTCRtpEncodingParameters[];
+    codecOptions?: CodecOption[];
+    stopTracks?: boolean;
+    disableTrackOnPause?: boolean;
+    zeroRtpOnPause?: boolean;
+    appData?: Record<string, unknown>;
+};
 type MediaKind$1 = 'audio' | 'video';
+type ProducerConstructorOptions = {
+    id: string;
+    localId: string;
+    track?: MediaStreamTrack;
+    stopTracks: boolean;
+    disableTrackOnPause: boolean;
+    zeroRtpOnPause: boolean;
+    handler: HandlerInterface<TransportPromiseEvents>;
+    appData?: Record<string, unknown>;
+    rtpSender?: RTCRtpSender;
+};
+declare class Producer extends EnhancedEventEmitter<TransportPromiseEvents> {
+    readonly id: string;
+    readonly localId: string;
+    readonly kind: MediaKind$1;
+    readonly appData: Record<string, unknown>;
+    readonly rtpSender: RTCRtpSender;
+    constructor(context: Context<RTKContextState>, opt: ProducerConstructorOptions);
+    get closed(): boolean;
+    get track(): MediaStreamTrack | null;
+    get paused(): boolean;
+    get maxSpatialLayer(): number | undefined;
+    close(reason?: string): Promise<void>;
+    getStats(): Promise<RTCStatsReport>;
+    pause(): void;
+    resume(): void;
+    replaceTrack({ track, }: {
+        track: MediaStreamTrack | null;
+    }): Promise<void>;
+    setMaxSpatialLayer(spatialLayer: number): Promise<void>;
+    setRtpEncodingParameters(params: RTCRtpEncodingParameters): Promise<void>;
+}
 
+declare enum SendType {
+    Request = "REQUEST",
+    Response = "RESPONSE",
+    Notify = "NOTIFY"
+}
+type RPCMessage = {
+    id: string;
+    method: string;
+    timer: NodeJS.Timeout | number;
+    resolve: (v: unknown) => void;
+    cancel: (e: unknown) => void;
+};
 type DCMessage = {
     type: string;
     payload: Record<string, unknown>;
 };
+type DCMessageChunked = {
+    id: string;
+    count: number;
+    chunkIndex: number;
+    chunk: string;
+};
+type ExtendedDCMessage = {
+    payload: {
+        _bolt: {
+            id: string;
+            type: SendType;
+            version: number;
+        };
+    };
+} & DCMessage;
+declare class Datachannel extends EventEmitter$1 {
+    readonly label: string;
+    readonly transportId: string;
+    static createRequest: (data: DCMessage) => ExtendedDCMessage;
+    static createResponse: (id: string, data: DCMessage) => {
+        type: string;
+        payload: {
+            _bolt: {
+                id: string;
+                type: SendType;
+                version: number;
+            };
+        };
+    };
+    static createNotification: (data: DCMessage) => {
+        type: string;
+        payload: {
+            bolt: {
+                id: string;
+                type: SendType;
+                version: number;
+            };
+        };
+    };
+    static createErrorResponse: (id: string, error: Error) => ExtendedDCMessage;
+    channel: RTCDataChannel;
+    queue: Map<string, RPCMessage>;
+    serverProtocolVersion?: number;
+    constructor(context: Context<RTKContextState>, dc: RTCDataChannel, label: string, transportId: string);
+    respond: (id: string, data: DCMessage | Error, error?: boolean) => void;
+    notify: (data: DCMessage) => void;
+    request: (data: DCMessage) => Promise<{
+        type: string;
+        payload: Record<string, unknown>;
+    }>;
+    send: (payload: DCMessage) => void;
+    processMessage: (dcmsg: DCMessageChunked) => ExtendedDCMessage | undefined;
+    processResponseMsg: (msg: ExtendedDCMessage) => boolean;
+    processBoltHandshake: (msg: ExtendedDCMessage) => boolean;
+}
+
+type ConsumerStates = Map<string, {
+    producingTransportId: string;
+} & ConsumerStateObject>;
+declare abstract class ConsumerStrategy {
+    abstract create(producers: ProducerState[]): Promise<{
+        consumerStates: ConsumerStates;
+        sessionDescription?: SessionDescription;
+        failedProducers?: (ProducerState & {
+            errorCode?: string;
+            consumerId?: string;
+        })[];
+    }>;
+    abstract close(consumers: Consumer[]): Promise<{
+        failedConsumers?: Consumer['id'][];
+    }>;
+    abstract negotiate(offer: RTCSessionDescriptionInit, reqId?: string, channelLabel?: string): Promise<RTCSessionDescriptionInit>;
+    abstract switchConsumersToLayer(consumer: Consumer[], layer: number): Promise<void>;
+}
+
+declare const mediaEvents: {
+    readonly unknown: 0;
+    readonly createWebRTCTransport: 1;
+    readonly produce: 2;
+    readonly consume: 3;
+    readonly toggleProducer: 4;
+    readonly toggleConsumer: 5;
+    readonly closeProducer: 6;
+    readonly closeConsumer: 7;
+    readonly updateConsumersSimulcastConfig: 8;
+    readonly joinRoom: 16;
+    readonly leaveRoom: 17;
+    readonly selectedPeer: 18;
+    readonly globalPinPeer: 19;
+    readonly selfJoinComplete: 20;
+    readonly peerJoinedBroadcast: 25;
+    readonly peerLeaveBroadcast: 26;
+    readonly peerProducerCreateBroadcast: 27;
+    readonly peerProducerToggleBroadcast: 28;
+    readonly peerProducerCloseBroadcast: 29;
+    readonly globalPeerPinBroadcast: 30;
+    readonly recordingStartedBroadcast: 31;
+    readonly recordingStoppedBroadcast: 32;
+    readonly peerDisplayNameEditBroadcast: 33;
+    readonly mediaRoomTerminationBroadcastResponse: 36;
+    readonly selectedPeerDiff: 40;
+    readonly renegotiateSessionDescription: 50;
+    readonly errorResponse: 60;
+    readonly kickPeer: 90;
+    readonly kickAll: 91;
+    readonly changeDisplayName: 92;
+    readonly hostControlPeer: 93;
+    readonly hostControlAllPeers: 94;
+    readonly audioActivity: 100;
+};
+declare const cfMediaEvents: {
+    readonly unknown: 0;
+    readonly createWebRTCTransport: 1;
+    readonly produce: 2;
+    readonly consume: 3;
+    readonly toggleProducer: 4;
+    readonly toggleConsumer: 5;
+    readonly closeProducer: 6;
+    readonly closeConsumer: 7;
+    readonly updateConsumersSimulcastConfig: 8;
+    readonly joinRoom: 16;
+    readonly leaveRoom: 17;
+    readonly selectedPeer: 18;
+    readonly globalPinPeer: 19;
+    readonly selfJoinComplete: 20;
+    readonly peerJoinedBroadcast: 25;
+    readonly peerLeaveBroadcast: 26;
+    readonly peerProducerCreateBroadcast: 27;
+    readonly peerProducerToggleBroadcast: 28;
+    readonly peerProducerCloseBroadcast: 29;
+    readonly globalPeerPinBroadcast: 30;
+    readonly recordingStartedBroadcast: 31;
+    readonly recordingStoppedBroadcast: 32;
+    readonly peerDisplayNameEditBroadcast: 33;
+    readonly mediaRoomTerminationBroadcastResponse: 36;
+    readonly selectedPeerDiff: 40;
+    readonly renegotiateSessionDescription: 50;
+    readonly errorResponse: 60;
+    readonly kickPeer: 90;
+    readonly kickAll: 91;
+    readonly changeDisplayName: 92;
+    readonly hostControlPeer: 93;
+    readonly hostControlAllPeers: 94;
+    readonly audioActivity: 100;
+};
+
+declare class SFUSocketOps {
+    events: typeof cfMediaEvents | typeof mediaEvents;
+    sfuType: MediaNodeType;
+    constructor(socket: SocketService, sfuType: MediaNodeType);
+    joinRoom(roomUuid: string, displayName: string, capabilities: PeerRtpCapabilitites, prejoined?: boolean, location?: GeoLocation$1): Promise<Uint8Array>;
+    connectTransport(request: CreateTransportRequest): Promise<{
+        transportId: string;
+        answer: RTCSessionDescriptionInit;
+        producerIds: string[];
+    }>;
+    produce(req: ProducerCreateRequest): Promise<{
+        answer: RTCSessionDescriptionInit;
+        producerId: string;
+    }>;
+    consume(req: ConsumePeersRequest): Promise<{
+        consumerStateMap: {
+            [key: string]: ConsumerState;
+        };
+        sessionDescription: SessionDescription;
+    }>;
+    closeProducer(req: ProducerCloseRequest): Promise<SessionDescription>;
+    closeConsumer(req: ConsumerCloseRequest): Promise<Uint8Array>;
+    updateConsumersSimulcastConfig(req: UpdateConsumersSimulcastConfigRequest): Promise<Uint8Array>;
+    hostControlForPeer(peerId: string, kind: 'audio' | 'video'): Promise<boolean>;
+    hostControlForAll(kind: 'audio' | 'video'): Promise<boolean>;
+    kickAll(): Promise<void>;
+    kickPeer(req: RemoveParticipantsRequest): Promise<void>;
+    changeDisplayName(req: PeerDisplayNameEditRequest): Promise<boolean>;
+    notifySelfJoinComplete(): Promise<PeerJoinCompleteResponse>;
+    audioActivity(req: AudioActivityRequest): Promise<void>;
+}
+
+type CreateProducerInfo = {
+    offer: RTCSessionDescriptionInit;
+    kind: string;
+    paused: boolean;
+    appData: ProducerOptions['appData'];
+    codecOptions: CodecOption[];
+    producingTransportId: string;
+};
 
+type AwaitQueueTask<T> = () => (T | PromiseLike<T>);
+type AwaitQueueTaskDump = {
+    idx: number;
+    task: AwaitQueueTask<unknown>;
+    name?: string;
+    enqueuedTime: number;
+    executionTime: number;
+};
+type PendingTask<T> = {
+    id: number;
+    task: AwaitQueueTask<T>;
+    metadata: Record<string, unknown>;
+    name?: string;
+    enqueuedAt: number;
+    executedAt?: number;
+    completedAt?: number;
+    completed: boolean;
+    resolve: (result: T | PromiseLike<T>) => void;
+    reject: (error: Error) => void;
+};
+declare class AwaitQueue {
+    readonly log: boolean;
+    pendingTasks: Map<number, PendingTask<any>>;
+    constructor(logger?: RTKLogger$1, log?: boolean);
+    get size(): number;
+    push<T>(task: AwaitQueueTask<T>, name?: string, metadata?: Record<string, unknown>): Promise<T>;
+    stop(): void;
+    remove(taskIdx: number): void;
+    get<T>(taskIdx: number): PendingTask<T>;
+    dump(): AwaitQueueTaskDump[];
+}
+
+type TransportOptions = {
+    iceServers?: RTCIceServer[];
+    iceTransportPolicy?: RTCIceTransportPolicy;
+    additionalSettings?: Record<string, unknown>;
+    proprietaryConstraints?: Record<string, unknown>;
+    appData?: Record<string, unknown>;
+    config?: {
+        enableDtx?: boolean;
+        enableStereo: boolean;
+        enableHighBitrate: boolean;
+    };
+};
 type TransportPromiseEvents = {
     'close': {
         answer: RTCSessionDescriptionInit;
@@ -3033,7 +3713,125 @@ type TransportPromiseEvents = {
         description: RTCSessionDescriptionInit;
     };
 };
+type ConnectionState = 'new' | 'connecting' | 'connected' | 'failed' | 'disconnected' | 'closed';
+type InternalTransportOptions = {
+    id?: string;
+    direction: 'send' | 'recv';
+    handlerFactory?: HandlerFactory<TransportPromiseEvents>;
+    config?: {
+        enableDtx?: boolean;
+        enableStereo: boolean;
+        enableHighBitrate: boolean;
+    };
+} & TransportOptions;
+declare class Transport extends EnhancedEventEmitter<TransportPromiseEvents> {
+    awaitQueue: AwaitQueue;
+    observer: EnhancedEventEmitter<TransportPromiseEvents>;
+    readonly id: string;
+    serverId: string;
+    readonly direction: 'send' | 'recv';
+    readonly maxSctpMessageSize?: number | undefined;
+    handler: HandlerInterface<TransportPromiseEvents>;
+    connectionState: ConnectionState;
+    readonly producers: Map<string, Producer>;
+    readonly consumers: Map<string, Consumer>;
+    readonly datachannels: Map<string, Datachannel>;
+    connected: boolean;
+    eventsDCReadyPromise: Promise<boolean>;
+    eventsDCReadyPromiseResolver: (value: boolean | PromiseLike<boolean>) => void;
+    eventsDCFailureTimer: NodeJS.Timeout;
+    transportConnectionPromise: Promise<boolean>;
+    readonly consumerTrackEvents: Map<string, (track: MediaStreamTrack, transceiver: RTCRtpTransceiver) => void>;
+    readonly unknownTracksMap: Map<string, RTCTrackEvent>;
+    readonly appData: Record<string, unknown>;
+    get closed(): boolean;
+    constructor(context: Context<RTKContextState>, sfu: MediaNodeType, { id, direction, handlerFactory, iceServers, iceTransportPolicy, proprietaryConstraints, additionalSettings, appData, config, }: InternalTransportOptions);
+    setServerId(id: string): void;
+    getDatachannel(label: string): Datachannel;
+    get isEventsDCReady(): Promise<boolean>;
+    close(): void;
+    getStats(): Promise<RTCStatsReport>;
+    connect(transportConnectionRequest: (offer: RTCSessionDescriptionInit) => Promise<{
+        transportId: string;
+        answer: RTCSessionDescriptionInit;
+    }>): Promise<void>;
+    restartIce(): Promise<GenericHandlerResult>;
+    canProduce(producerOptions: ProducerOptions): Promise<boolean>;
+    produce(producerOptions: ProducerOptions, producerCreationRequest: (info: CreateProducerInfo) => Promise<{
+        answer: RTCSessionDescriptionInit;
+        producerId: string;
+    }>): Promise<Producer>;
+    createProducerObject(opts: ProducerConstructorOptions): Promise<Producer>;
+    closeProducer(producer: Producer): Promise<void>;
+    canConsume(): Promise<boolean>;
+    consume(producers: ProducerState[], consumerCreationRequest: ConsumerStrategy['create'], negotiationRequest: ConsumerStrategy['negotiate']): Promise<{
+        consumers: Consumer[];
+        failedProducers: (ProducerState & {
+            errorCode?: string;
+            consumerId?: string;
+        })[];
+    }>;
+    static parseCodecAndFmtpMappings(sdp: RTCSessionDescription, mids: string[]): {
+        [mid: string]: {
+            rtp: transform.MediaAttributes['rtp'];
+            fmtp: transform.MediaAttributes['fmtp'];
+            payloads: string;
+            rtcpFb: transform.MediaAttributes['rtcpFb'];
+        };
+    };
+    static setCodecAndFmtpMappings(sdp: RTCSessionDescriptionInit, mids: string[], payloadMappings: {
+        [mid: string]: {
+            rtp: transform.MediaAttributes['rtp'];
+            fmtp: transform.MediaAttributes['fmtp'];
+            payloads: string;
+            rtcpFb: transform.MediaAttributes['rtcpFb'];
+        };
+    }): {
+        sdp: string;
+        type: RTCSdpType;
+    };
+    static parseHeaderExtensionMappings(sdp: RTCSessionDescriptionInit): {
+        [mid: string]: {
+            value: number;
+            direction?: string;
+            uri: string;
+            config?: string;
+        }[];
+    };
+    static setHeaderExtensionMappings(sdp: RTCSessionDescriptionInit, headerExtensions: {
+        [mid: string]: transform.SharedAttributes['ext'];
+    }): {
+        sdp: string;
+        type: RTCSdpType;
+    };
+    closeConsumers(consumers: Consumer[], closeFn: (consumers: Consumer[], offer: RTCSessionDescriptionInit) => Promise<RTCSessionDescriptionInit>): Promise<void>;
+    setRemoteOffer(offer: RTCSessionDescriptionInit): Promise<RTCSessionDescriptionInit>;
+    _ontrack(event: RTCTrackEvent): void;
+    sendErrorOverDC(label: string, id: string, error: Error): void;
+    sendResponseOverDC(label: string, id: string, payload: DCMessage): void;
+    createConsumerObjectAndWaitForTrack(opts: ConsumerCreationTaskOptions): Promise<Consumer>;
+    setRemoteDescription(sdp: RTCSessionDescriptionInit): Promise<void>;
+    setLocalDescription(sdp: RTCSessionDescriptionInit): Promise<void>;
+    sendDataChannelMessage(channel: string, req: DCMessage): Promise<Record<string, unknown>>;
+}
 
+type ConsumerStateObject = {
+    consumerId: string;
+    trackId: string;
+    streamId: string;
+    screenShare: boolean;
+    paused: boolean;
+    appData: any;
+    kind: 'audio' | 'video';
+    producingPeerId: string;
+    mimeType?: string;
+};
+type ConsumerCreationTaskOptions = {
+    producerId: string;
+    producingPeerId: string;
+    producingTransportId: string;
+    appData: Record<string, unknown>;
+} & ConsumerStateObject;
 type ConsumerOptions = {
     id?: string;
     producerId: string;
@@ -3681,6 +4479,11 @@ declare class RTKSelf$1 extends RTKSelfMedia$1 {
     removeDocumentEventListeners(): Promise<void>;
     enableAudio(customTrack?: MediaStreamTrack): Promise<void>;
     enableVideo(customTrack?: MediaStreamTrack): Promise<void>;
+    produce(payload: {
+        producingTransportId: string;
+        producerId: string;
+        kind: string;
+    }): Promise<void>;
     updateVideoConstraints(resolution: VideoQualityConstraints): Promise<void>;
     enableScreenShare(): Promise<void>;
     updateScreenshareConstraints(resolution: VideoQualityConstraints): Promise<void>;
@@ -4627,11 +5430,11 @@ declare class BrowserDetection {
     isMobile(): boolean;
     getDeviceInfo: () => {
         isMobile: boolean;
-        browserName: any;
-        osName: any;
-        browserVersion: any;
-        osVersionName: any;
-        engineName: any;
+        browserName: string;
+        osName: string;
+        browserVersion: string;
+        osVersionName: string;
+        engineName: string;
     };
     _checkCondition(checkTree: any): any;
     isVersionGreaterThan(version: any): any;
@@ -4745,6 +5548,93 @@ declare const enum PRODUCERS_TYPE {
     SCREENSHARE_AUDIO = "screenshare_audio"
 }
 
+declare class TransportLayer extends EventEmitter$1 {
+    context: Context<RTKContextState>;
+    get telemetry(): RTKTelemetry;
+    get logger(): RTKLogger$1;
+    protected get socket(): SocketService;
+    protected get socketHandler(): SFUSocketOps;
+    protected get sendTransport(): Transport;
+    protected get recvTransport(): Transport;
+    get events(): {
+        readonly unknown: 0;
+        readonly createWebRTCTransport: 1;
+        readonly produce: 2;
+        readonly consume: 3;
+        readonly toggleProducer: 4;
+        readonly toggleConsumer: 5;
+        readonly closeProducer: 6;
+        readonly closeConsumer: 7;
+        readonly updateConsumersSimulcastConfig: 8;
+        readonly joinRoom: 16;
+        readonly leaveRoom: 17;
+        readonly selectedPeer: 18;
+        readonly globalPinPeer: 19;
+        readonly selfJoinComplete: 20;
+        readonly peerJoinedBroadcast: 25;
+        readonly peerLeaveBroadcast: 26;
+        readonly peerProducerCreateBroadcast: 27;
+        readonly peerProducerToggleBroadcast: 28;
+        readonly peerProducerCloseBroadcast: 29;
+        readonly globalPeerPinBroadcast: 30;
+        readonly recordingStartedBroadcast: 31;
+        readonly recordingStoppedBroadcast: 32;
+        readonly peerDisplayNameEditBroadcast: 33;
+        readonly mediaRoomTerminationBroadcastResponse: 36;
+        readonly selectedPeerDiff: 40;
+        readonly renegotiateSessionDescription: 50;
+        readonly errorResponse: 60;
+        readonly kickPeer: 90;
+        readonly kickAll: 91;
+        readonly changeDisplayName: 92;
+        readonly hostControlPeer: 93;
+        readonly hostControlAllPeers: 94;
+        readonly audioActivity: 100;
+    };
+    protected get nodeType(): MediaNodeType;
+    protected set sendTransportConnectedCallback(cb: (transport: Transport) => void);
+    protected set recvTransportConnectedCallback(cb: (transport: Transport) => void);
+    constructor(context: Context<RTKContextState>, socket: SocketService, nodeType: MediaNodeType);
+    setupTransports(directions: {
+        send?: boolean;
+        recv?: boolean;
+    }): Promise<void>;
+    stopTransports(directions: {
+        send?: boolean;
+        recv?: boolean;
+    }): void;
+    stopAllTransports(): void;
+}
+
+declare class SFUHandler extends TransportLayer {
+    get socketHandler(): SFUSocketOps;
+    get producers(): Map<string, Producer>;
+    get consumers(): Map<string, Consumer>;
+    get producerIdToConsumerIdMap(): Map<string, string>;
+    get logger(): RTKLogger$1;
+    constructor(context: Context<RTKContextState>, socket: SocketService, nodeType: MediaNodeType);
+    reset(): void;
+    createProducer(producerOptions: ProducerOptions, onClose: () => void): Promise<Producer>;
+    closeProducer(id: Producer['id'], options?: Partial<{
+        stopTrack: boolean;
+    }>): Promise<void>;
+    closeAllProducers(): Promise<void[]>;
+    produce(payload: {
+        producingTransportId: string;
+        producerId: string;
+        kind: string;
+    }): Promise<{
+        answer: RTCSessionDescriptionInit;
+        producerId: string;
+    }>;
+    createConsumer(producer: ProducerState): Promise<void>;
+    createConsumers(producers: ProducerState[]): Promise<void>;
+    closeConsumer(consumer: Consumer['id']): Promise<void>;
+    closeConsumers(consumers: Consumer['id'][]): Promise<void>;
+    closeAllConsumers(): Promise<void>;
+    switchConsumersToLayer(consumers: Consumer[], layer: number): Promise<void>;
+}
+
 interface MediaPermissions {
     canProduceAudio?: MediaProductionPermissionType;
     canProduceVideo?: MediaProductionPermissionType;
@@ -4761,6 +5651,7 @@ declare class MediaNodeClient {
     readonly authToken: string;
     readonly e2ee: boolean;
     get peerId(): string;
+    get sfuHandler(): SFUHandler;
     get telemetry(): RTKTelemetry;
     get logger(): RTKLogger$1;
     constructor(context: Context<RTKContextState>, nodeType: MediaNodeType, options: MediaNodeClientOptions);