mediasoup-client 3.6.88 → 3.6.90

package/lib/index.d.ts

@@ -1,24 +1,1445 @@
-import debug from 'debug';
-import { Device, detectDevice } from './Device';
-import * as types from './types';
+export { default as debug } from 'debug';
+import { EventEmitter } from 'events';
+
+type Events = Record<string, any[]>;
+declare class EnhancedEventEmitter<E extends Events = Events> extends EventEmitter {
+    constructor();
+    emit<K extends keyof E & string>(eventName: K, ...args: E[K]): boolean;
+    /**
+     * Special addition to the EventEmitter API.
+     */
+    safeEmit<K extends keyof E & string>(eventName: K, ...args: E[K]): boolean;
+    on<K extends keyof E & string>(eventName: K, listener: (...args: E[K]) => void): this;
+    off<K extends keyof E & string>(eventName: K, listener: (...args: E[K]) => void): this;
+    addListener<K extends keyof E & string>(eventName: K, listener: (...args: E[K]) => void): this;
+    prependListener<K extends keyof E & string>(eventName: K, listener: (...args: E[K]) => void): this;
+    once<K extends keyof E & string>(eventName: K, listener: (...args: E[K]) => void): this;
+    prependOnceListener<K extends keyof E & string>(eventName: K, listener: (...args: E[K]) => void): this;
+    removeListener<K extends keyof E & string>(eventName: K, listener: (...args: E[K]) => void): this;
+    removeAllListeners<K extends keyof E & string>(eventName?: K): this;
+    listenerCount<K extends keyof E & string>(eventName: K): number;
+    listeners<K extends keyof E & string>(eventName: K): Function[];
+    rawListeners<K extends keyof E & string>(eventName: K): Function[];
+}
+
 /**
- * Expose all types.
+ * The RTP capabilities define what mediasoup or an endpoint can receive at
+ * media level.
  */
