import { FailoverCacheState } from 'CallingClient/registration/types';
import { KmsKey, KmsResourceObject, LogsMetaData, PeopleListResponse, UploadLogsResponse, WebexRequestPayload } from '../common/types';
type Listener = (e: string, data?: unknown) => void;
type ListenerOff = (e: string) => void;
export type ServiceHost = {
    host: string;
    ttl: number;
    priority: number;
    id: string;
    homeCluster?: boolean;
};
export type Model = {
    _values: {
        key: string;
    };
};
export type ServiceCatalog = {
    serviceGroups: {
        postauth: [
            {
                _values: {
                    name: string;
                    hosts: ServiceHost[];
                };
            }
        ];
    };
};
export type ClientRegionInfo = {
    attribution: string;
    clientAddress: string;
    clientRegion: string;
    countryCode: string;
    disclaimer: string;
    regionCode: string;
    timezone: string;
};
export type Logger = {
    config?: {
        level: string;
        bufferLogLevel: string;
    };
    log: (payload: string) => void;
    error: (payload: string) => void;
    warn: (payload: string) => void;
    info: (payload: string) => void;
    trace: (payload: string) => void;
    debug: (payload: string) => void;
};
export interface WebexSDK {
    boundedStorage: {
        get: (namespace: string, key: string) => Promise<FailoverCacheState>;
        put: (namespace: string, key: string, value: FailoverCacheState) => Promise<void>;
        del: (namespace: string, key: string) => Promise<void>;
    };
    config: {
        fedramp: boolean;
        defaultMobiusSocketOptions?: Record<string, unknown>;
    };
    version: string;
    canAuthorize: boolean;
    credentials: {
        getUserToken: () => Promise<string>;
        canRefresh?: boolean;
        refresh?: (options: {
            force: boolean;
        }) => Promise<unknown>;
    };
    ready: boolean;
    sessionId?: string;
    request: <T>(payload: WebexRequestPayload) => Promise<T>;
    internal: {
        mercury: {
            on: Listener;
            off: ListenerOff;
            connected: boolean;
            connecting: boolean;
        };
        feature?: {
            updateFeature?: (featureToggle: unknown) => void;
        };
        calendar: unknown;
        device: {
            url: string;
            userId: string;
            orgId: string;
            version: string;
            callingBehavior: string;
            registered?: boolean;
            webSocketUrl?: string;
            register?: () => Promise<unknown>;
            refresh?: () => Promise<unknown>;
            settings?: Record<string, {
                value?: boolean;
            } | undefined>;
            features: {
                developer: {
                    models: Model[];
                    get: (key: string) => {
                        value: boolean;
                    } | undefined;
                };
                entitlement: {
                    models: Model[];
                };
            };
        };
        encryption: {
            decryptText: (encryptionKeyUrl: string, encryptedData?: string) => Promise<string>;
            encryptText: (encryptionKeyUrl: string, text?: string) => Promise<string>;
            kms: {
                createUnboundKeys: (arg0: {
                    count?: number;
                }) => Promise<KmsKey[]>;
                createResource: (arg0: {
                    keyUris: string[];
                }) => Promise<KmsResourceObject>;
                bindKey: (arg0: {
                    kroUri: string;
                    keyUri: string;
                }) => Promise<KmsKey>;
            };
        };
        presence: unknown;
        support: {
            submitLogs: (metaData: LogsMetaData, logs?: string, options?: {
                type: 'diff' | 'full';
            }) => Promise<UploadLogsResponse>;
        };
        services: {
            _hostCatalog: Record<string, ServiceHost[]>;
            _serviceUrls: {
                mobius: string;
                identity: string;
                janus: string;
                wdm: string;
                broadworksIdpProxy: string;
                hydra: string;
                mercuryApi: string;
                'ucmgmt-gateway': string;
                contactsService: string;
            };
            _activeServices: {
                broadworksIdpProxy: string;
                contactsService: string;
                hydra: string;
                janus: string;
                mercuryApi: string;
                mobius: string;
            };
            get: (service: string) => string;
            getMobiusClusters: () => ServiceHost[];
            fetchClientRegionInfo: () => Promise<ClientRegionInfo>;
            invalidateCache?: (timestamp: unknown) => void;
            switchActiveClusterIds?: (activeClusters: unknown) => void;
        };
        metrics: {
            submitClientMetrics: (name: string, data: unknown) => void;
        };
    };
    logger: Logger;
    messages: unknown;
    memberships: unknown;
    people: {
        list: (arg: object) => Promise<PeopleListResponse>;
    };
    rooms: unknown;
    teams: unknown;
}
export interface ISDKConnector {
    setWebex: (webexInstance: WebexSDK) => void;
    getWebex: () => WebexSDK;
    get: () => ISDKConnector;
    registerListener: <T>(event: string, cb: (data?: T) => unknown) => void;
    unregisterListener: (event: string) => void;
}
export {};
//# sourceMappingURL=types.d.ts.map