import { SignalTarget } from '@livekit/protocol'; import type { Throws } from '../utils/throws'; import PCTransport from './PCTransport'; import { NegotiationError } from './errors'; import type { LoggerOptions } from './types'; export declare enum PCTransportState { NEW = 0, CONNECTING = 1, CONNECTED = 2, FAILED = 3, CLOSING = 4, CLOSED = 5 } type PCMode = 'subscriber-primary' | 'publisher-primary' | 'publisher-only'; export type PCTransportManagerOptions = { rtcConfig?: RTCConfiguration; peerConnectionTimeout?: number; }; export declare class PCTransportManager { publisher: PCTransport; subscriber?: PCTransport; readonly peerConnectionTimeout: number; get needsPublisher(): boolean; get needsSubscriber(): boolean; get currentState(): PCTransportState; onStateChange?: (state: PCTransportState, pubState: RTCPeerConnectionState, subState?: RTCPeerConnectionState) => void; onIceCandidate?: (ev: RTCIceCandidate, target: SignalTarget) => void; onDataChannel?: (ev: RTCDataChannelEvent) => void; onTrack?: (ev: RTCTrackEvent) => void; onPublisherOffer?: (offer: RTCSessionDescriptionInit, offerId: number) => void; private isPublisherConnectionRequired; private isSubscriberConnectionRequired; private state; private connectionLock; private remoteOfferLock; private log; private iceLog; private loggerOptions; private _mode; get mode(): PCMode; constructor(mode: PCMode, loggerOptions: LoggerOptions, { rtcConfig, peerConnectionTimeout, }?: PCTransportManagerOptions); private get logContext(); requirePublisher(require?: boolean): void; createAndSendPublisherOffer(options?: RTCOfferOptions): Promise; setPublisherAnswer(sd: RTCSessionDescriptionInit, offerId: number): Promise; removeTrack(sender: RTCRtpSender, stop?: boolean): void; close(): Promise; /** * Restarts ICE on the transports that need it. Only the publisher: the server restarts the * subscriber's ICE itself and follows with a fresh offer. * * The subscriber deliberately does NOT enter `restartingIce` here. Queueing its remote * candidates would guard against candidates for a new generation arriving before the offer * that introduces it, but the server does not send them in that order -- on a same-node * resume it buffers them until the offer has gone out, and on a reconnect that lands on * another node it withholds subscriber candidates until immediately before creating the * offer. Setting the flag only risks withholding candidates during the window that decides * whether the reconnect succeeded. */ triggerIceRestart(): Promise; addIceCandidate(candidate: RTCIceCandidateInit, target: SignalTarget): Promise; createSubscriberAnswerFromOffer(sd: RTCSessionDescriptionInit, offerId: number): Promise; updateConfiguration(config: RTCConfiguration, iceRestart?: boolean): void; ensurePCTransportConnection(abortController?: AbortController, timeout?: number): Promise; negotiate(abortController: AbortController): Promise>; addPublisherTransceiver(track: MediaStreamTrack, transceiverInit: RTCRtpTransceiverInit): RTCRtpTransceiver; addPublisherTransceiverOfKind(kind: 'audio' | 'video', transceiverInit: RTCRtpTransceiverInit): RTCRtpTransceiver; getTransceiverForReceiver(receiver: RTCRtpReceiver): RTCRtpTransceiver | undefined; getMaxPublisherMessageSize(): number | undefined; addPublisherTrack(track: MediaStreamTrack): RTCRtpSender; createPublisherDataChannel(label: string, dataChannelDict: RTCDataChannelInit): RTCDataChannel; /** * Returns the first required transport's address if no explicit target is specified */ getConnectedAddress(target?: SignalTarget): Promise; private get requiredTransports(); private updateState; private ensureTransportConnected; } export {}; //# sourceMappingURL=PCTransportManager.d.ts.map