-export { types };
+type RtpCapabilities = {
+    /**
+     * Supported media and RTX codecs.
+     */
+    codecs?: RtpCodecCapability[];
+    /**
+     * Supported RTP header extensions.
+     */
+    headerExtensions?: RtpHeaderExtension[];
+};
 /**
- * Expose mediasoup-client version.
+ * Media kind ('audio' or 'video').
+ */
+type MediaKind = 'audio' | 'video';
+/**
+ * Provides information on the capabilities of a codec within the RTP
+ * capabilities. The list of media codecs supported by mediasoup and their
+ * settings is defined in the supportedRtpCapabilities.ts file.
+ *
+ * Exactly one RtpCodecCapability will be present for each supported combination
+ * of parameters that requires a distinct value of preferredPayloadType. For
+ * example:
+ *
+ * - Multiple H264 codecs, each with their own distinct 'packetization-mode' and
+ *   'profile-level-id' values.
+ * - Multiple VP9 codecs, each with their own distinct 'profile-id' value.
+ *
+ * RtpCodecCapability entries in the mediaCodecs array of RouterOptions do not
+ * require preferredPayloadType field (if unset, mediasoup will choose a random
+ * one). If given, make sure it's in the 96-127 range.
+ */
+type RtpCodecCapability = {
+    /**
+     * Media kind.
+     */
+    kind: MediaKind;
+    /**
+     * The codec MIME media type/subtype (e.g. 'audio/opus', 'video/VP8').
+     */
+    mimeType: string;
+    /**
+     * The preferred RTP payload type.
+     */
+    preferredPayloadType?: number;
+    /**
+     * Codec clock rate expressed in Hertz.
+     */
+    clockRate: number;
+    /**
+     * The number of channels supported (e.g. two for stereo). Just for audio.
+     * Default 1.
+     */
+    channels?: number;
+    /**
+     * Codec specific parameters. Some parameters (such as 'packetization-mode'
+     * and 'profile-level-id' in H264 or 'profile-id' in VP9) are critical for
+     * codec matching.
+     */
+    parameters?: any;
+    /**
+     * Transport layer and codec-specific feedback messages for this codec.
+     */
+    rtcpFeedback?: RtcpFeedback[];
+};
+/**
+ * Direction of RTP header extension.
+ */
+type RtpHeaderExtensionDirection = 'sendrecv' | 'sendonly' | 'recvonly' | 'inactive';
+/**
+ * Provides information relating to supported header extensions. The list of
+ * RTP header extensions supported by mediasoup is defined in the
+ * supportedRtpCapabilities.ts file.
+ *
+ * mediasoup does not currently support encrypted RTP header extensions. The
+ * direction field is just present in mediasoup RTP capabilities (retrieved via
+ * router.rtpCapabilities or mediasoup.getSupportedRtpCapabilities()). It's
+ * ignored if present in endpoints' RTP capabilities.
+ */
+type RtpHeaderExtension = {
+    /**
+     * Media kind.
+     */
+    kind: MediaKind;
+    uri: string;
+    /**
+     * The preferred numeric identifier that goes in the RTP packet. Must be
+     * unique.
+     */
+    preferredId: number;
+    /**
+     * If true, it is preferred that the value in the header be encrypted as per
+     * RFC 6904. Default false.
+     */
+    preferredEncrypt?: boolean;
+    /**
+     * If 'sendrecv', mediasoup supports sending and receiving this RTP extension.
+     * 'sendonly' means that mediasoup can send (but not receive) it. 'recvonly'
+     * means that mediasoup can receive (but not send) it.
+     */
+    direction?: RtpHeaderExtensionDirection;
+};
+/**
+ * The RTP send parameters describe a media stream received by mediasoup from
+ * an endpoint through its corresponding mediasoup Producer. These parameters
+ * may include a mid value that the mediasoup transport will use to match
+ * received RTP packets based on their MID RTP extension value.
+ *
+ * mediasoup allows RTP send parameters with a single encoding and with multiple
+ * encodings (simulcast). In the latter case, each entry in the encodings array
+ * must include a ssrc field or a rid field (the RID RTP extension value). Check
+ * the Simulcast and SVC sections for more information.
+ *
+ * The RTP receive parameters describe a media stream as sent by mediasoup to
+ * an endpoint through its corresponding mediasoup Consumer. The mid value is
+ * unset (mediasoup does not include the MID RTP extension into RTP packets
+ * being sent to endpoints).
+ *
+ * There is a single entry in the encodings array (even if the corresponding
+ * producer uses simulcast). The consumer sends a single and continuous RTP
+ * stream to the endpoint and spatial/temporal layer selection is possible via
+ * consumer.setPreferredLayers().
+ *
+ * As an exception, previous bullet is not true when consuming a stream over a
+ * PipeTransport, in which all RTP streams from the associated producer are
+ * forwarded verbatim through the consumer.
+ *
+ * The RTP receive parameters will always have their ssrc values randomly
+ * generated for all of its  encodings (and optional rtx: { ssrc: XXXX } if the
+ * endpoint supports RTX), regardless of the original RTP send parameters in
+ * the associated producer. This applies even if the producer's encodings have
+ * rid set.
+ */
+type RtpParameters = {
+    /**
+     * The MID RTP extension value as defined in the BUNDLE specification.
+     */
+    mid?: string;
+    /**
+     * Media and RTX codecs in use.
+     */
+    codecs: RtpCodecParameters[];
+    /**
+     * RTP header extensions in use.
+     */
+    headerExtensions?: RtpHeaderExtensionParameters[];
+    /**
+     * Transmitted RTP streams and their settings.
+     */
+    encodings?: RtpEncodingParameters[];
+    /**
+     * Parameters used for RTCP.
+     */
+    rtcp?: RtcpParameters;
+};
+/**
+ * Provides information on codec settings within the RTP parameters. The list
+ * of media codecs supported by mediasoup and their settings is defined in the
+ * supportedRtpCapabilities.ts file.
+ */
+type RtpCodecParameters = {
+    /**
+     * The codec MIME media type/subtype (e.g. 'audio/opus', 'video/VP8').
+     */
+    mimeType: string;
+    /**
+     * The value that goes in the RTP Payload Type Field. Must be unique.
+     */
+    payloadType: number;
+    /**
+     * Codec clock rate expressed in Hertz.
+     */
+    clockRate: number;
+    /**
+     * The number of channels supported (e.g. two for stereo). Just for audio.
+     * Default 1.
+     */
+    channels?: number;
+    /**
+     * Codec-specific parameters available for signaling. Some parameters (such
+     * as 'packetization-mode' and 'profile-level-id' in H264 or 'profile-id' in
+     * VP9) are critical for codec matching.
+     */
+    parameters?: any;
+    /**
+     * Transport layer and codec-specific feedback messages for this codec.
+     */
+    rtcpFeedback?: RtcpFeedback[];
+};
+/**
+ * Provides information on RTCP feedback messages for a specific codec. Those
+ * messages can be transport layer feedback messages or codec-specific feedback
+ * messages. The list of RTCP feedbacks supported by mediasoup is defined in the
+ * supportedRtpCapabilities.ts file.
+ */
+type RtcpFeedback = {
+    /**
+     * RTCP feedback type.
+     */
+    type: string;
+    /**
+     * RTCP feedback parameter.
+     */
+    parameter?: string;
+};
+/**
+ * Provides information relating to an encoding, which represents a media RTP
+ * stream and its associated RTX stream (if any).
+ */
+type RtpEncodingParameters = {
+    /**
+     * The media SSRC.
+     */
+    ssrc?: number;
+    /**
+     * The RID RTP extension value. Must be unique.
+     */
+    rid?: string;
+    /**
+     * Codec payload type this encoding affects. If unset, first media codec is
+     * chosen.
+     */
+    codecPayloadType?: number;
+    /**
+     * RTX stream information. It must contain a numeric ssrc field indicating
+     * the RTX SSRC.
+     */
+    rtx?: {
+        ssrc: number;
+    };
+    /**
+     * It indicates whether discontinuous RTP transmission will be used. Useful
+     * for audio (if the codec supports it) and for video screen sharing (when
+     * static content is being transmitted, this option disables the RTP
+     * inactivity checks in mediasoup). Default false.
+     */
+    dtx?: boolean;
+    /**
+     * Number of spatial and temporal layers in the RTP stream (e.g. 'L1T3').
+     * See webrtc-svc.
+     */
+    scalabilityMode?: string;
+    /**
+     * Others.
+     */
+    scaleResolutionDownBy?: number;
+    maxBitrate?: number;
+    maxFramerate?: number;
+    adaptivePtime?: boolean;
+    priority?: 'very-low' | 'low' | 'medium' | 'high';
+    networkPriority?: 'very-low' | 'low' | 'medium' | 'high';
+};
+/**
+ * Defines a RTP header extension within the RTP parameters. The list of RTP
+ * header extensions supported by mediasoup is defined in the
+ * supportedRtpCapabilities.ts file.
+ *
+ * mediasoup does not currently support encrypted RTP header extensions and no
+ * parameters are currently considered.
+ */
+type RtpHeaderExtensionParameters = {
+    /**
+     * The URI of the RTP header extension, as defined in RFC 5285.
+     */
+    uri: string;
+    /**
+     * The numeric identifier that goes in the RTP packet. Must be unique.
+     */
+    id: number;
+    /**
+     * If true, the value in the header is encrypted as per RFC 6904. Default false.
+     */
+    encrypt?: boolean;
+    /**
+     * Configuration parameters for the header extension.
+     */
+    parameters?: any;
+};
+/**
+ * Provides information on RTCP settings within the RTP parameters.
+ *
+ * If no cname is given in a producer's RTP parameters, the mediasoup transport
+ * will choose a random one that will be used into RTCP SDES messages sent to
+ * all its associated consumers.
+ *
+ * mediasoup assumes reducedSize to always be true.
+ */
+type RtcpParameters = {
+    /**
+     * The Canonical Name (CNAME) used by RTCP (e.g. in SDES messages).
+     */
+    cname?: string;
+    /**
+     * Whether reduced size RTCP RFC 5506 is configured (if true) or compound RTCP
+     * as specified in RFC 3550 (if false). Default true.
+     */
+    reducedSize?: boolean;
+    /**
+     * Whether RTCP-mux is used. Default true.
+     */
+    mux?: boolean;
+};
+
+type ConsumerOptions<ConsumerAppData extends AppData = AppData> = {
+    id?: string;
+    producerId?: string;
+    kind?: 'audio' | 'video';
+    rtpParameters: RtpParameters;
+    streamId?: string;
+    appData?: ConsumerAppData;
+};
+type ConsumerEvents = {
+    transportclose: [];
+    trackended: [];
+    '@getstats': [(stats: RTCStatsReport) => void, (error: Error) => void];
+    '@close': [];
+    '@pause': [];
+    '@resume': [];
+};
+type ConsumerObserverEvents = {
+    close: [];
+    pause: [];
+    resume: [];
+    trackended: [];
+};
+declare class Consumer<ConsumerAppData extends AppData = AppData> extends EnhancedEventEmitter<ConsumerEvents> {
+    private readonly _id;
+    private readonly _localId;
+    private readonly _producerId;
+    private _closed;
+    private readonly _rtpReceiver?;
+    private readonly _track;
+    private readonly _rtpParameters;
+    private _paused;
+    private _appData;
+    protected readonly _observer: EnhancedEventEmitter<ConsumerObserverEvents>;
+    constructor({ id, localId, producerId, rtpReceiver, track, rtpParameters, appData }: {
+        id: string;
+        localId: string;
+        producerId: string;
+        rtpReceiver?: RTCRtpReceiver;
+        track: MediaStreamTrack;
+        rtpParameters: RtpParameters;
+        appData?: ConsumerAppData;
+    });
+    /**
+     * Consumer id.
+     */
+    get id(): string;
+    /**
+     * Local id.
+     */
+    get localId(): string;
+    /**
+     * Associated Producer id.
+     */
+    get producerId(): string;
+    /**
+     * Whether the Consumer is closed.
+     */
+    get closed(): boolean;
+    /**
+     * Media kind.
+     */
+    get kind(): MediaKind;
+    /**
+     * Associated RTCRtpReceiver.
+     */
+    get rtpReceiver(): RTCRtpReceiver | undefined;
+    /**
+     * The associated track.
+     */
+    get track(): MediaStreamTrack;
+    /**
+     * RTP parameters.
+     */
+    get rtpParameters(): RtpParameters;
+    /**
+     * Whether the Consumer is paused.
+     */
+    get paused(): boolean;
+    /**
+     * App custom data.
+     */
+    get appData(): ConsumerAppData;
+    /**
+     * App custom data setter.
+     */
+    set appData(appData: ConsumerAppData);
+    get observer(): EnhancedEventEmitter;
+    /**
+     * Closes the Consumer.
+     */
+    close(): void;
+    /**
+     * Transport was closed.
+     */
+    transportClosed(): void;
+    /**
+     * Get associated RTCRtpReceiver stats.
+     */
+    getStats(): Promise<RTCStatsReport>;
+    /**
+     * Pauses receiving media.
+     */
+    pause(): void;
+    /**
+     * Resumes receiving media.
+     */
+    resume(): void;
+    private onTrackEnded;
+    private handleTrack;
+    private destroyTrack;
+}
+
+type SctpCapabilities = {
+    numStreams: NumSctpStreams;
+};
+type NumSctpStreams = {
+    /**
+     * Initially requested number of outgoing SCTP streams.
+     */
+    OS: number;
+    /**
+     * Maximum number of incoming SCTP streams.
+     */
+    MIS: number;
+};
+type SctpParameters = {
+    /**
+     * Must always equal 5000.
+     */
+    port: number;
+    /**
+     * Initially requested number of outgoing SCTP streams.
+     */
+    OS: number;
+    /**
+     * Maximum number of incoming SCTP streams.
+     */
+    MIS: number;
+    /**
+     * Maximum allowed size for SCTP messages.
+     */
+    maxMessageSize: number;
+};
+/**
+ * SCTP stream parameters describe the reliability of a certain SCTP stream.
+ * If ordered is true then maxPacketLifeTime and maxRetransmits must be
+ * false.
+ * If ordered if false, only one of maxPacketLifeTime or maxRetransmits
+ * can be true.
  */
