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 Workano: {
    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: (forServer?: string | null | undefined) => import("..").WorkanoApiClient;
    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("..").WorkanoApiClient;
    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 Workano;
//# sourceMappingURL=index.d.ts.map