@snugdesk/avaya-ipo-widget 0.2.2

package/index.d.ts

@@ -0,0 +1,794 @@
+import * as i0 from '@angular/core';
+import { NgZone, OnInit, OnDestroy, EventEmitter, ChangeDetectorRef, AfterViewInit, ElementRef, OnChanges, SimpleChanges } from '@angular/core';
+import * as i14 from '@angular/forms';
+import { FormGroup, FormBuilder } from '@angular/forms';
+import * as rxjs from 'rxjs';
+import { BehaviorSubject, Subject } from 'rxjs';
+import { HttpClient } from '@angular/common/http';
+import { SnugdeskAuthenticationService } from '@snugdesk/core';
+import * as i19 from 'ngx-intl-tel-input';
+import { CountryISO, SearchCountryField } from 'ngx-intl-tel-input';
+import * as i13 from '@angular/common';
+import * as i15 from '@angular/material/form-field';
+import * as i16 from '@angular/material/input';
+import * as i17 from '@angular/material/icon';
+import * as i18 from '@angular/material/button';
+
+interface RemoteMedia {
+    callId: string;
+    stream: MediaStream;
+}
+declare class AvayaIPOService {
+    zone: NgZone;
+    private http;
+    private cli;
+    remoteStream: RemoteMedia | null;
+    readonly remoteStream$: BehaviorSubject<RemoteMedia>;
+    localStream: MediaStream | null;
+    incomingCallSubject: Subject<{
+        callId: string;
+        farEndNumber: string;
+    }>;
+    callTerminateSubject: Subject<{
+        callId: string;
+        reason: any;
+    }>;
+    outgoingDialSubject: BehaviorSubject<{
+        dialed: string;
+    }>;
+    private ringAudio;
+    private lastIncomingCall;
+    callStateSubject: Subject<{
+        callId: string;
+        state: string;
+    }>;
+    transferStatusSubject: Subject<{
+        callId?: string;
+        success: boolean;
+        message: string;
+    }>;
+    private transferInProgressCallId;
+    private callSlots;
+    activeCallsMap: Map<string, any>;
+    activeCallId: string | null;
+    currentcallId: string | null;
+    getLastIncomingCall(): {
+        callId: string;
+        farEndNumber: string;
+    } | null;
+    clearLastIncomingCall(): void;
+    notifyOutgoingDial(dialed: string): void;
+    clearOutgoingDial(): void;
+    getActiveCallCount(): number;
+    setLastIncomingCall(callId: string, farEndNumber: string): void;
+    private startRingTone;
+    private stopRingTone;
+    private agentId;
+    private loginStatusSubject;
+    loginStatus$: rxjs.Observable<boolean>;
+    private readonly DOM_TAGS;
+    private configTemplate;
+    private readonly agentStatusApiUrl;
+    private readonly CALL_HISTORY_API_URL;
+    private prewarmedStream?;
+    private isSafari;
+    private _rpcPatched;
+    private _rpcMessageListenerWs?;
+    private isLoggedIn;
+    private initAttempts;
+    constructor(zone: NgZone, http: HttpClient);
+    setConfigValues(opts: {
+        serviceType?: string;
+        gatewayIp?: string;
+        gatewayPort?: string;
+        stunIp?: string;
+        stunPort?: string;
+        turnIp?: string;
+        turnPort?: string;
+    }): void;
+    init(): void;
+    logIn(username: string, password: string, attempt?: number): void;
+    private logCliCapabilities;
+    logOut(): void;
+    logout(): void;
+    getAlternateServerConfig(): any;
+    getDeviceList(): void;
+    setDeviceIds(deviceIds: any): void;
+    makeCall(destination: string): Promise<'1' | '2' | '3' | null>;
+    dropCall(): void;
+    doMute(): void;
+    doUnMute(): void;
+    doHold(): void;
+    doUnHold(): void;
+    pauseVideo(): void;
+    playVideo(): void;
+    transferCall(target: string, type: string): void;
+    sendDTMF(digit: string | number): void;
+    answerCall(): void;
+    addVideo(): void;
+    removeVideo(): void;
+    clearCallSlot(): void;
+    setAgentId(id: string): void;
+    agentIdle(): void;
+    agentBusy(): void;
+    agentAutoRelease(): void;
+    handleConfigChange: (res_configChange: any) => void;
+    handleRegistrationChange: (res_registrationChange: any) => void;
+    handleTokenRenewal: (res_tokenRenewal: any) => void;
+    assignToFirstAvailableSlot(callId: string, callObj: any): void;
+    getSlotForCallId(callId: string): '1' | '2' | '3' | null;
+    releaseCallById(callId: string): void;
+    handleCallState(callObj: any): void;
+    swapLines(): void;
+    swapToSlot(targetSlot: '1' | '2' | '3'): void;
+    dropCallBySlot(targetSlot: '1' | '2' | '3'): void;
+    logCall(callData: any): rxjs.Observable<Object>;
+    getActiveCallId(): string | null;
+    initLocalMic(): Promise<void>;
+    private patchRpcForTransfers;
+    makeCallWithCustomData(destination: string, dataToSend: string): Promise<'1' | '2' | '3' | null>;
+    transferCallWithTag(target: string, type: 'Attended' | 'Blind'): void;
+    consumeTransferInProgress(callId: string): boolean;
+    private _doPatch;
+    /** Pre-warm microphone so AWL always has a local stream when it tries addStream() */
+    prewarmMic(): Promise<MediaStream>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AvayaIPOService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AvayaIPOService>;
+}
+
+declare class CountryService {
+    private httpClient;
+    private countriesData;
+    private static readonly COUNTRY_ENDPOINT;
+    constructor(httpClient: HttpClient);
+    getAllCountries(): Promise<any[]>;
+    getCountryFromCallingCode(countryCallingCode: string): Promise<any | undefined>;
+    getCountryFromCountryCode(countryCode: string): Promise<any | undefined>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CountryService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CountryService>;
+}
+
+declare class PhoneNumberLookupService {
+    private httpClient;
+    constructor(httpClient: HttpClient);
+    lookupPhoneNumber(phoneNumber: string, hlr?: boolean): Promise<Object>;
+    private normalizeForLookup;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PhoneNumberLookupService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PhoneNumberLookupService>;
+}
+
+declare class AuthenticationService {
+    private snugdeskAuthService;
+    tenant$: BehaviorSubject<any>;
+    user$: BehaviorSubject<any>;
+    isAuthenticated$: BehaviorSubject<boolean>;
+    constructor(snugdeskAuthService: SnugdeskAuthenticationService);
+    isAuthenticated(): boolean;
+    getAuthSessionToken(): string | null;
+    getAuthDomainToken(): string | null;
+    getDecodedAuthDomainToken(): any;
+    getTenantId(): string;
+    getDecodedAuthSessionToken(): any;
+    getUserId(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AuthenticationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AuthenticationService>;
+}
+
+declare class EntitiesSearchService {
+    private http;
+    private authenticationService;
+    private nameCache;
+    constructor(http: HttpClient, authenticationService: AuthenticationService);
+    fetchContacts(tenantId: string, size?: number, searchAfter?: [string, string]): Promise<any>;
+    searchByPhone(tenantId: string, phoneNumber: string, size?: number): Promise<any>;
+    searchEntities(tenantId: string, query: string, size?: number, from?: number): Promise<any>;
+    getCachedName(tenantId: string, phoneNumber: string): string | null;
+    lookupNameByPhone(tenantId: string, phoneNumber: string, size?: number): Promise<string | null>;
+    private postEntities;
+    private cacheKey;
+    private ensureWildcard;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EntitiesSearchService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<EntitiesSearchService>;
+}
+
+declare class AvayaIPOWidgetComponent implements OnInit, OnDestroy {
+    private formBuilder;
+    private avayaIPOService;
+    private cdr;
+    private countryService;
+    private phoneNumberLookupService;
+    private entitiesSearchService;
+    private snugdeskAuthService;
+    hostDarkMode: boolean;
+    private readonly STORAGE_KEY;
+    isVisible: boolean;
+    configurationMode?: string;
+    avayaIPOServerIP?: string;
+    avayaIPOServerPort?: number;
+    avayaIPOServerStunServerIP?: string;
+    avayaIPOServerStunServerPort?: number;
+    avayaIPOServerTurnServerIP?: string;
+    avayaIPOServerTurnServerPort?: number;
+    token?: string;
+    tenantId: string;
+    userId: string;
+    notificationEvent: EventEmitter<number>;
+    readonly avayaLogoUrl: string;
+    isReconnectingInProgress: boolean;
+    isFailoverInProgress: boolean;
+    isFailbackInProgress: boolean;
+    showLoginForm: boolean;
+    showLoginLoader: boolean;
+    hasAvayaSocketError: boolean;
+    hasAvayaLoginError: boolean;
+    hasAvayaLoginFailedGeneral: boolean;
+    hasAvayaLoginConflictError: boolean;
+    hasAvayaDeviceError: boolean;
+    private awlScriptPromise?;
+    loginForm: FormGroup;
+    activeTab: 'history' | 'contacts' | 'keypad' | 'settings';
+    private loginSub?;
+    private incomingCallSub?;
+    private callStateSub?;
+    hideTabs: boolean;
+    darkModeEnabled: boolean;
+    activeCallNumber: string | null;
+    incomingCallName: string | null;
+    incomingNameResolved: boolean;
+    activeCallName: string | null;
+    authErrorMessage: string;
+    authLoading: boolean;
+    private hasInitialized;
+    private callLogIndex;
+    private pendingDisconnectSide;
+    private callStartTimes;
+    constructor(formBuilder: FormBuilder, avayaIPOService: AvayaIPOService, cdr: ChangeDetectorRef, countryService: CountryService, phoneNumberLookupService: PhoneNumberLookupService, entitiesSearchService: EntitiesSearchService, snugdeskAuthService: SnugdeskAuthenticationService);
+    ngOnInit(): Promise<void>;
+    private initAfterAuth;
+    private authenticateWithToken;
+    onAuthLoginClick(): Promise<void>;
+    onLogin(): void;
+    onLogout(): void;
+    private handleLoginStatus;
+    selectTab(tab: 'history' | 'contacts' | 'keypad' | 'settings'): void;
+    onHistoryMakeCall(payload: {
+        dialOut: string;
+        name?: string;
+    }): void;
+    onPhoneMakeCall(phoneNumber: string): void;
+    onContactsMakeCall(payload: {
+        dialOut: string;
+        name?: string;
+    }): void;
+    onPhoneEndCall(): void;
+    onDeviceChange(change: {
+        audioInputId: string;
+        audioOutputId: string;
+        videoInputId?: string;
+    }): void;
+    onThemeToggle(enabled: boolean): void;
+    onCallScreenChange(active: boolean): void;
+    private triggerCall;
+    ngOnDestroy(): void;
+    private getLookupPhoneNumber;
+    private getOpenSearchCallerName;
+    private normalizePhoneForSearch;
+    private persistSession;
+    private restoreSession;
+    private restoreThemePreference;
+    private clearSession;
+    private loadAwlScript;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AvayaIPOWidgetComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AvayaIPOWidgetComponent, "snugdesk-avaya-ipo-widget", never, { "isVisible": { "alias": "isVisible"; "required": false; }; "configurationMode": { "alias": "configurationMode"; "required": false; }; "avayaIPOServerIP": { "alias": "avayaIPOServerIP"; "required": false; }; "avayaIPOServerPort": { "alias": "avayaIPOServerPort"; "required": false; }; "avayaIPOServerStunServerIP": { "alias": "avayaIPOServerStunServerIP"; "required": false; }; "avayaIPOServerStunServerPort": { "alias": "avayaIPOServerStunServerPort"; "required": false; }; "avayaIPOServerTurnServerIP": { "alias": "avayaIPOServerTurnServerIP"; "required": false; }; "avayaIPOServerTurnServerPort": { "alias": "avayaIPOServerTurnServerPort"; "required": false; }; "token": { "alias": "token"; "required": false; }; "tenantId": { "alias": "tenantId"; "required": false; }; "userId": { "alias": "userId"; "required": false; }; }, { "notificationEvent": "notificationEvent"; }, never, never, false, never>;
+}
+
+declare class CallHistoryComponent implements OnInit {
+    private http;
+    private cdr;
+    mode: 'dial' | 'transfer';
+    tenantId?: string;
+    agentId?: string;
+    makeCallEv: EventEmitter<{
+        dialOut: string;
+        name?: string;
+    }>;
+    transferEv: EventEmitter<any>;
+    private readonly CALL_HISTORY_API_URL;
+    showHistoryLoader: boolean;
+    callHistory: any[];
+    searchTerm: string;
+    recentCallactiveTab: 'recentCall' | 'missedCall';
+    selectedCall: any;
+    constructor(http: HttpClient, cdr: ChangeDetectorRef);
+    ngOnInit(): Promise<void>;
+    recentSelectTab(tab: 'recentCall' | 'missedCall'): void;
+    loadCallHistory(): Promise<void>;
+    getCallHistory(tenantId: string, agentId: string): Promise<any>;
+    makeCall(phoneNumber: string, name?: string): void;
+    get callerDropped(): any[];
+    get filteredRecent(): any[];
+    get groupedRecent(): Array<{
+        label: string;
+        items: any[];
+    }>;
+    get filteredMissed(): any[];
+    get groupedMissed(): Array<{
+        label: string;
+        items: any[];
+    }>;
+    onSelectCall(item: any): void;
+    closeDetails(): void;
+    selectFromHistory(item: any): void;
+    private resolveDialable;
+    private resolveName;
+    private formatDialOutFromInput;
+    private getTenantIdFromSession;
+    private getUserIdFromSession;
+    getPhoneDisplay(item: any): string;
+    getPhoneBadge(item: any): string;
+    private getInitials;
+    private groupByDate;
+    private formatDateLabel;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CallHistoryComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CallHistoryComponent, "app-call-history", never, { "mode": { "alias": "mode"; "required": false; }; "tenantId": { "alias": "tenantId"; "required": false; }; "agentId": { "alias": "agentId"; "required": false; }; }, { "makeCallEv": "makeCallEv"; "transferEv": "transferEv"; }, never, never, false, never>;
+}
+
+type TranscriptLine = {
+    speaker?: string;
+    text?: string;
+};
+declare class CallDetailsComponent {
+    private http;
+    call: any;
+    transcriptLines: TranscriptLine[];
+    summaryText: string;
+    customerSentiment: string;
+    isTranscribing: boolean;
+    transcriptionError: string;
+    isTranscriptFullscreen: boolean;
+    hasGeneratedTranscript: boolean;
+    private readonly ANALYZE_CALL_API;
+    constructor(http: HttpClient);
+    getBadge(): string;
+    getDisplayName(): string;
+    getPhone(): string;
+    getTranscriptSpeaker(line: TranscriptLine): string;
+    runTranscription(): Promise<void>;
+    private normalizeTranscript;
+    getSentimentEmoji(): string;
+    private parseSpeakerLine;
+    toggleTranscriptFullscreen(): void;
+    private getRecordingFilename;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CallDetailsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CallDetailsComponent, "app-call-details", never, { "call": { "alias": "call"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+type ContactItem = {
+    id: string;
+    name: string;
+    phone: string;
+    entity: any;
+};
+declare class ContactsComponent implements OnInit, AfterViewInit {
+    private entitiesSearchService;
+    tenantId?: string;
+    listEl?: ElementRef<HTMLElement>;
+    makeCallEv: EventEmitter<{
+        dialOut: string;
+        name?: string;
+    }>;
+    contacts: ContactItem[];
+    groupedContacts: Array<{
+        label: string;
+        items: ContactItem[];
+    }>;
+    selectedContact: ContactItem | null;
+    searchTerm: string;
+    isLoading: boolean;
+    error: string;
+    private searchToken;
+    private pageSize;
+    private nextFrom;
+    private searchAfter?;
+    private hasMore;
+    isLoadingMore: boolean;
+    constructor(entitiesSearchService: EntitiesSearchService);
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    private resetAndLoad;
+    loadNextPage(): Promise<void>;
+    onSearchChange(value: string): void;
+    private groupContacts;
+    private applySearch;
+    openContact(contact: ContactItem): void;
+    closeContact(): void;
+    onCallContact(contact: ContactItem, ev?: Event): void;
+    private searchContacts;
+    onListScroll(event: Event): void;
+    private ensureFill;
+    private getGroupLabel;
+    private getPageSize;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ContactsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ContactsComponent, "app-contacts", never, { "tenantId": { "alias": "tenantId"; "required": false; }; }, { "makeCallEv": "makeCallEv"; }, never, never, false, never>;
+}
+
+declare class ContactCardComponent {
+    name: string;
+    phone: string;
+    call: EventEmitter<Event>;
+    get initials(): string;
+    onCall(ev: Event): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ContactCardComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ContactCardComponent, "app-contact-card", never, { "name": { "alias": "name"; "required": false; }; "phone": { "alias": "phone"; "required": false; }; }, { "call": "call"; }, never, never, false, never>;
+}
+
+declare class ContactDetailsComponent {
+    contact: any;
+    getDisplayName(): string;
+    getPrimaryPhone(): string;
+    getEmails(): string[];
+    getPhoneNumbers(): string[];
+    getInitials(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ContactDetailsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ContactDetailsComponent, "app-contact-details", never, { "contact": { "alias": "contact"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class SettingsComponent implements OnInit, OnDestroy {
+    selectedAudioInputId?: string;
+    selectedAudioOutputId?: string;
+    extensionId?: string;
+    darkMode: boolean;
+    change: EventEmitter<{
+        audioInputId: string;
+        audioOutputId: string;
+        videoInputId?: string;
+    }>;
+    darkModeChange: EventEmitter<boolean>;
+    logout: EventEmitter<void>;
+    audioInputs: MediaDeviceInfo[];
+    audioOutputs: MediaDeviceInfo[];
+    ngOnInit(): void;
+    onLogout(): void;
+    onToggleDarkMode(): void;
+    ngOnDestroy(): void;
+    private handleDeviceChange;
+    private refreshDeviceList;
+    onMicChange(deviceId: string | undefined): void;
+    onSpeakerChange(deviceId: string | undefined): void;
+    private emitDeviceChange;
+    trackByDeviceId(index: number, device: MediaDeviceInfo): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SettingsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SettingsComponent, "app-settings", never, { "selectedAudioInputId": { "alias": "selectedAudioInputId"; "required": false; }; "selectedAudioOutputId": { "alias": "selectedAudioOutputId"; "required": false; }; "extensionId": { "alias": "extensionId"; "required": false; }; "darkMode": { "alias": "darkMode"; "required": false; }; }, { "change": "change"; "darkModeChange": "darkModeChange"; "logout": "logout"; }, never, never, false, never>;
+}
+
+declare class AvayaIpoLoginComponent {
+    loginForm: FormGroup;
+    showLoginLoader: boolean;
+    hasAvayaSocketError: boolean;
+    hasAvayaLoginError: boolean;
+    hasAvayaLoginFailedGeneral: boolean;
+    hasAvayaLoginConflictError: boolean;
+    hasAvayaDeviceError: boolean;
+    login: EventEmitter<void>;
+    showLoginPassword: boolean;
+    onLoginClick(): void;
+    restrictNumeric(evt: KeyboardEvent): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AvayaIpoLoginComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AvayaIpoLoginComponent, "app-avaya-ipo-login", never, { "loginForm": { "alias": "loginForm"; "required": false; }; "showLoginLoader": { "alias": "showLoginLoader"; "required": false; }; "hasAvayaSocketError": { "alias": "hasAvayaSocketError"; "required": false; }; "hasAvayaLoginError": { "alias": "hasAvayaLoginError"; "required": false; }; "hasAvayaLoginFailedGeneral": { "alias": "hasAvayaLoginFailedGeneral"; "required": false; }; "hasAvayaLoginConflictError": { "alias": "hasAvayaLoginConflictError"; "required": false; }; "hasAvayaDeviceError": { "alias": "hasAvayaDeviceError"; "required": false; }; }, { "login": "login"; }, never, never, false, never>;
+}
+
+interface CallMetadata {
+    tenantId: string;
+    agentId: string;
+    phoneNumber: string;
+    callId: string;
+}
+
+interface RecordingSession {
+    audioContext: AudioContext;
+    recordingStream: MediaStreamAudioDestinationNode;
+    recorder?: MediaRecorder | null;
+    metadata: CallMetadata;
+    stopping: boolean;
+    chunkIndex: number;
+    chunkTimer?: number;
+}
+declare class RecordingManagerService {
+    private http;
+    private sessions;
+    private readonly MIME_TYPE_PREFERRED;
+    private readonly MIME_TYPE_FALLBACK;
+    private readonly CHUNK_DURATION_MS;
+    private readonly AUDIO_CONTEXT_CLOSE_DELAY_MS;
+    private readonly CALL_HISTORY_API_URL;
+    constructor(http: HttpClient);
+    startRecording(localMediaStream: MediaStream, remoteMediaStream: MediaStream, metadata: CallMetadata): RecordingSession | undefined;
+    getSession(callId: string): RecordingSession | undefined;
+    stopRecording(callId: string): void;
+    private startNextChunk;
+    private uploadCallRecording;
+    private convertBlobToBase64;
+    private generateFilename;
+    private generateChunkFilename;
+    private normalizePhoneNumberForUpload;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RecordingManagerService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RecordingManagerService>;
+}
+
+type TranscriptMessage = {
+    callId: string;
+    text: string;
+    isFinal: boolean;
+    ts: number;
+    speaker?: string;
+};
+declare class TranscriptionStreamService implements OnDestroy {
+    private session;
+    private transcriptSubject;
+    readonly transcript$: rxjs.Observable<TranscriptMessage>;
+    private readonly SAMPLE_RATE;
+    private readonly BUFFER_SIZE;
+    private readonly SILENCE_RMS_THRESHOLD;
+    private readonly VOICE_RMS_THRESHOLD;
+    private readonly NOISE_FLOOR_MULTIPLIER;
+    private readonly NOISE_FLOOR_SMOOTHING;
+    private readonly CHUNK_INTERVAL_MS;
+    private readonly CUSTOM_WS_URL;
+    private readonly CUSTOM_WS_MIME_TYPE;
+    private readonly LANGUAGE_CODE;
+    private readonly ALT_LANGUAGE_CODES;
+    private readonly TRANSCRIPTION_MODEL;
+    constructor();
+    ngOnDestroy(): void;
+    startSession(callId: string, localStream: MediaStream, remoteStream: MediaStream, allowSendBinary?: boolean): Promise<void>;
+    stopSession(callId: string): void;
+    enableBinary(callId: string): void;
+    setStreamMuted(callId: string, label: 'agent' | 'customer', muted: boolean): void;
+    private mixToMono;
+    private calculateRms;
+    private encodePcm16;
+    private downsampleBuffer;
+    private queueAudio;
+    private flushPendingAudio;
+    private mergeChunks;
+    private handleTranscriptPayload;
+    private parseSpeakerLine;
+    private createStreamSession;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TranscriptionStreamService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TranscriptionStreamService>;
+}
+
+declare class PhoneComponent implements OnInit, AfterViewInit, OnChanges, OnDestroy {
+    private cdr;
+    private formBuilder;
+    private avayaIpoService;
+    private authenticationService;
+    private recordingManagerService;
+    private transcriptionStreamService;
+    contacts: any[];
+    tenantId?: string;
+    agentId?: string;
+    callScreenChange: EventEmitter<boolean>;
+    private _isActiveCall;
+    set isActiveCall(value: boolean);
+    get isActiveCall(): boolean;
+    activeCallNumber: string | null;
+    incomingCallName?: string | null;
+    incomingNameResolved: boolean;
+    activeCallName?: string | null;
+    serverIp?: string;
+    serverPort?: number;
+    stunIp?: string;
+    stunPort?: number;
+    turnIp?: string;
+    turnPort?: number;
+    configurationMode?: string;
+    makeCallEv: EventEmitter<string>;
+    endCallEv: EventEmitter<void>;
+    audioElement: any;
+    private callStateSub?;
+    private endToneTimeout?;
+    private suppressHangupToneOnce;
+    private transferStatusSub?;
+    private remoteStreamSub?;
+    private callTerminateSub?;
+    private outgoingDialSub?;
+    private transcriptionSub?;
+    private lastRemoteStream;
+    private lastLocalStream;
+    private currentCallId;
+    private pendingOutgoing;
+    private transcriptionActiveCallId;
+    private pendingTranscriptionCallId;
+    private pendingTranscriptionAllowBinary;
+    private lastPartialIndex;
+    private pendingIncomingCall;
+    dialForm: FormGroup;
+    directoryForm: FormGroup;
+    showDirectoryPhonebook: boolean;
+    isTransferMode: boolean;
+    isAddCallMode: boolean;
+    directoryTab: 'contacts' | 'dialpad';
+    directoryNumber: string;
+    contactSearch: string;
+    directoryDigits: {
+        digit: string;
+        letters: string;
+    }[];
+    incomingCallSubscription: any;
+    incomingCallNumber: string | undefined;
+    isMuted: boolean;
+    isHeld: boolean;
+    activeCallDuration: number;
+    callStatusText: string;
+    transferError: string;
+    transferSuccess: string;
+    transferPending: boolean;
+    private transferErrorTimeout?;
+    private activeCallTimer?;
+    private muteToggleInProgress;
+    private holdToggleInProgress;
+    isKeypadOpen: boolean;
+    isTranscriptionOpen: boolean;
+    transcriptText: string;
+    transcriptSegments: Array<{
+        ts: number;
+        text: string;
+        speaker?: string;
+    }>;
+    private transcriptStartedAt;
+    private transcriptEndedAt;
+    autoDownloadSummaryOnEnd: boolean;
+    summaryText: string;
+    dtmfBuffer: string;
+    private phoneUtil;
+    CountryISO: typeof CountryISO;
+    SearchCountryField: typeof SearchCountryField;
+    isRinging: boolean;
+    audio: any;
+    get isConnecting(): boolean;
+    constructor(cdr: ChangeDetectorRef, formBuilder: FormBuilder, avayaIpoService: AvayaIPOService, authenticationService: AuthenticationService, recordingManagerService: RecordingManagerService, transcriptionStreamService: TranscriptionStreamService);
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    makeCall(): void;
+    onClear(): void;
+    handleKeyboardInput: (event: KeyboardEvent) => void;
+    handleKeypadInput(digit: string): void;
+    private updatePhoneControl;
+    private formatE164;
+    private formatDialOut;
+    declineAvayaCall(): void;
+    acceptAvayaCAll(): void;
+    onEndActiveCall(): void;
+    private playHangupToneAndThenIdle;
+    private finishDisconnectWithoutTone;
+    private handleIncomingCall;
+    onActiveOpenContacts(): void;
+    onActiveOpenKeypad(): void;
+    closeKeypad(): void;
+    private startTranscriptionForCall;
+    private applyTranscriptUpdate;
+    getTranscriptSpeakerLabel(segment: {
+        speaker?: string;
+    }): string;
+    getTranscriptBubbleClass(segment: {
+        speaker?: string;
+    }): string;
+    get customerTranscriptSegments(): Array<{
+        ts: number;
+        text: string;
+    }>;
+    get agentTranscriptSegments(): Array<{
+        ts: number;
+        text: string;
+    }>;
+    openTranscription(): void;
+    closeTranscription(): void;
+    private stopTranscription;
+    private generateAndDownloadSummary;
+    private buildExtractiveSummary;
+    private splitSentences;
+    private extractActionItems;
+    private extractKeyInfo;
+    private downloadBlobFile;
+    private fmtHMS;
+    onClosePhonebook(): void;
+    onContactsLoaded(list: any[]): void;
+    get filteredContacts(): any[];
+    onSelectContact(contact: any): void;
+    toggleMute(): void;
+    toggleHold(): void;
+    onTransferCall(): void;
+    private emitCallScreenState;
+    private startCallTimer;
+    private stopCallTimer;
+    onIdleToggleDirectory(): void;
+    onIdleClear(): void;
+    onIdleMakeCall(): void;
+    onIdleKeypadInput(digit: string): void;
+    onIdleKeyboardInput(ev: KeyboardEvent): void;
+    setDirectoryTab(tab: 'contacts' | 'dialpad'): void;
+    onDirectoryKeypad(digit: string): void;
+    onDirectoryBackspace(): void;
+    onDirectoryUseNumber(): void;
+    onDirectoryClear(): void;
+    onDtmfDigit(digit: string): void;
+    onDtmfBackspace(): void;
+    private updateDirectoryControl;
+    private formatDialOutFromInput;
+    private formatTransferTargetFromInput;
+    private startRecordingForCall;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PhoneComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PhoneComponent, "app-phone", never, { "contacts": { "alias": "contacts"; "required": false; }; "tenantId": { "alias": "tenantId"; "required": false; }; "agentId": { "alias": "agentId"; "required": false; }; "isActiveCall": { "alias": "isActiveCall"; "required": false; }; "activeCallNumber": { "alias": "activeCallNumber"; "required": false; }; "incomingCallName": { "alias": "incomingCallName"; "required": false; }; "incomingNameResolved": { "alias": "incomingNameResolved"; "required": false; }; "activeCallName": { "alias": "activeCallName"; "required": false; }; "serverIp": { "alias": "serverIp"; "required": false; }; "serverPort": { "alias": "serverPort"; "required": false; }; "stunIp": { "alias": "stunIp"; "required": false; }; "stunPort": { "alias": "stunPort"; "required": false; }; "turnIp": { "alias": "turnIp"; "required": false; }; "turnPort": { "alias": "turnPort"; "required": false; }; "configurationMode": { "alias": "configurationMode"; "required": false; }; }, { "callScreenChange": "callScreenChange"; "makeCallEv": "makeCallEv"; "endCallEv": "endCallEv"; }, never, never, false, never>;
+}
+
+declare class PhoneIdleComponent {
+    dialForm: FormGroup;
+    contacts: any[];
+    showDirectoryPhonebook: boolean;
+    isRinging: boolean;
+    CountryISO: typeof CountryISO;
+    SearchCountryField: typeof SearchCountryField;
+    toggleDirectory: EventEmitter<void>;
+    clear: EventEmitter<void>;
+    makeCall: EventEmitter<void>;
+    keypadInput: EventEmitter<string>;
+    keyboardInput: EventEmitter<KeyboardEvent>;
+    getContactBadge(contact: any): string;
+    onToggleDirectory(): void;
+    onClear(): void;
+    onMakeCall(): void;
+    onKeypadInput(d: string): void;
+    onKeyboardInput(ev: KeyboardEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PhoneIdleComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PhoneIdleComponent, "app-phone-idle", never, { "dialForm": { "alias": "dialForm"; "required": false; }; "contacts": { "alias": "contacts"; "required": false; }; "showDirectoryPhonebook": { "alias": "showDirectoryPhonebook"; "required": false; }; "isRinging": { "alias": "isRinging"; "required": false; }; "CountryISO": { "alias": "CountryISO"; "required": false; }; "SearchCountryField": { "alias": "SearchCountryField"; "required": false; }; }, { "toggleDirectory": "toggleDirectory"; "clear": "clear"; "makeCall": "makeCall"; "keypadInput": "keypadInput"; "keyboardInput": "keyboardInput"; }, never, never, false, never>;
+}
+
+declare class PhoneIncomingComponent {
+    incomingAvatarUrl: string;
+    incomingCallName?: string;
+    incomingNameResolved: boolean;
+    incomingCallNumber: string | undefined;
+    accept: EventEmitter<void>;
+    decline: EventEmitter<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PhoneIncomingComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PhoneIncomingComponent, "app-phone-incoming", never, { "incomingCallName": { "alias": "incomingCallName"; "required": false; }; "incomingNameResolved": { "alias": "incomingNameResolved"; "required": false; }; "incomingCallNumber": { "alias": "incomingCallNumber"; "required": false; }; }, { "accept": "accept"; "decline": "decline"; }, never, never, false, never>;
+}
+
+declare class PhoneActiveComponent implements OnInit {
+    private entitiesSearchService;
+    tenantId?: string;
+    activeAvatarUrl: string;
+    activeCallName?: string;
+    activeCallNumber: string | null;
+    activeCallDuration: number;
+    callStatusText: string;
+    isConnecting: boolean;
+    isMuted: boolean;
+    isHeld: boolean;
+    endCall: EventEmitter<void>;
+    toggleMute: EventEmitter<void>;
+    toggleHold: EventEmitter<void>;
+    transfer: EventEmitter<void>;
+    openContacts: EventEmitter<void>;
+    openKeypad: EventEmitter<void>;
+    startTranscription: EventEmitter<void>;
+    contactsLoaded: EventEmitter<any[]>;
+    private isLoadingContacts;
+    constructor(entitiesSearchService: EntitiesSearchService);
+    ngOnInit(): void;
+    fetchContacts(): Promise<void>;
+    formatDuration(totalSeconds: number): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PhoneActiveComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PhoneActiveComponent, "app-phone-active", never, { "tenantId": { "alias": "tenantId"; "required": false; }; "activeCallName": { "alias": "activeCallName"; "required": false; }; "activeCallNumber": { "alias": "activeCallNumber"; "required": false; }; "activeCallDuration": { "alias": "activeCallDuration"; "required": false; }; "callStatusText": { "alias": "callStatusText"; "required": false; }; "isConnecting": { "alias": "isConnecting"; "required": false; }; "isMuted": { "alias": "isMuted"; "required": false; }; "isHeld": { "alias": "isHeld"; "required": false; }; }, { "endCall": "endCall"; "toggleMute": "toggleMute"; "toggleHold": "toggleHold"; "transfer": "transfer"; "openContacts": "openContacts"; "openKeypad": "openKeypad"; "startTranscription": "startTranscription"; "contactsLoaded": "contactsLoaded"; }, never, never, false, never>;
+}
+
+declare class AvayaIPOWidgetModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<AvayaIPOWidgetModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<AvayaIPOWidgetModule, [typeof AvayaIPOWidgetComponent, typeof CallHistoryComponent, typeof CallDetailsComponent, typeof ContactsComponent, typeof ContactCardComponent, typeof ContactDetailsComponent, typeof SettingsComponent, typeof AvayaIpoLoginComponent, typeof PhoneComponent, typeof PhoneIdleComponent, typeof PhoneIncomingComponent, typeof PhoneActiveComponent], [typeof i13.CommonModule, typeof i14.FormsModule, typeof i14.ReactiveFormsModule, typeof i15.MatFormFieldModule, typeof i16.MatInputModule, typeof i17.MatIconModule, typeof i18.MatButtonModule, typeof i19.NgxIntlTelInputModule], [typeof AvayaIPOWidgetComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<AvayaIPOWidgetModule>;
+}
+
+export { AvayaIPOWidgetComponent, AvayaIPOWidgetModule };