import { EventEmitter } from 'eventemitter3';

/**
 * MediaManager - Media device and stream management
 */
interface MediaConstraints {
    video?: boolean | MediaTrackConstraints;
    audio?: boolean | MediaTrackConstraints;
}
interface MediaDevice {
    deviceId: string;
    kind: MediaDeviceKind;
    label: string;
    groupId: string;
}
declare class MediaManager {
    private currentStream?;
    private devices;
    getDevices(): Promise<MediaDevice[]>;
    getUserMedia(constraints?: MediaConstraints): Promise<MediaStream>;
    getDisplayMedia(constraints?: MediaStreamConstraints): Promise<MediaStream>;
    switchCamera(deviceId?: string): Promise<MediaStream>;
    muteAudio(muted?: boolean): void;
    muteVideo(muted?: boolean): void;
    stopStream(stream?: MediaStream): void;
    getCurrentStream(): MediaStream | undefined;
    hasVideo(): boolean;
    hasAudio(): boolean;
    isAudioMuted(): boolean;
    isVideoMuted(): boolean;
    getVideoDevices(): MediaDevice[];
    getAudioDevices(): MediaDevice[];
    checkPermissions(): Promise<{
        camera: PermissionState;
        microphone: PermissionState;
    }>;
}

/**
 * PeerConnection - WebRTC peer connection management
 */

interface PeerConnectionEvents {
    'connection-state-change': (state: RTCPeerConnectionState) => void;
    'ice-candidate': (candidate: RTCIceCandidate) => void;
    'remote-stream': (stream: MediaStream) => void;
    'data-channel': (channel: RTCDataChannel) => void;
}
declare class PeerConnection extends EventEmitter<PeerConnectionEvents> {
    private pc;
    private localStream?;
    private remoteStream?;
    constructor(config?: RTCConfiguration);
    private setupEventHandlers;
    createOffer(): Promise<RTCSessionDescriptionInit>;
    createAnswer(): Promise<RTCSessionDescriptionInit>;
    setRemoteDescription(description: RTCSessionDescriptionInit): Promise<void>;
    addIceCandidate(candidate: RTCIceCandidateInit): Promise<void>;
    addLocalStream(stream: MediaStream): void;
    createDataChannel(label: string, options?: RTCDataChannelInit): RTCDataChannel;
    getConnectionState(): RTCPeerConnectionState;
    getLocalStream(): MediaStream | undefined;
    getRemoteStream(): MediaStream | undefined;
    close(): void;
}

/**
 * SignalingClient - WebSocket signaling client
 */

interface SignalingMessage {
    type: 'offer' | 'answer' | 'ice-candidate' | 'join-room' | 'leave-room' | 'user-joined' | 'user-left';
    data?: any;
    roomId?: string;
    userId?: string;
}
interface SignalingClientEvents {
    'connected': () => void;
    'disconnected': () => void;
    'message': (message: SignalingMessage) => void;
    'error': (error: Error) => void;
}
declare class SignalingClient extends EventEmitter<SignalingClientEvents> {
    private ws?;
    private url;
    private reconnectAttempts;
    private maxReconnectAttempts;
    private reconnectDelay;
    private isConnecting;
    constructor(url: string, options?: {
        maxReconnectAttempts?: number;
        reconnectDelay?: number;
    });
    connect(): Promise<void>;
    private attemptReconnect;
    send(message: SignalingMessage): void;
    joinRoom(roomId: string, userId: string): void;
    leaveRoom(roomId: string, userId: string): void;
    sendOffer(offer: RTCSessionDescriptionInit, roomId: string, userId: string): void;
    sendAnswer(answer: RTCSessionDescriptionInit, roomId: string, userId: string): void;
    sendIceCandidate(candidate: RTCIceCandidate, roomId: string, userId: string): void;
    isConnected(): boolean;
    disconnect(): void;
}

/**
 * @webrtc2/peer
 *
 * Low-level WebRTC peer connection management
 */

declare const VERSION = "1.0.0";

export { type MediaConstraints, type MediaDevice, MediaManager, PeerConnection, type PeerConnectionEvents, SignalingClient, type SignalingClientEvents, type SignalingMessage, VERSION };