/// <reference types="node" />
import { EventEmitter } from 'events';
import { Deferred } from '../internal/promise';
import { Room } from '../room';
import { RemotePeer } from '../remote_peer';
import { LocalPeer } from '../local_peer';
import { PeerConnection } from '../peer_connection';
import { Channel, Signaling, SignalingPeer } from '../types';
export declare type CallingStatus = Record<string, any>;
declare type DataCb = (error: Error | undefined, data?: any) => void;
export declare type CallingState = "idle" | "connecting" | "connected" | "closed" | "failed";
export interface CallingOptions {
    pingInterval: number;
    timeout: number;
    remotePing?: number;
    remoteTimeout?: number;
}
export declare class Calling extends EventEmitter {
    id?: string;
    channel: Channel;
    room_options: Record<string, any>;
    calling_options: CallingOptions;
    next_tid: number;
    answers: Record<string, Deferred<any> | DataCb>;
    hello_p: Promise<string>;
    ping_timeout?: ReturnType<typeof setTimeout>;
    timeout_timeout?: ReturnType<typeof setTimeout>;
    state: CallingState;
    constructor(channel: Channel, room_options: Record<string, any>, calling_options?: Partial<CallingOptions>);
    connect(): Promise<void>;
    request(msg: any, cb: DataCb): void;
    request(msg: any): Promise<any>;
    ping(): Promise<void>;
    connectionAlive(): void;
    resetPing(): void;
    resetTimeout(): void;
    subscribe(nsid: string): Promise<CallingNamespace>;
    register(namespace: string): Promise<void>;
    unregister(namespace: string): Promise<void>;
    room(room?: string, options?: Record<string, any>): CallingRoom;
    room_signaling(room?: string): CallingSignaling;
    setStatus(status: Record<string, any>): Promise<void>;
    close(): Promise<void>;
    private setState;
}
export declare class CallingNamespace extends EventEmitter {
    calling: Calling;
    id: string;
    users: Record<string, CallingNamespaceUser>;
    rooms: Record<string, CallingNamespaceRoom>;
    constructor(calling: Calling, id: string);
    addUser(id: string, status: Record<string, any>): CallingNamespaceUser;
    addRoom(id: string, status: Record<string, any>, peers: any): CallingNamespaceRoom;
    unsubscribe(): Promise<unknown>;
}
export declare class CallingNamespaceUser extends EventEmitter {
    id: string;
    status: CallingStatus;
    pending: boolean;
    constructor(id: string, status: Record<string, any>, pending?: boolean);
}
export declare class CallingNamespaceRoom extends EventEmitter {
    id: string;
    status: CallingStatus;
    peers: Record<string, CallingNamespaceRoomPeer>;
    constructor(id: string, status: Record<string, any>);
    addPeer(id: string, status: Record<string, any>, pending: boolean): CallingNamespaceUser;
}
export declare class CallingNamespaceRoomPeer extends EventEmitter {
    id: string;
    status: CallingStatus;
    pending: boolean;
    accepted_d: Deferred<void>;
    constructor(id: string, status: Record<string, any>, pending: boolean);
    accepted(): Promise<void>;
}
export declare class CallingSignaling extends EventEmitter implements Signaling<CallingSignalingPeer> {
    id?: string;
    calling: Calling;
    connect_fun: (peer_status: Record<string, any>, cb: DataCb) => void;
    status: CallingStatus;
    peer_status: CallingStatus;
    peers: Record<string, CallingSignalingPeer>;
    initialized: boolean;
    connect_p?: Promise<void>;
    constructor(calling: Calling, connect_fun: (peer_status: Record<string, any>, cb: DataCb) => void);
    init(data: any): void;
    connect(): Promise<void>;
    addPeer(id: string, status: Record<string, any>, pending: boolean, first: boolean): CallingSignalingPeer;
    close(): Promise<void>;
    setStatus(status: Record<string, any>): Promise<void>;
    invite(user: CallingNamespaceUser | string, data?: any): Promise<CallingOutInvitation>;
    setRoomStatusSafe(key: string, value: any, previous: any): Promise<void>;
    setRoomStatus(key: string, value: any): Promise<void>;
    register(namespace: string): Promise<void>;
    unregister(namespace: string): Promise<void>;
}
export declare class CallingSignalingPeer extends EventEmitter implements SignalingPeer {
    room: CallingSignaling;
    id: string;
    status: CallingStatus;
    pending: boolean;
    first: boolean;
    accepted_d: Deferred<void>;
    constructor(room: CallingSignaling, id: string, status: Record<string, any>, pending: boolean, first: boolean);
    accepted(): Promise<void>;
    send(event: string, data: any): Promise<void>;
}
export declare class CallingInInvitation extends EventEmitter {
    calling: Calling;
    handle: string;
    sender: string;
    data: any;
    cancelled: boolean;
    constructor(calling: Calling, handle: string, sender: string, data: any);
    signaling(): CallingSignaling;
    deny(): Promise<void>;
}
export declare class CallingOutInvitation {
    calling: Calling;
    handle: string;
    user: string;
    defer: Deferred<boolean>;
    pending: boolean;
    constructor(calling: Calling, handle: string, user: string);
    response(): Promise<boolean>;
    cancel(): Promise<void>;
}
export declare class CallingRoom extends Room<CallingSignalingPeer, CallingSignaling> {
    peers: Record<string, CallingPeer>;
    constructor(signaling: CallingSignaling, options: Record<string, any>);
    createPeer(pc: PeerConnection, signaling: CallingSignalingPeer): CallingPeer;
    invite(user: CallingNamespaceUser | string, data: any): Promise<CallingOutInvitation>;
    register(nsid: string): Promise<void>;
    unregister(nsid: string): Promise<void>;
}
export declare class CallingInvitationRoom extends CallingRoom {
    invitation: CallingInInvitation;
    sender_id: string;
    data: any;
    constructor(invitation: CallingInInvitation, options: Record<string, any>, sender_id: string, data: any);
    sender(): CallingPeer;
    deny(): Promise<void>;
}
export declare class CallingPeer extends RemotePeer {
    signaling: CallingSignalingPeer;
    constructor(pc: PeerConnection, signaling: CallingSignalingPeer, local: LocalPeer, options: Record<string, any>);
    connect(): Promise<void>;
}
export {};