import type { Observable } from 'rxjs';
import type { ReactiveControllerHost } from 'lit';
import type { Call, LayoutLayer } from '../types/index.js';
import type { CallStatus, CallParticipant, CallSelfParticipant, CallAddress, MediaDirections, VideoPosition } from '@signalwire/js';
export interface CallState {
    id: string;
    direction: 'inbound' | 'outbound';
    to: string | undefined;
    status: CallStatus;
    recording: boolean;
    streaming: boolean;
    locked: boolean;
    raiseHandPriority: boolean;
    meta: Record<string, unknown>;
    participants: CallParticipant[];
    /** The local/self participant. Null until the call is joined. */
    self: CallSelfParticipant | null;
    remoteStream: MediaStream | null;
    localStream: MediaStream | null;
    mediaDirections: MediaDirections;
    layout: string | undefined;
    layouts: string[];
    layoutLayers: LayoutLayer[];
    address: CallAddress | undefined;
    capabilities: string[];
    hangup: () => Promise<void>;
    toggleLock: () => Promise<void>;
    toggleHold: () => Promise<void>;
    setLayout: (layout: string, positions?: Record<string, VideoPosition>) => Promise<void>;
    startRecording: () => Promise<void>;
    startStreaming: () => Promise<void>;
    sendDigits: (digits: string) => Promise<void>;
    answer: () => void;
    reject: () => void;
}
export declare const callStateContext: {
    __context__: CallState;
};
export interface IncomingCallInfo {
    call: Call;
    callerName: string | undefined;
    callerNumber: string | undefined;
}
type IncomingCallCallback = (info: IncomingCallInfo) => void;
/**
 * Listens to an incoming-calls observable and fires a callback for each
 * new inbound call. Deduplicates by call ID so a call is never announced
 * twice.
 *
 * Usage in a provider component:
 *
 *   private _incoming = new IncomingCallController(this);
 *
 *   // Set the handler:
 *   this._incoming.onIncomingCall = (info) => { ... };
 *
 *   // Start listening (pass the observable from client.session):
 *   this._incoming.connect(client.session.incomingCalls$);
 *
 *   // Stop listening:
 *   this._incoming.disconnect();
 */
export declare class IncomingCallController {
    private _subscription;
    private _seenCallIds;
    private _callback;
    constructor(host: ReactiveControllerHost & EventTarget);
    hostConnected(): void;
    hostDisconnected(): void;
    set onIncomingCall(cb: IncomingCallCallback);
    connect(incomingCalls$: Observable<Call[]>): void;
    disconnect(): void;
}
export {};
//# sourceMappingURL=call-state-context.d.ts.map