-export declare const version = "3.6.88";
+type SctpStreamParameters = {
+    /**
+     * SCTP stream id.
+     */
+    streamId?: number;
+    /**
+     * Whether data messages must be received in order. if true the messages will
+     * be sent reliably. Default true.
+     */
+    ordered?: boolean;
+    /**
+     * When ordered is false indicates the time (in milliseconds) after which a
+     * SCTP packet will stop being retransmitted.
+     */
+    maxPacketLifeTime?: number;
+    /**
+     * When ordered is false indicates the maximum number of times a packet will
+     * be retransmitted.
+     */
+    maxRetransmits?: number;
+    /**
+     * A label which can be used to distinguish this DataChannel from others.
+     */
+    label?: string;
+    /**
+     * Name of the sub-protocol used by this DataChannel.
+     */
+    protocol?: string;
+};
+
+type DataProducerOptions<DataProducerAppData extends AppData = AppData> = {
+    ordered?: boolean;
+    maxPacketLifeTime?: number;
+    maxRetransmits?: number;
+    label?: string;
+    protocol?: string;
+    appData?: DataProducerAppData;
+};
+type DataProducerEvents = {
+    transportclose: [];
+    open: [];
+    error: [Error];
+    close: [];
+    bufferedamountlow: [];
+    '@close': [];
+};
+type DataProducerObserverEvents = {
+    close: [];
+};
+declare class DataProducer<DataProducerAppData extends AppData = AppData> extends EnhancedEventEmitter<DataProducerEvents> {
+    private readonly _id;
+    private readonly _dataChannel;
+    private _closed;
+    private readonly _sctpStreamParameters;
+    private _appData;
+    protected readonly _observer: EnhancedEventEmitter<DataProducerObserverEvents>;
+    constructor({ id, dataChannel, sctpStreamParameters, appData }: {
+        id: string;
+        dataChannel: RTCDataChannel;
+        sctpStreamParameters: SctpStreamParameters;
+        appData?: DataProducerAppData;
+    });
+    /**
+     * DataProducer id.
+     */
+    get id(): string;
+    /**
+     * Whether the DataProducer is closed.
+     */
+    get closed(): boolean;
+    /**
+     * SCTP stream parameters.
+     */
+    get sctpStreamParameters(): SctpStreamParameters;
+    /**
+     * DataChannel readyState.
+     */
+    get readyState(): RTCDataChannelState;
+    /**
+     * DataChannel label.
+     */
+    get label(): string;
+    /**
+     * DataChannel protocol.
+     */
+    get protocol(): string;
+    /**
+     * DataChannel bufferedAmount.
+     */
+    get bufferedAmount(): number;
+    /**
+     * DataChannel bufferedAmountLowThreshold.
+     */
+    get bufferedAmountLowThreshold(): number;
+    /**
+     * Set DataChannel bufferedAmountLowThreshold.
+     */
+    set bufferedAmountLowThreshold(bufferedAmountLowThreshold: number);
+    /**
+     * App custom data.
+     */
+    get appData(): DataProducerAppData;
+    /**
+     * App custom data setter.
+     */
+    set appData(appData: DataProducerAppData);
+    get observer(): EnhancedEventEmitter;
+    /**
+     * Closes the DataProducer.
+     */
+    close(): void;
+    /**
+     * Transport was closed.
+     */
+    transportClosed(): void;
+    /**
+     * Send a message.
+     *
+     * @param {String|Blob|ArrayBuffer|ArrayBufferView} data.
+     */
+    send(data: any): void;
+    private handleDataChannel;
+}
+
+type DataConsumerOptions<DataConsumerAppData extends AppData = AppData> = {
+    id?: string;
+    dataProducerId?: string;
+    sctpStreamParameters: SctpStreamParameters;
+    label?: string;
+    protocol?: string;
+    appData?: DataConsumerAppData;
+};
+type DataConsumerEvents = {
+    transportclose: [];
+    open: [];
+    error: [Error];
+    close: [];
+    message: [any];
+    '@close': [];
+};
+type DataConsumerObserverEvents = {
+    close: [];
+};
+declare class DataConsumer<DataConsumerAppData extends AppData = AppData> extends EnhancedEventEmitter<DataConsumerEvents> {
+    private readonly _id;
+    private readonly _dataProducerId;
+    private readonly _dataChannel;
+    private _closed;
+    private readonly _sctpStreamParameters;
+    private _appData;
+    protected readonly _observer: EnhancedEventEmitter<DataConsumerObserverEvents>;
+    constructor({ id, dataProducerId, dataChannel, sctpStreamParameters, appData }: {
+        id: string;
+        dataProducerId: string;
+        dataChannel: RTCDataChannel;
+        sctpStreamParameters: SctpStreamParameters;
+        appData?: DataConsumerAppData;
+    });
+    /**
+     * DataConsumer id.
+     */
+    get id(): string;
+    /**
+     * Associated DataProducer id.
+     */
+    get dataProducerId(): string;
+    /**
+     * Whether the DataConsumer is closed.
+     */
+    get closed(): boolean;
+    /**
+     * SCTP stream parameters.
+     */
+    get sctpStreamParameters(): SctpStreamParameters;
+    /**
+     * DataChannel readyState.
+     */
+    get readyState(): RTCDataChannelState;
+    /**
+     * DataChannel label.
+     */
+    get label(): string;
+    /**
+     * DataChannel protocol.
+     */
+    get protocol(): string;
+    /**
+     * DataChannel binaryType.
+     */
+    get binaryType(): BinaryType;
+    /**
+     * Set DataChannel binaryType.
+     */
+    set binaryType(binaryType: BinaryType);
+    /**
+     * App custom data.
+     */
+    get appData(): DataConsumerAppData;
+    /**
+     * App custom data setter.
+     */
+    set appData(appData: DataConsumerAppData);
+    get observer(): EnhancedEventEmitter;
+    /**
+     * Closes the DataConsumer.
+     */
+    close(): void;
+    /**
+     * Transport was closed.
+     */
+    transportClosed(): void;
+    private handleDataChannel;
+}
+
 /**
- * Expose Device class and detectDevice() helper.
+ * Error indicating not support for something.
  */
