import type { AppData, MediaKind, ProducerCodecOptions, RtpCapabilities, RtpEncodingParameters, RtpParameters, RtpCodecCapability } from 'mediasoup-client/lib/types';
import type { Consumer, ConsumerOptions } from 'mediasoup-client/lib/Consumer';
import type { ConnectionState, DtlsRole } from 'mediasoup-client/lib/Transport';
import type { types } from 'mediasoup-client';
export interface ProduceParams {
    kind: MediaKind;
    rtpParameters: RtpParameters;
    appData: Record<string, unknown>;
}
export interface TrackProduceParams {
    encodings?: RtpEncodingParameters[];
    codecOptions?: ProducerCodecOptions;
    preferredCodec?: string;
    transformParams?: TrackTransformParams;
    keyFrameRequestDelay?: number;
}
export interface PrepareProducerEncodingsParams {
    encodings: RtpEncodingParameters[];
    codec?: RtpCodecCapability;
    maxSpatialLayer: number;
}
export interface TrackTransformParams {
    width?: number;
    height?: number;
}
export interface ProducerData {
    id: string;
    kind: MediaKind;
    peerId: string;
    label: TrackLabel;
    paused: boolean;
    encodings: RtpEncodingParameters[];
    maxSpatialLayer: number;
    trackTransformParams?: TrackTransformParams;
}
export interface ConsumerData {
    producerData: ProducerData;
    peerId: string;
    appId: string;
    channelId: string;
}
export type Role = 'audience' | 'host';
export interface PeerResponse {
    id: string;
    channelIds: string[];
    groups: PeerGroup[];
    producePermissions: TrackLabel[];
    appId: string;
    producers: ProducerData[];
    uid?: string;
    appData: Record<string, unknown>;
    role: Role;
    loginDate: Date;
}
export interface AvailableMediaDevices {
    video: MediaDeviceInfo[];
    audio: MediaDeviceInfo[];
}
export interface JoinChannelParams {
    channelId: string;
    token: string;
    role: Role;
    appData?: Record<string, unknown>;
    isP2pCall?: boolean;
}
export interface ChannelEvent {
    eventName: string;
    data: Record<string, unknown>;
}
export interface PreferredLayersParams {
    spatialLayer: number;
    temporalLayer?: number;
}
export interface ChangePreferredLayersParams {
    consumerId: string;
    peerId: string;
    spatialLayer: number;
    temporalLayer: number;
}
export type EncoderConfig = object;
export type VideoCodec = 'h264' | 'vp8' | 'vp9';
export type AudioCodec = 'opus';
export type VideoEncoderConfig = EncoderConfig & {
    preferredCodec?: VideoCodec;
    encodings?: RtpEncodingParameters[];
    videoGoogleStartBitrate?: number;
};
export type AudioEncoderConfig = EncoderConfig & {
    preferredCodec?: AudioCodec;
    encodings?: RtpEncodingParameters[];
    enableFec?: boolean;
    enableDtx?: boolean;
};
export interface CreateTrackOptions {
    stopTrackOnPause?: boolean;
}
export type BaseVideoTrackOptions = CreateTrackOptions & {
    video?: boolean | MediaTrackConstraints;
};
export type BaseAudioTrackOptions = CreateTrackOptions & {
    audio?: boolean | MediaTrackConstraints;
};
export type CreateCameraVideoTrackOptions = BaseVideoTrackOptions & {
    encoderConfig?: VideoEncoderConfig;
    effects?: boolean;
    isPreview?: boolean;
};
export type CreateMicrophoneAudioTrackOptions = BaseAudioTrackOptions & {
    encoderConfig?: AudioEncoderConfig;
    noiseSuppression?: boolean;
    isPreview?: boolean;
};
export type CreateScreenMediaOptions = BaseVideoTrackOptions & BaseAudioTrackOptions & {
    videoEncoderConfig?: VideoEncoderConfig;
    audioEncoderConfig?: AudioEncoderConfig;
};
export type CreateCustomVideoOptions = BaseVideoTrackOptions & {
    videoEncoderConfig?: VideoEncoderConfig;
    videoTrack: MediaStreamTrack;
};
export type CreateCustomAudioOptions = BaseAudioTrackOptions & {
    audioEncoderConfig?: AudioEncoderConfig;
    audioTrack: MediaStreamTrack;
};
export declare enum TrackLabel {
    Camera = "camera",
    CameraPreview = "camera-preview",
    Microphone = "microphone",
    MicrophonePreview = "microphone-preview",
    ScreenVideo = "screen-video",
    ScreenAudio = "screen-audio",
    CustomVideo = "custom-video",
    CustomAudio = "custom-audio",
    Unknown = "unknown"
}
export interface PayloadOfPublishedMedia {
    producerId: string;
    kind: MediaKind;
    label: TrackLabel;
    paused: boolean;
}
export interface TrackForceClosedPayload {
    label: TrackLabel;
}
export interface SubscribeOptions {
    producerId: string;
    muted?: boolean;
}
export type PayloadOfUnpublishedMedia = PayloadOfPublishedMedia;
export type ChangePreferredLayersPayload = PreferredLayersParams & {
    consumerId: string;
    spatialLayer: number;
    temporalLayer: number;
};
export interface CreateVideoTrackParams {
    videoTrackOptions: boolean | MediaTrackConstraints;
    encoderConfig: VideoEncoderConfig;
}
export type SpatialLayerParams = RtpEncodingParameters & TransformParams;
export interface ProducerRequestMaxSpatialLayer {
    producerId: string;
    spatialLayer: number;
}
export type ProducerSetMaxSpatialLayer = ProducerRequestMaxSpatialLayer & {
    peerId: string;
};
export interface TransformParams {
    width?: number;
    height?: number;
}
export type RemoteConsumerOptions = ConsumerOptions & {
    producerPaused: boolean;
};
export type LogMessageHandler = (msg: string, ...meta: any) => void;
export type LogLevel = 3 | 4 | 6 | 7;
export type LogLevelStr = 'error' | 'warn' | 'info' | 'debug';
export interface Logger {
    debug: (msg: string, ...meta: Record<string, unknown>[]) => void;
    info: (msg: string, ...meta: Record<string, unknown>[]) => void;
    warn: (msg: string, ...meta: Record<string, unknown>[]) => void;
    error: (msg: string, ...meta: Record<string, unknown>[]) => void;
}
export interface TransportConnectionTimeoutPayload {
    reason: 'ice' | 'dtls';
    transportId: string;
    direction: 'receive' | 'send';
    timeout: number;
}
export type ExtendedRTCInboundRtpStreamStats = RTCInboundRtpStreamStats & {
    decoderImplementation?: string;
};
export interface TransportsStateInfo {
    receive?: TransportStateInfo;
    send?: TransportStateInfo;
}
export interface TransportStateInfo {
    dtlsState: ConnectionState;
    iceState: ConnectionState;
    dtlsRole: DtlsRole;
    iceRole: string;
    selectedCandidatePairChanges: number;
    tlsVersion: string;
    localCandidateState: ICECandidateState;
    remoteCandidateState: ICECandidateState;
}
export interface ICECandidateState {
    ip: string;
    address: string;
    port: number;
    protocol: RTCIceProtocol;
    candidateType: RTCIceCandidateType;
}
export interface CreateConsumerPayload {
    producerId: string;
    rtpCapabilities: RtpCapabilities;
    producerPeerId: string;
}
export interface CreateDataConsumerPayload {
    producerId: string;
    appId?: string;
    channelId?: string;
    ordered?: boolean;
    transport: types.Transport;
}
export interface CreateConsumerResponse {
    consumer: Consumer;
    isProducerPaused: boolean;
}
export declare enum DeviceErrors {
    NotFoundError = "NotFoundError",
    NoDevices = "NoDevices",
    DeviceIsBusy = "DeviceIsBusy",
    NotAllowedError = "NotAllowedError",
    RequestDevicesUnknownError = "RequestDevicesUnknownError"
}
export interface TrackInboundStats {
    consumerId: string;
    codec?: RTCRtpCodecParameters;
    currentSpatialLayerParams?: SpatialLayerParams;
    availableSpatialLayers?: SpatialLayerParams[];
    requestedSpatialLayer?: number;
    dtlsState?: RTCDtlsTransportState;
    rtcStats?: ExtendedRTCInboundRtpStreamStats;
}
export interface TrackOutboundStats {
    producerId?: string;
    codec?: RTCRtpCodecParameters;
    dtlsState?: RTCDtlsTransportState;
    rtcStats?: RTCOutboundRtpStreamStats;
}
export interface PeerTrackInfo {
    trackId: string;
    readyState: MediaStreamTrackState;
    isRemote: boolean;
    kind: MediaKind;
    label: TrackLabel;
    paused: boolean;
    width?: number;
    height?: number;
    frameRate?: number;
    aspectRatio?: number;
    trackInboundStats?: TrackInboundStats;
    trackOutboundStats?: TrackOutboundStats;
}
export interface BaseTrackInfo {
    trackId: string;
    readyState: MediaStreamTrackState;
    kind: MediaKind;
    label: TrackLabel;
    paused: boolean;
    width?: number;
    height?: number;
    frameRate?: number;
    aspectRatio?: number;
    trackOutboundStats?: TrackOutboundStats;
}
export interface PeerInfo {
    id: string;
    appData: Record<string, unknown>;
    role: Role;
    channelIds: string[];
    appId: string;
    uid?: string;
    loginDate: Date;
    tracks: PeerTrackInfo[];
}
export interface UpdatePeerAppDataPayload {
    peerId: string;
    appData: Record<string, unknown>;
}
export interface CreateTracksPayload {
    mediaStreamTracks: MediaStreamTrack[];
    constraints: MediaStreamConstraints;
}
export interface ChangeProducerStatePayload {
    peerId: string;
    producerId: string;
}
export interface ForceCloseProducerPayload {
    peerId: string;
    label: TrackLabel;
}
export interface ActivityConfirmationRequiredPayload {
    channelId: string;
    time: number;
}
export interface PeerShortData {
    id: string;
    producers: Array<{
        id: string;
        paused: boolean;
    }>;
    appData?: Record<string, unknown>;
}
export type PeerSyncData = Omit<PeerShortData, 'appData'> & {
    appData?: string;
};
export type TransportAppData = AppData;
export type PeerGroup = 'moderator' | 'user';
export type TrackLabelString = 'camera' | 'microphone' | 'screen-video' | 'screen-audio' | 'custom-video' | 'custom-audio';