import { CHANNEL_EVENTS, MEDIASOUP_EVENTS, PEER_EVENTS } from '../constants/events';
import EnhancedEventEmitter from '../EnhancedEventEmitter';
import { type ChangePreferredLayersPayload, type PayloadOfPublishedMedia, type PayloadOfUnpublishedMedia, type PeerGroup, type PeerInfo, type PeerShortData, type ProducerData, type ProducerSetMaxSpatialLayer, type Role, type SubscribeOptions, TrackLabel, type TrackLabelString } from '../types/common';
import type { PeerConsumerFactory } from '../types/container';
import type { GroupsChangedPayload, ProducePermissionsChangedPayload } from '../types/engine';
import type { CallState } from './CallState';
import type Logger from './Logger';
import type Media from './media';
import type PeerTrack from './media/tracks/PeerTrack';
import type { MyPeer } from './MyPeer';
import type Network from './network';
import type PeerConsumer from './PeerConsumer';
import PeerProducer from './PeerProducer';
import type { Peers } from './Peers';
import type { RemotePeerTracks } from './RemotePeerTracks';
export interface PeerDependencies {
    callState: CallState;
    loggerFactory: (namespace: string) => Logger;
    media: Media;
    myPeer: MyPeer;
    network: Network;
    peers: Peers;
    remotePeerTracks: RemotePeerTracks;
    peerConsumerFactory: PeerConsumerFactory;
}
interface PeerConstructor extends PeerDependencies {
    id: string;
    channelIds: string[];
    groups: PeerGroup[];
    producePermissions: TrackLabel[];
    appId: string;
    producers: ProducerData[];
    videoConsumer?: PeerConsumer;
    audioConsumer?: PeerConsumer;
    soundLevel?: number;
    loginDate: Date;
    uid?: string;
    appData?: Record<string, unknown>;
    role: Role;
}
export interface PeerObserverEvents {
    [PEER_EVENTS.mediaPublished]: [PayloadOfPublishedMedia];
    [PEER_EVENTS.appDataUpdated]: [Record<string, unknown>];
    [PEER_EVENTS.connectionQualityChanged]: [{
        connectionQuality: number;
    }];
    [PEER_EVENTS.publisherPaused]: [PayloadOfPublishedMedia];
    [PEER_EVENTS.publisherResumed]: [PayloadOfPublishedMedia];
    [PEER_EVENTS.mediaUnPublished]: [PayloadOfUnpublishedMedia];
    [PEER_EVENTS.trackStart]: [PeerTrack];
    [PEER_EVENTS.trackEnd]: [PeerTrack];
    [PEER_EVENTS.trackResumed]: [PeerTrack];
    [PEER_EVENTS.trackPaused]: [PeerTrack];
    [PEER_EVENTS.trackFailed]: [PeerTrack];
    [PEER_EVENTS.producePermissionsChanged]: [ProducePermissionsChangedPayload];
    [PEER_EVENTS.groupsChanged]: [GroupsChangedPayload];
    [MEDIASOUP_EVENTS.producerClose]: [ProducerData];
    [MEDIASOUP_EVENTS.newProducer]: [ProducerData];
    [MEDIASOUP_EVENTS.closeConsumer]: [consumerId: string];
    [MEDIASOUP_EVENTS.pauseConsumer]: [consumerId: string];
    [MEDIASOUP_EVENTS.resumeConsumer]: [consumerId: string];
    [MEDIASOUP_EVENTS.consumerChangePreferredLayers]: [ChangePreferredLayersPayload];
    [MEDIASOUP_EVENTS.producerSetMaxSpatialLayer]: [ProducerSetMaxSpatialLayer];
    [CHANNEL_EVENTS.updatePeerAppData]: [Record<string, unknown>];
    [event: string]: unknown[];
}
declare class Peer {
    #private;
    id: string;
    channelIds: string[];
    groups: PeerGroup[];
    producePermissions: TrackLabel[];
    appId: string;
    loginDate: Date;
    uid?: string;
    private applicationData;
    role: Role;
    producers: Map<string, PeerProducer>;
    readonly tracks: Map<string, PeerTrack>;
    private readonly _observer;
    constructor({ id, channelIds, groups, producePermissions, appId, loginDate, producers, appData, uid, role, loggerFactory, myPeer, callState, peers, remotePeerTracks, media, network, peerConsumerFactory, }: PeerConstructor);
    get appData(): Record<string, unknown>;
    get observer(): EnhancedEventEmitter<PeerObserverEvents>;
    get isMe(): boolean;
    get isModerator(): boolean;
    get isUser(): boolean;
    get publishedMedia(): PayloadOfPublishedMedia[];
    get shortData(): PeerShortData;
    hasPermission(producePermission: TrackLabel): boolean;
    hasGroup(group: PeerGroup): boolean;
    subscribe({ producerId, muted }: SubscribeOptions): Promise<void>;
    unsubscribe(producerId: string): Promise<void>;
    setProducePermissions(producePermissions: TrackLabelString[]): Promise<void>;
    addProducePermission(label: TrackLabelString): Promise<void>;
    removeProducePermission(label: TrackLabelString): Promise<void>;
    getInfo(): Promise<PeerInfo>;
    getProducers(): PeerProducer[];
    getConsumersState(): Array<{
        id: string;
        producerId: string;
        paused: boolean;
    }>;
    private handleNewProducer;
    private handlePeerEvents;
    reset(): Promise<void>;
    getActiveTracksCount(): number;
    getActivePublishersCount(): number;
    handleProducePermissionsChange(producePermissions: TrackLabel[]): void;
    handleGroupsChange(groups: PeerGroup[]): void;
    private getAllConsumers;
    private getConsumerByProducerId;
    private getConsumerById;
    private getTrackByConsumerId;
    private setAppData;
    private throwIfIamNotModerator;
}
export default Peer;