-export { Device, detectDevice };
+declare class UnsupportedError extends Error {
+    constructor(message: string);
+}
 /**
- * Expose parseScalabilityMode() function.
+ * Error produced when calling a method in an invalid state.
  */
-export { parse as parseScalabilityMode } from './scalabilityModes';
+declare class InvalidStateError extends Error {
+    constructor(message: string);
+}
+
+type ScalabilityMode = {
+    spatialLayers: number;
+    temporalLayers: number;
+};
+declare function parse(scalabilityMode?: string): ScalabilityMode;
+
+type AppData = {
+    [key: string]: unknown;
+};
+
+type types_AppData = AppData;
+type types_BuiltinHandlerName = BuiltinHandlerName;
+type types_CanProduceByKind = CanProduceByKind;
+type types_ConnectionState = ConnectionState;
+type types_Consumer<ConsumerAppData extends AppData = AppData> = Consumer<ConsumerAppData>;
+declare const types_Consumer: typeof Consumer;
+type types_ConsumerEvents = ConsumerEvents;
+type types_ConsumerObserverEvents = ConsumerObserverEvents;
+type types_ConsumerOptions<ConsumerAppData extends AppData = AppData> = ConsumerOptions<ConsumerAppData>;
+type types_DataConsumer<DataConsumerAppData extends AppData = AppData> = DataConsumer<DataConsumerAppData>;
+declare const types_DataConsumer: typeof DataConsumer;
+type types_DataConsumerEvents = DataConsumerEvents;
+type types_DataConsumerObserverEvents = DataConsumerObserverEvents;
+type types_DataConsumerOptions<DataConsumerAppData extends AppData = AppData> = DataConsumerOptions<DataConsumerAppData>;
+type types_DataProducer<DataProducerAppData extends AppData = AppData> = DataProducer<DataProducerAppData>;
+declare const types_DataProducer: typeof DataProducer;
+type types_DataProducerEvents = DataProducerEvents;
+type types_DataProducerObserverEvents = DataProducerObserverEvents;
+type types_DataProducerOptions<DataProducerAppData extends AppData = AppData> = DataProducerOptions<DataProducerAppData>;
+type types_Device = Device;
+declare const types_Device: typeof Device;
+type types_DeviceObserverEvents = DeviceObserverEvents;
+type types_DeviceOptions = DeviceOptions;
+type types_DtlsFingerprint = DtlsFingerprint;
+type types_DtlsParameters = DtlsParameters;
+type types_DtlsRole = DtlsRole;
+type types_HandlerEvents = HandlerEvents;
+type types_HandlerFactory = HandlerFactory;
+type types_HandlerInterface = HandlerInterface;
+declare const types_HandlerInterface: typeof HandlerInterface;
+type types_HandlerReceiveDataChannelOptions = HandlerReceiveDataChannelOptions;
+type types_HandlerReceiveDataChannelResult = HandlerReceiveDataChannelResult;
+type types_HandlerReceiveOptions = HandlerReceiveOptions;
+type types_HandlerReceiveResult = HandlerReceiveResult;
+type types_HandlerRunOptions = HandlerRunOptions;
+type types_HandlerSendDataChannelOptions = HandlerSendDataChannelOptions;
+type types_HandlerSendDataChannelResult = HandlerSendDataChannelResult;
+type types_HandlerSendOptions = HandlerSendOptions;
+type types_HandlerSendResult = HandlerSendResult;
+type types_IceCandidate = IceCandidate;
+type types_IceParameters = IceParameters;
+type types_InvalidStateError = InvalidStateError;
+declare const types_InvalidStateError: typeof InvalidStateError;
+type types_MediaKind = MediaKind;
+type types_NumSctpStreams = NumSctpStreams;
+type types_PlainRtpParameters = PlainRtpParameters;
+type types_Producer<ProducerAppData extends AppData = AppData> = Producer<ProducerAppData>;
+declare const types_Producer: typeof Producer;
+type types_ProducerCodecOptions = ProducerCodecOptions;
+type types_ProducerEvents = ProducerEvents;
+type types_ProducerObserverEvents = ProducerObserverEvents;
+type types_ProducerOptions<ProducerAppData extends AppData = AppData> = ProducerOptions<ProducerAppData>;
+type types_RtcpFeedback = RtcpFeedback;
+type types_RtcpParameters = RtcpParameters;
+type types_RtpCapabilities = RtpCapabilities;
+type types_RtpCodecCapability = RtpCodecCapability;
+type types_RtpCodecParameters = RtpCodecParameters;
+type types_RtpEncodingParameters = RtpEncodingParameters;
+type types_RtpHeaderExtension = RtpHeaderExtension;
+type types_RtpHeaderExtensionDirection = RtpHeaderExtensionDirection;
+type types_RtpHeaderExtensionParameters = RtpHeaderExtensionParameters;
+type types_RtpParameters = RtpParameters;
+type types_ScalabilityMode = ScalabilityMode;
+type types_SctpCapabilities = SctpCapabilities;
+type types_SctpParameters = SctpParameters;
+type types_SctpStreamParameters = SctpStreamParameters;
+type types_Transport<TransportAppData extends AppData = AppData> = Transport<TransportAppData>;
+declare const types_Transport: typeof Transport;
+type types_TransportEvents = TransportEvents;
+type types_TransportObserverEvents = TransportObserverEvents;
+type types_TransportOptions<TransportAppData extends AppData = AppData> = TransportOptions<TransportAppData>;
+type types_UnsupportedError = UnsupportedError;
+declare const types_UnsupportedError: typeof UnsupportedError;
+declare const types_detectDevice: typeof detectDevice;
+declare namespace types {
+  export {
+    types_AppData as AppData,
+    types_BuiltinHandlerName as BuiltinHandlerName,
+    types_CanProduceByKind as CanProduceByKind,
+    types_ConnectionState as ConnectionState,
+    types_Consumer as Consumer,
+    types_ConsumerEvents as ConsumerEvents,
+    types_ConsumerObserverEvents as ConsumerObserverEvents,
+    types_ConsumerOptions as ConsumerOptions,
+    types_DataConsumer as DataConsumer,
+    types_DataConsumerEvents as DataConsumerEvents,
+    types_DataConsumerObserverEvents as DataConsumerObserverEvents,
+    types_DataConsumerOptions as DataConsumerOptions,
+    types_DataProducer as DataProducer,
+    types_DataProducerEvents as DataProducerEvents,
+    types_DataProducerObserverEvents as DataProducerObserverEvents,
+    types_DataProducerOptions as DataProducerOptions,
+    types_Device as Device,
+    types_DeviceObserverEvents as DeviceObserverEvents,
+    types_DeviceOptions as DeviceOptions,
+    types_DtlsFingerprint as DtlsFingerprint,
+    types_DtlsParameters as DtlsParameters,
+    types_DtlsRole as DtlsRole,
+    types_HandlerEvents as HandlerEvents,
+    types_HandlerFactory as HandlerFactory,
+    types_HandlerInterface as HandlerInterface,
+    types_HandlerReceiveDataChannelOptions as HandlerReceiveDataChannelOptions,
+    types_HandlerReceiveDataChannelResult as HandlerReceiveDataChannelResult,
+    types_HandlerReceiveOptions as HandlerReceiveOptions,
+    types_HandlerReceiveResult as HandlerReceiveResult,
+    types_HandlerRunOptions as HandlerRunOptions,
+    types_HandlerSendDataChannelOptions as HandlerSendDataChannelOptions,
+    types_HandlerSendDataChannelResult as HandlerSendDataChannelResult,
+    types_HandlerSendOptions as HandlerSendOptions,
+    types_HandlerSendResult as HandlerSendResult,
+    types_IceCandidate as IceCandidate,
+    types_IceParameters as IceParameters,
+    types_InvalidStateError as InvalidStateError,
+    types_MediaKind as MediaKind,
+    types_NumSctpStreams as NumSctpStreams,
+    types_PlainRtpParameters as PlainRtpParameters,
+    types_Producer as Producer,
+    types_ProducerCodecOptions as ProducerCodecOptions,
+    types_ProducerEvents as ProducerEvents,
+    types_ProducerObserverEvents as ProducerObserverEvents,
+    types_ProducerOptions as ProducerOptions,
+    types_RtcpFeedback as RtcpFeedback,
+    types_RtcpParameters as RtcpParameters,
+    types_RtpCapabilities as RtpCapabilities,
+    types_RtpCodecCapability as RtpCodecCapability,
+    types_RtpCodecParameters as RtpCodecParameters,
+    types_RtpEncodingParameters as RtpEncodingParameters,
+    types_RtpHeaderExtension as RtpHeaderExtension,
+    types_RtpHeaderExtensionDirection as RtpHeaderExtensionDirection,
+    types_RtpHeaderExtensionParameters as RtpHeaderExtensionParameters,
+    types_RtpParameters as RtpParameters,
+    types_ScalabilityMode as ScalabilityMode,
+    types_SctpCapabilities as SctpCapabilities,
+    types_SctpParameters as SctpParameters,
+    types_SctpStreamParameters as SctpStreamParameters,
+    types_Transport as Transport,
+    types_TransportEvents as TransportEvents,
+    types_TransportObserverEvents as TransportObserverEvents,
+    types_TransportOptions as TransportOptions,
+    types_UnsupportedError as UnsupportedError,
+    types_detectDevice as detectDevice,
+  };
+}
+
+type ProducerOptions<ProducerAppData extends AppData = AppData> = {
+    track?: MediaStreamTrack;
+    encodings?: RtpEncodingParameters[];
+    codecOptions?: ProducerCodecOptions;
+    codec?: RtpCodecCapability;
+    stopTracks?: boolean;
+    disableTrackOnPause?: boolean;
+    zeroRtpOnPause?: boolean;
+    appData?: ProducerAppData;
+};
+type ProducerCodecOptions = {
+    opusStereo?: boolean;
+    opusFec?: boolean;
+    opusDtx?: boolean;
+    opusMaxPlaybackRate?: number;
+    opusMaxAverageBitrate?: number;
+    opusPtime?: number;
+    opusNack?: boolean;
+    videoGoogleStartBitrate?: number;
+    videoGoogleMaxBitrate?: number;
+    videoGoogleMinBitrate?: number;
+};
+type ProducerEvents = {
+    transportclose: [];
+    trackended: [];
+    '@pause': [
+        () => void,
+        (error: Error) => void
+    ];
+    '@resume': [
+        () => void,
+        (error: Error) => void
+    ];
+    '@replacetrack': [
+        MediaStreamTrack | null,
+        () => void,
+        (error: Error) => void
+    ];
+    '@setmaxspatiallayer': [
+        number,
+        () => void,
+        (error: Error) => void
+    ];
+    '@setrtpencodingparameters': [
+        RTCRtpEncodingParameters,
+        () => void,
+        (error: Error) => void
+    ];
+    '@getstats': [(stats: RTCStatsReport) => void, (error: Error) => void];
+    '@close': [];
+};
+type ProducerObserverEvents = {
+    close: [];
+    pause: [];
+    resume: [];
+    trackended: [];
+};
+declare class Producer<ProducerAppData extends AppData = AppData> extends EnhancedEventEmitter<ProducerEvents> {
+    private readonly _id;
+    private readonly _localId;
+    private _closed;
+    private readonly _rtpSender?;
+    private _track;
+    private readonly _kind;
+    private readonly _rtpParameters;
+    private _paused;
+    private _maxSpatialLayer;
+    private _stopTracks;
+    private _disableTrackOnPause;
+    private _zeroRtpOnPause;
+    private _appData;
+    protected readonly _observer: EnhancedEventEmitter<ProducerObserverEvents>;
+    constructor({ id, localId, rtpSender, track, rtpParameters, stopTracks, disableTrackOnPause, zeroRtpOnPause, appData }: {
+        id: string;
+        localId: string;
+        rtpSender?: RTCRtpSender;
+        track: MediaStreamTrack;
+        rtpParameters: RtpParameters;
+        stopTracks: boolean;
+        disableTrackOnPause: boolean;
+        zeroRtpOnPause: boolean;
+        appData?: ProducerAppData;
+    });
+    /**
+     * Producer id.
+     */
+    get id(): string;
+    /**
+     * Local id.
+     */
+    get localId(): string;
+    /**
+     * Whether the Producer is closed.
+     */
+    get closed(): boolean;
+    /**
+     * Media kind.
+     */
+    get kind(): MediaKind;
+    /**
+     * Associated RTCRtpSender.
+     */
+    get rtpSender(): RTCRtpSender | undefined;
+    /**
+     * The associated track.
+     */
+    get track(): MediaStreamTrack | null;
+    /**
+     * RTP parameters.
+     */
+    get rtpParameters(): RtpParameters;
+    /**
+     * Whether the Producer is paused.
+     */
+    get paused(): boolean;
+    /**
+     * Max spatial layer.
+     *
+     * @type {Number | undefined}
+     */
+    get maxSpatialLayer(): number | undefined;
+    /**
+     * App custom data.
+     */
+    get appData(): ProducerAppData;
+    /**
+     * App custom data setter.
+     */
+    set appData(appData: ProducerAppData);
+    get observer(): EnhancedEventEmitter;
+    /**
+     * Closes the Producer.
+     */
+    close(): void;
+    /**
+     * Transport was closed.
+     */
+    transportClosed(): void;
+    /**
+     * Get associated RTCRtpSender stats.
+     */
+    getStats(): Promise<RTCStatsReport>;
+    /**
+     * Pauses sending media.
+     */
+    pause(): void;
+    /**
+     * Resumes sending media.
+     */
+    resume(): void;
+    /**
+     * Replaces the current track with a new one or null.
+     */
+    replaceTrack({ track }: {
+        track: MediaStreamTrack | null;
+    }): Promise<void>;
+    /**
+     * Sets the video max spatial layer to be sent.
+     */
+    setMaxSpatialLayer(spatialLayer: number): Promise<void>;
+    setRtpEncodingParameters(params: RTCRtpEncodingParameters): Promise<void>;
+    private onTrackEnded;
+    private handleTrack;
+    private destroyTrack;
+}
+
+type HandlerFactory = () => HandlerInterface;
+type HandlerRunOptions = {
+    direction: 'send' | 'recv';
+    iceParameters: IceParameters;
+    iceCandidates: IceCandidate[];
+    dtlsParameters: DtlsParameters;
+    sctpParameters?: SctpParameters;
+    iceServers?: RTCIceServer[];
+    iceTransportPolicy?: RTCIceTransportPolicy;
+    additionalSettings?: any;
+    proprietaryConstraints?: any;
+    extendedRtpCapabilities: any;
+};
+type HandlerSendOptions = {
+    track: MediaStreamTrack;
+    encodings?: RtpEncodingParameters[];
+    codecOptions?: ProducerCodecOptions;
+    codec?: RtpCodecCapability;
+};
+type HandlerSendResult = {
+    localId: string;
+    rtpParameters: RtpParameters;
+    rtpSender?: RTCRtpSender;
+};
+type HandlerReceiveOptions = {
+    trackId: string;
+    kind: 'audio' | 'video';
+    rtpParameters: RtpParameters;
+    /**
+     * Stream id. WebRTC based devices try to synchronize inbound streams with
+     * same streamId. If not given, the consuming device will be told to
+     * synchronize all streams produced by the same endpoint. However libwebrtc
+     * can just synchronize up to one audio stream with one video stream.
+     */
+    streamId?: string;
+};
+type HandlerReceiveResult = {
+    localId: string;
+    track: MediaStreamTrack;
+    rtpReceiver?: RTCRtpReceiver;
+};
+type HandlerSendDataChannelOptions = SctpStreamParameters;
+type HandlerSendDataChannelResult = {
+    dataChannel: RTCDataChannel;
+    sctpStreamParameters: SctpStreamParameters;
+};
+type HandlerReceiveDataChannelOptions = {
+    sctpStreamParameters: SctpStreamParameters;
+    label?: string;
+    protocol?: string;
+};
+type HandlerReceiveDataChannelResult = {
+    dataChannel: RTCDataChannel;
+};
+type HandlerEvents = {
+    '@close': [];
+    '@connect': [
+        {
+            dtlsParameters: DtlsParameters;
+        },
+        () => void,
+        (error: Error) => void
+    ];
+    '@connectionstatechange': [ConnectionState];
+};
+declare abstract class HandlerInterface extends EnhancedEventEmitter<HandlerEvents> {
+    constructor();
+    abstract get name(): string;
+    abstract close(): void;
+    abstract getNativeRtpCapabilities(): Promise<RtpCapabilities>;
+    abstract getNativeSctpCapabilities(): Promise<SctpCapabilities>;
+    abstract run(options: HandlerRunOptions): void;
+    abstract updateIceServers(iceServers: RTCIceServer[]): Promise<void>;
+    abstract restartIce(iceParameters: IceParameters): Promise<void>;
+    abstract getTransportStats(): Promise<RTCStatsReport>;
+    abstract send(options: HandlerSendOptions): Promise<HandlerSendResult>;
+    abstract stopSending(localId: string): Promise<void>;
+    abstract pauseSending(localId: string): Promise<void>;
+    abstract resumeSending(localId: string): Promise<void>;
+    abstract replaceTrack(localId: string, track: MediaStreamTrack | null): Promise<void>;
+    abstract setMaxSpatialLayer(localId: string, spatialLayer: number): Promise<void>;
+    abstract setRtpEncodingParameters(localId: string, params: any): Promise<void>;
+    abstract getSenderStats(localId: string): Promise<RTCStatsReport>;
+    abstract sendDataChannel(options: HandlerSendDataChannelOptions): Promise<HandlerSendDataChannelResult>;
+    abstract receive(optionsList: HandlerReceiveOptions[]): Promise<HandlerReceiveResult[]>;
+    abstract stopReceiving(localIds: string[]): Promise<void>;
+    abstract pauseReceiving(localIds: string[]): Promise<void>;
+    abstract resumeReceiving(localIds: string[]): Promise<void>;
+    abstract getReceiverStats(localId: string): Promise<RTCStatsReport>;
+    abstract receiveDataChannel(options: HandlerReceiveDataChannelOptions): Promise<HandlerReceiveDataChannelResult>;
+}
+
+type TransportOptions<TransportAppData extends AppData = AppData> = {
+    id: string;
+    iceParameters: IceParameters;
+    iceCandidates: IceCandidate[];
+    dtlsParameters: DtlsParameters;
+    sctpParameters?: SctpParameters;
+    iceServers?: RTCIceServer[];
+    iceTransportPolicy?: RTCIceTransportPolicy;
+    additionalSettings?: any;
+    proprietaryConstraints?: any;
+    appData?: TransportAppData;
+};
+type CanProduceByKind = {
+    audio: boolean;
+    video: boolean;
+    [key: string]: boolean;
+};
+type IceParameters = {
+    /**
+     * ICE username fragment.
+     * */
+    usernameFragment: string;
+    /**
+     * ICE password.
+     */
+    password: string;
+    /**
+     * ICE Lite.
+     */
+    iceLite?: boolean;
+};
+type IceCandidate = {
+    /**
+     * Unique identifier that allows ICE to correlate candidates that appear on
+     * multiple transports.
+     */
+    foundation: string;
+    /**
+     * The assigned priority of the candidate.
+     */
+    priority: number;
+    /**
+     * The IP address of the candidate.
+     */
+    ip: string;
+    /**
+     * The protocol of the candidate.
+     */
+    protocol: 'udp' | 'tcp';
+    /**
+     * The port for the candidate.
+     */
+    port: number;
+    /**
+     * The type of candidate.
+     */
+    type: 'host' | 'srflx' | 'prflx' | 'relay';
+    /**
+     * The type of TCP candidate.
+     */
+    tcpType?: 'active' | 'passive' | 'so';
+};
+type DtlsParameters = {
+    /**
+     * Server DTLS role. Default 'auto'.
+     */
+    role?: DtlsRole;
+    /**
+     * Server DTLS fingerprints.
+     */
+    fingerprints: DtlsFingerprint[];
+};
 /**
- * Expose the debug module.
+ * The hash function algorithm (as defined in the "Hash function Textual Names"
+ * registry initially specified in RFC 4572 Section 8) and its corresponding
+ * certificate fingerprint value (in lowercase hex string as expressed utilizing
+ * the syntax of "fingerprint" in RFC 4572 Section 5).
+ */
+type DtlsFingerprint = {
+    algorithm: string;
+    value: string;
+};
+type DtlsRole = 'auto' | 'client' | 'server';
+type ConnectionState = 'new' | 'connecting' | 'connected' | 'failed' | 'disconnected' | 'closed';
+type PlainRtpParameters = {
+    ip: string;
+    ipVersion: 4 | 6;
+    port: number;
+};
+type TransportEvents = {
+    connect: [{
+        dtlsParameters: DtlsParameters;
+    }, () => void, (error: Error) => void];
+    connectionstatechange: [ConnectionState];
+    produce: [
+        {
+            kind: MediaKind;
+            rtpParameters: RtpParameters;
+            appData: AppData;
+        },
+        ({ id }: {
+            id: string;
+        }) => void,
+        (error: Error) => void
+    ];
+    producedata: [
+        {
+            sctpStreamParameters: SctpStreamParameters;
+            label?: string;
+            protocol?: string;
+            appData: AppData;
+        },
+        ({ id }: {
+            id: string;
+        }) => void,
+        (error: Error) => void
+    ];
+};
+type TransportObserverEvents = {
+    close: [];
+    newproducer: [Producer];
+    newconsumer: [Consumer];
+    newdataproducer: [DataProducer];
+    newdataconsumer: [DataConsumer];
+};
+declare class Transport<TransportAppData extends AppData = AppData> extends EnhancedEventEmitter<TransportEvents> {
+    private readonly _id;
+    private _closed;
+    private readonly _direction;
+    private readonly _extendedRtpCapabilities;
+    private readonly _canProduceByKind;
+    private readonly _maxSctpMessageSize?;
+    private readonly _handler;
+    private _connectionState;
+    private _appData;
+    private readonly _producers;
+    private readonly _consumers;
+    private readonly _dataProducers;
+    private readonly _dataConsumers;
+    private _probatorConsumerCreated;
+    private readonly _awaitQueue;
+    private _pendingConsumerTasks;
+    private _consumerCreationInProgress;
+    private _pendingPauseConsumers;
+    private _consumerPauseInProgress;
+    private _pendingResumeConsumers;
+    private _consumerResumeInProgress;
+    private _pendingCloseConsumers;
+    private _consumerCloseInProgress;
+    protected readonly _observer: EnhancedEventEmitter<TransportObserverEvents>;
+    constructor({ direction, id, iceParameters, iceCandidates, dtlsParameters, sctpParameters, iceServers, iceTransportPolicy, additionalSettings, proprietaryConstraints, appData, handlerFactory, extendedRtpCapabilities, canProduceByKind }: {
+        direction: 'send' | 'recv';
+        handlerFactory: HandlerFactory;
+        extendedRtpCapabilities: any;
+        canProduceByKind: CanProduceByKind;
+    } & TransportOptions<TransportAppData>);
+    /**
+     * Transport id.
+     */
+    get id(): string;
+    /**
+     * Whether the Transport is closed.
+     */
+    get closed(): boolean;
+    /**
+     * Transport direction.
+     */
+    get direction(): 'send' | 'recv';
+    /**
+     * RTC handler instance.
+     */
+    get handler(): HandlerInterface;
+    /**
+     * Connection state.
+     */
+    get connectionState(): ConnectionState;
+    /**
+     * App custom data.
+     */
+    get appData(): TransportAppData;
+    /**
+     * App custom data setter.
+     */
+    set appData(appData: TransportAppData);
+    get observer(): EnhancedEventEmitter;
+    /**
+     * Close the Transport.
+     */
+    close(): void;
+    /**
+     * Get associated Transport (RTCPeerConnection) stats.
+     *
+     * @returns {RTCStatsReport}
+     */
+    getStats(): Promise<RTCStatsReport>;
+    /**
+     * Restart ICE connection.
+     */
+    restartIce({ iceParameters }: {
+        iceParameters: IceParameters;
+    }): Promise<void>;
+    /**
+     * Update ICE servers.
+     */
+    updateIceServers({ iceServers }?: {
+        iceServers?: RTCIceServer[];
+    }): Promise<void>;
+    /**
+     * Create a Producer.
+     */
+    produce<ProducerAppData extends AppData = AppData>({ track, encodings, codecOptions, codec, stopTracks, disableTrackOnPause, zeroRtpOnPause, appData }?: ProducerOptions<ProducerAppData>): Promise<Producer<ProducerAppData>>;
+    /**
+     * Create a Consumer to consume a remote Producer.
+     */
+    consume<ConsumerAppData extends AppData = AppData>({ id, producerId, kind, rtpParameters, streamId, appData }: ConsumerOptions<ConsumerAppData>): Promise<Consumer<ConsumerAppData>>;
+    /**
+     * Create a DataProducer
+     */
+    produceData<DataProducerAppData extends AppData = AppData>({ ordered, maxPacketLifeTime, maxRetransmits, label, protocol, appData }?: DataProducerOptions<DataProducerAppData>): Promise<DataProducer<DataProducerAppData>>;
+    /**
+     * Create a DataConsumer
+     */
+    consumeData<ConsumerAppData extends AppData = AppData>({ id, dataProducerId, sctpStreamParameters, label, protocol, appData }: DataConsumerOptions<ConsumerAppData>): Promise<DataConsumer<ConsumerAppData>>;
+    private createPendingConsumers;
+    private pausePendingConsumers;
+    private resumePendingConsumers;
+    private closePendingConsumers;
+    private handleHandler;
+    private handleProducer;
+    private handleConsumer;
+    private handleDataProducer;
+    private handleDataConsumer;
+}
+
+type BuiltinHandlerName = 'Chrome111' | 'Chrome74' | 'Chrome70' | 'Chrome67' | 'Chrome55' | 'Firefox60' | 'Safari12' | 'Safari11' | 'Edge11' | 'ReactNativeUnifiedPlan' | 'ReactNative';
+type DeviceOptions = {
+    /**
+     * The name of one of the builtin handlers.
+     */
+    handlerName?: BuiltinHandlerName;
+    /**
+     * Custom handler factory.
+     */
+    handlerFactory?: HandlerFactory;
+    /**
+     * DEPRECATED!
+     * The name of one of the builtin handlers.
+     */
+    Handler?: string;
+};
+declare function detectDevice(): BuiltinHandlerName | undefined;
+type DeviceObserverEvents = {
+    newtransport: [Transport];
+};
+declare class Device {
+    private readonly _handlerFactory;
+    private readonly _handlerName;
+    private _loaded;
+    private _extendedRtpCapabilities?;
+    private _recvRtpCapabilities?;
+    private readonly _canProduceByKind;
+    private _sctpCapabilities?;
+    protected readonly _observer: EnhancedEventEmitter<DeviceObserverEvents>;
+    /**
+     * Create a new Device to connect to mediasoup server.
+     *
+     * @throws {UnsupportedError} if device is not supported.
+     */
+    constructor({ handlerName, handlerFactory, Handler }?: DeviceOptions);
+    /**
+     * The RTC handler name.
+     */
+    get handlerName(): string;
+    /**
+     * Whether the Device is loaded.
+     */
+    get loaded(): boolean;
+    /**
+     * RTP capabilities of the Device for receiving media.
+     *
+     * @throws {InvalidStateError} if not loaded.
+     */
+    get rtpCapabilities(): RtpCapabilities;
+    /**
+     * SCTP capabilities of the Device.
+     *
+     * @throws {InvalidStateError} if not loaded.
+     */
+    get sctpCapabilities(): SctpCapabilities;
+    get observer(): EnhancedEventEmitter;
+    /**
+     * Initialize the Device.
+     */
+    load({ routerRtpCapabilities }: {
+        routerRtpCapabilities: RtpCapabilities;
+    }): Promise<void>;
+    /**
+     * Whether we can produce audio/video.
+     *
+     * @throws {InvalidStateError} if not loaded.
+     * @throws {TypeError} if wrong arguments.
+     */
+    canProduce(kind: MediaKind): boolean;
+    /**
+     * Creates a Transport for sending media.
+     *
+     * @throws {InvalidStateError} if not loaded.
+     * @throws {TypeError} if wrong arguments.
+     */
+    createSendTransport<TransportAppData extends AppData = AppData>({ id, iceParameters, iceCandidates, dtlsParameters, sctpParameters, iceServers, iceTransportPolicy, additionalSettings, proprietaryConstraints, appData }: TransportOptions<TransportAppData>): Transport<TransportAppData>;
+    /**
+     * Creates a Transport for receiving media.
+     *
+     * @throws {InvalidStateError} if not loaded.
+     * @throws {TypeError} if wrong arguments.
+     */
+    createRecvTransport<TransportAppData extends AppData = AppData>({ id, iceParameters, iceCandidates, dtlsParameters, sctpParameters, iceServers, iceTransportPolicy, additionalSettings, proprietaryConstraints, appData }: TransportOptions<TransportAppData>): Transport<TransportAppData>;
+    private createTransport;
+}
+
+/**
+ * Expose mediasoup-client version.
  */
-export { debug };
-//# sourceMappingURL=index.d.ts.map
+declare const version = "3.6.90";
+
+export { Device, detectDevice, parse as parseScalabilityMode, types, version };