export interface TwinTransport {
    sendMessage(targetTwinId: string, data: any): Promise<void>;
    subscribe(twinId: string): Promise<void>;
    onMessage(twinId: string, callback: (msg: any) => void): void;
    offMessage(twinId: string, callback: (msg: any) => void): void;
    twinId: string;
}
export interface TurnServerConfig {
    urls: string;
    username: string;
    credential: string;
}
export interface IceServersResult {
    iceServers: RTCIceServer[];
    ttlSeconds?: number;
}
export type IceServersProvider = () => Promise<RTCIceServer[] | IceServersResult> | RTCIceServer[] | IceServersResult;
export interface WebRTCManagerOptions {
    verbose?: boolean;
    useStun?: boolean;
    stunServers?: string[];
    turnServers?: TurnServerConfig[];
    iceTransportPolicy?: RTCIceTransportPolicy;
    iceServersProvider?: IceServersProvider;
    connectionTimeout?: number;
    initialRetryDelay?: number;
    maxRetryDelay?: number;
}
export type WebRTCStandardEvent = 'connected' | 'disconnected' | 'error';
export type WebRTCVerboseEvent = 'reconnecting' | 'reconnected' | 'ice-state-change' | 'signaling-state-change' | 'ice-candidate';
export type WebRTCEvent = WebRTCStandardEvent | WebRTCVerboseEvent;
export interface WebRTCEventData {
    connected: {
        targetTwinId: string;
        connectionType: 'datachannel' | 'mediastream';
    };
    disconnected: {
        targetTwinId: string;
        connectionType: 'datachannel' | 'mediastream';
    };
    error: {
        targetTwinId?: string;
        error: Error;
    };
    reconnecting: {
        targetTwinId: string;
        attempt: number;
    };
    reconnected: {
        targetTwinId: string;
        attempt: number;
    };
    'ice-state-change': {
        targetTwinId: string;
        state: RTCIceConnectionState;
    };
    'signaling-state-change': {
        targetTwinId: string;
        state: RTCSignalingState;
    };
    'ice-candidate': {
        targetTwinId: string;
        candidate: RTCIceCandidate | null;
    };
}
export type WebRTCEventCallback<E extends WebRTCEvent = WebRTCEvent> = (data: WebRTCEventData[E]) => void;
export interface PhygridDataChannel {
    send(data: string | ArrayBuffer | object): void;
    onMessage(callback: (data: any) => void): void;
    offMessage(callback: (data: any) => void): void;
    onClose(callback: () => void): void;
    offClose(callback: () => void): void;
    close(): void;
    isOpen(): boolean;
    isConnecting(): boolean;
    getTargetTwinId(): string;
    getChannelName(): string;
    getPeerId(): string | null;
}
export interface ExtendedMediaStreamTrack extends MediaStreamTrack {
    onFrame?: (frame: any) => void;
}
export type MediaTrackKind = 'audio' | 'video';
export interface MediaStreamOptions {
    direction?: RTCRtpTransceiverDirection;
    localStream?: MediaStream;
    channelName?: string;
    kinds?: MediaTrackKind[];
}
export interface MediaStreamResponderOptions {
    channelName?: string;
    createLocalStream?: () => MediaStream;
    direction?: RTCRtpTransceiverDirection;
    maxPeers?: number;
}
export interface DataChannelResponderOptions {
    channelName?: string;
    maxPeers?: number;
}
export interface PeerInfo {
    deviceId?: string;
}
export type MediaStreamCallback = (stream: PhygridMediaStream, peerId: string, info: PeerInfo) => void;
export type DataChannelCallback = (channel: PhygridDataChannel, peerId: string, info: PeerInfo) => void;
export interface PhygridMediaStream {
    getTracks(): MediaStreamTrack[];
    getStream(): MediaStream | null;
    addTrack(track: MediaStreamTrack): void;
    onTrack(callback: (track: MediaStreamTrack) => void): void;
    offTrack(callback: (track: MediaStreamTrack) => void): void;
    onFrame(callback: (frameData: any) => void): void;
    offFrame(callback: (frameData: any) => void): void;
    onClose(callback: () => void): void;
    offClose(callback: () => void): void;
    close(): void;
    isReceivingFrames(): boolean;
    isConnecting(): boolean;
    getTargetTwinId(): string;
    getChannelName(): string;
    getPeerId(): string | null;
}
export type ConnectionType = 'datachannel' | 'mediastream';
export interface ConnectionState {
    targetTwinId: string;
    connectionType: ConnectionType;
    isInitiator: boolean;
    pc: RTCPeerConnection | null;
    isConnected: boolean;
    isReconnecting: boolean;
    reconnectAttempts: number;
}
export type SignalingMessageType = 'offer' | 'answer' | 'ice';
export type SignalingSink = (type: SignalingMessageType, data: RTCSessionDescriptionInit | RTCIceCandidateInit | RTCIceCandidate) => void;
export interface SignalingMessage {
    type: string;
    data: RTCSessionDescriptionInit | RTCIceCandidateInit;
    peerId?: string;
}
export interface PeerConnectionConfig {
    targetTwinId: string;
    isInitiator: boolean;
    connectionType: ConnectionType;
    channelPrefix: string;
    useStun: boolean;
    stunServers: string[];
    turnServers: TurnServerConfig[];
    iceTransportPolicy: RTCIceTransportPolicy;
    iceServersProvider?: IceServersProvider;
    onConnected: () => void;
    onDisconnected: () => void;
    onError: (error: Error) => void;
    onReconnecting?: (attempt: number) => void;
    onReconnected?: (attempt: number) => void;
    onIceStateChange?: (state: RTCIceConnectionState) => void;
    onSignalingStateChange?: (state: RTCSignalingState) => void;
    onIceCandidate?: (candidate: RTCIceCandidate | null) => void;
    peerId?: string;
    selfManagedSignaling?: boolean;
    signalingSink?: SignalingSink;
    onPeerConnectionCreated?: (pc: RTCPeerConnection) => void | Promise<void>;
}
export interface DataChannelConfig extends PeerConnectionConfig {
    onMessage: (data: any) => void;
    onOpen: () => void;
    onClose: () => void;
}
export interface MediaStreamConfig extends PeerConnectionConfig {
    direction: RTCRtpTransceiverDirection;
    localStream?: MediaStream;
    onTrack: (track: MediaStreamTrack) => void;
    onFrameInactive?: () => void;
}
export declare class NoMediaResponderError extends Error {
    readonly code = "no-responder-armed";
    constructor(targetTwinId: string, channelName: string);
}
export declare class PeerCapReachedError extends Error {
    readonly code = "peer-cap-reached";
    constructor(peerId: string, maxPeers: number);
}
export declare class MissingMediaTrackError extends Error {
    readonly code = "missing-media-track";
    readonly missingKinds: MediaTrackKind[];
    constructor(targetTwinId: string, missingKinds: MediaTrackKind[], timeoutMs: number);
}
//# sourceMappingURL=types.d.ts.map