workano-js-sdk/dist/lib/simple/index.d.ts

Workano Communications SDK - A modern JavaScript SDK for WebRTC and VoIP integration.

import { InvalidSubscription, InvalidAuthorization, NoTenantIdError, NoDomainNameError, NoSamlRouteError, SamlConfigError } from './Auth';
import Room from './room/Room';
import SipRoom from './room/SipRoom';
import RemoteParticipant from './room/RemoteParticipant';
import LocalParticipant from './room/LocalParticipant';
import Participant from './room/Participant';
import Stream from './room/Stream';
import { CanceledCallError } from '../web-rtc-client';
import BadResponse from '../domain/BadResponse';
import ServerError from '../domain/ServerError';
import SFUNotAvailableError from '../domain/SFUNotAvailableError';
import Call from '../domain/Call';
import CallLog from '../domain/CallLog';
import Recording from '../domain/Recording';
import ChatMessage from '../domain/ChatMessage';
import ChatRoom from '../domain/ChatRoom';
import Contact from '../domain/Contact';
import ForwardOption from '../domain/ForwardOption';
import Line from '../domain/Line';
import NotificationOptions from '../domain/NotificationOptions';
import Profile from '../domain/Profile';
import Session from '../domain/Session';
import Voicemail from '../domain/Voicemail';
import Relocation from '../domain/Relocation';
import ConferenceRoom from '../domain/Room';
import CallSession from '../domain/CallSession';
import WebRTCPhone from '../domain/Phone/WebRTCPhone';
import CTIPhone from '../domain/Phone/CTIPhone';
import IndirectTransfer from '../domain/IndirectTransfer';
import SwitchboardCall from '../domain/SwitchboardCall';
import Meeting from '../domain/Meeting';
import Checker from '../checker/Checker';
declare const Wazo: {
    Auth: import("./Auth").Auth;
    Phone: import("./Phone").Phone;
    Websocket: import("..").WebsocketType;
    Room: typeof Room;
    SipRoom: typeof SipRoom;
    RemoteParticipant: typeof RemoteParticipant;
    LocalParticipant: typeof LocalParticipant;
    Participant: typeof Participant;
    Stream: typeof Stream;
    createLocalVideoStream: (options: Record<string, any>) => Promise<Stream>;
    createLocalAudioStream: (options: Record<string, any>) => Promise<Stream>;
    Configuration: import("./Configuration").Configuration;
    Directory: import("./Directory").Directory;
    getApiClient: <T extends import("..").BaseApiClient = import("..").WazoApiClient>(forServer?: string | null, Client?: new (...args: any[]) => import("..").BaseApiClient) => T;
    IssueReporter: {
        TRACE: string;
        INFO: string;
        LOG: string;
        WARN: string;
        ERROR: string;
        oldConsoleMethods: Record<string, any> | null;
        enabled: boolean;
        remoteClientConfiguration: Record<string, any> | null | undefined;
        buffer: Record<string, any>[];
        bufferTimeout: any | null | undefined;
        _boundProcessBuffer: (...args: Array<any>) => any;
        _boundParseLoggerBody: (...args: Array<any>) => any;
        _callback: ((...args: Array<any>) => any) | null | undefined;
        init(): void;
        setCallback(cb: (...args: Array<any>) => any): void;
        configureRemoteClient(configuration?: Record<string, any>): void;
        enable(): void;
        disable(): void;
        loggerFor(category: string): any;
        removeSlashes(str: string): string;
        obfuscateHeaderToken(headers: object): object;
        log(level: string, ...args: any): void;
        logRequest(url: string, options: Record<string, any>, response: Record<string, any>, start: Date): void;
        getLogs(): never[];
        getParsedLogs(): never[];
        getReport(): string;
        _catchConsole(): void;
        _sendToRemoteLogger(level: string, payload?: Record<string, any>): void;
        _parseLoggerBody(payload: Record<string, any>): string;
        _addToBuffer(payload: Record<string, any>): void;
        _processBuffer(): void;
        _computeRetryDelay(attempt: number, initial?: number, maxWait?: number): number;
        _sendDebugToGrafana(payload: string | Record<string, any> | Record<string, any>[], retry?: number): void;
        _writeRetryCount(message: string | Record<string, any>, count: number): string | Record<string, any>;
        _isLevelAbove(level1: string, level2: string): boolean;
        _makeCategory(category: string): string;
    };
    loggerFor: (category: string) => any;
    Features: {
        _hasChat: boolean;
        _hasVideo: boolean;
        _hasCallRecording: boolean;
        _hasFax: boolean;
        _hasMobileDoubleCall: boolean;
        _hasMobileGsm: boolean;
        _hasMeeting: boolean;
        _hasCallerID: boolean;
        fetchAccess(): Promise<void>;
        hasChat(): boolean;
        hasVideo(): boolean;
        hasCallRecording(): boolean;
        hasFax(): boolean;
        hasMobileDoubleCall(): boolean;
        hasMobileGsm(): boolean;
        hasMeeting(): boolean;
        hasCallerID(): boolean;
        _hasFeatures(scopes: Record<string, any>, featureName: string): boolean;
    };
    Checker: typeof Checker;
    domain: {
        BadResponse: typeof BadResponse;
        ServerError: typeof ServerError;
        Call: typeof Call;
        CallLog: typeof CallLog;
        CTIPhone: typeof CTIPhone;
        Recording: typeof Recording;
        ChatMessage: typeof ChatMessage;
        ChatRoom: typeof ChatRoom;
        Contact: typeof Contact;
        ForwardOption: typeof ForwardOption;
        Line: typeof Line;
        NotificationOptions: typeof NotificationOptions;
        Profile: typeof Profile;
        Session: typeof Session;
        Voicemail: typeof Voicemail;
        Relocation: typeof Relocation;
        ConferenceRoom: typeof ConferenceRoom;
        CallSession: typeof CallSession;
        IndirectTransfer: typeof IndirectTransfer;
        SwitchboardCall: typeof SwitchboardCall;
        WebRTCPhone: typeof WebRTCPhone;
        Meeting: typeof Meeting;
    };
    readonly api: import("..").WazoApiClient;
    readonly agentd: import("../api/agentd").AgentD;
    readonly amid: import("../api/amid").AmiD;
    readonly application: import("../api/application").ApplicationD;
    readonly auth: import("../api/auth").AuthD;
    readonly callLogd: import("../api/call-logd").CallLogD;
    readonly calld: import("../api/calld").CallD;
    readonly chatd: import("../api/chatd").ChatD;
    readonly confd: import("../api/confd").ConfD;
    readonly dird: import("../api/dird").DirD;
    readonly webhookd: import("../api/webhookd").WebhookD;
    InvalidSubscription: typeof InvalidSubscription;
    InvalidAuthorization: typeof InvalidAuthorization;
    CanceledCallError: typeof CanceledCallError;
    SFUNotAvailableError: typeof SFUNotAvailableError;
    NoTenantIdError: typeof NoTenantIdError;
    NoDomainNameError: typeof NoDomainNameError;
    NoSamlRouteError: typeof NoSamlRouteError;
    SamlConfigError: typeof SamlConfigError;
};
export default Wazo;
//# sourceMappingURL=index.d.ts.map