declare module "src/config" {
    namespace _default {
        let version: string;
        let api: string;
        let allowSafariSFU: boolean;
        let screencapture: boolean;
        let verbose: boolean;
        let vbgScriptPath: string;
        let hdCamera: boolean;
    }
    export default _default;
}
declare module "src/options" {
    namespace _default {
        let widescreen: boolean;
    }
    export default _default;
}
declare module "src/Logger" {
    export default Logger;
    namespace Logger {
        function error(...args: any[]): void;
        function warn(...args: any[]): void;
        function info(...args: any[]): void;
        function debug(...args: any[]): void;
    }
}
declare module "src/ComApi" {
    export default ComApi;
    /**
     * eyeson Communications Api
     */
    class ComApi {
        constructor(uri: any, token: any);
        uri: any;
        token: any;
        cache: {
            users: any[];
        };
        errorCallback: any;
        _handleError(error: any, id: any): boolean;
        _request(path: any, options?: {}): Promise<any>;
        /**
         * NOTE: slightly adjusted from:
         * https://gist.github.com/ghinda/8442a57f22099bdb2e34
         */
        _objectToFormData(obj: any, form: any, namespace: any): any;
        _post(path: any, data: any): Promise<any>;
        _put(path: any, data: any): Promise<any>;
        onError(callback: any): void;
        /**
         * Fetch room details including the user and credentials from com-api.
         * @param {function} [callback] - Callback function
         * @return {Promise}
         */
        getRoom(callback?: Function): Promise<any>;
        /**
         * Terminate meeting immediately for all users
         * @return {Promise}
         */
        terminateMeeting(): Promise<any>;
        /**
         * Retrieve user information. Will use cache on multiple requests.
         * @param {string} userId - UserId
         * @param {function} callback - Callback function
         * @return {Promise}
         */
        getUser(userId: string, callback: Function): Promise<any>;
        addUserAttributes(user: any, userId: any, clientId: any): any;
        /**
         * Remove user from current meeting.
         * @param {string} userId - UserId
         * @return {Promise}
         **/
        kickUser(userId: string): Promise<any>;
        /**
         * Request a guest user from api.
         * @param {object} user - { name, email, locale }
         * @param {function} callback - Callback function
         * @return {Promise}
         */
        requestUser(user: object, callback: Function): Promise<any>;
        /**
         * Broadcast to a platform.
         * @param {object} data - { playerUrl, streamUrl }
         * @param {string} platform - 'generic'
         * @return {Promise}
         */
        startBroadcast(data: object, platform: string): Promise<any>;
        /**
         * Broadcast to a platform.
         * @param {object} data - { playerUrl }
         * @param {string} platform - 'generic'
         * @return {Promise}
         */
        publishBroadcast(data: object, platform: string): Promise<any>;
        /**
         * Stop a broadcast from a platform.
         * @param {string} platform - 'generic'
         * @return {Promise}
         */
        stopBroadcast(platform: string): Promise<any>;
        /**
         * Stop all broadcasts.
         * @return {Promise}
         */
        stopAllBroadcasts(): Promise<any>;
        /**
         * Start a recording.
         * @return {Promise}
         */
        startRecording(): Promise<any>;
        /**
         * Stop a recording
         * @return {Promise}
         */
        stopRecording(): Promise<any>;
        /**
         * Set layout
         * @see https://docs.eyeson.com/docs/rest/references/layout
         * @param {object} params - eg. { layout: 'auto' } or { users: [ id1, id2 ...] }
         * @return {Promise}
         */
        setLayout(params: object): Promise<any>;
        /**
         * Set layer
         * @see https://docs.eyeson.com/docs/rest/references/layers
         * @param {object} params - eg. { url: 'https://...', 'z-index': '-1' }
         * @return {Promise}
         */
        setLayer(params: object): Promise<any>;
        /**
         * Clear front most layer
         * @return {Promise}
         */
        clearFrontLayer(): Promise<any>;
        /**
         * Take a snapshot of the current podium
         * @return {Promise}
         */
        takeSnapshot(): Promise<any>;
        /**
         * Get snapshot info by snapshotId
         * @param {string} snapshotId - SnapshotId
         * @param {function} [callback] - Callback function
         * @return {Promise}
         */
        getSnapshot(snapshotId: string, callback?: Function): Promise<any>;
        /**
         * Start a playback
         * @see https://docs.eyeson.com/docs/rest/references/playbacks
         * @param {object} playback - eg. { url: 'https://..', play_id: 'demo', audio: false }
         * @param {function} [callback] - Callback function
         * @return {Promise}
         */
        startPlayback(playback: object, callback?: Function): Promise<any>;
        /**
         * Stop a playback identified by play_id
         * @param {object} playback - eg. { play_id: 'demo' }
         * @return {Promise}
         */
        stopPlayback(playback: object): Promise<any>;
        /**
         * Lock meeting to freeze current participants
         * @return {Promise}
         */
        lockMeeting(): Promise<any>;
        /**
         * Send message like type="chat"
         * @see https://docs.eyeson.com/docs/rest/references/messages
         * @param {object} params - eg. { type: 'chat', content: 'test' }
         * @return {Promise}
         */
        sendMessage(params: object): Promise<any>;
        /**
         * Start presentation
         * @param {function} [callback] - Callback function
         * @return {Promise}
         */
        startPresentation(callback?: Function): Promise<any>;
        /**
         * Stop presentation
         * @return {Promise}
         */
        stopPresentation(): Promise<any>;
        requestPermalinkMeetingInfo(callback: any): Promise<any>;
        joinPermalinkUser(callback: any): Promise<any>;
    }
}
declare module "src/utils/throttle" {
    export default throttle;
    /**
     * Creates and returns a new, throttled version of the passed function, that,
     * when invoked repeatedly, will only actually call the original function at most
     * once per every wait milliseconds. Useful for rate-limiting events that occur
     * faster than you can keep up with.
     *
     * By default, throttle will execute the function as soon as you call it for the
     * first time, and, if you call it again any number of times during the wait
     * period, as soon as that period is over. If you'd like to disable the
     * leading-edge call, pass {leading: false}, and if you'd like to disable the
     * execution on the trailing-edge, pass {trailing: false}.
     *
     * @see http://underscorejs.org/#throttle
     *
     * @param {function} func - Function to be throttled
     * @param {number} wait - N milliseconds for execution
     * @param {object} [options] - default { leading: true }
     * @return {function} - throttled version of given function
     */
    function throttle(func: Function, wait: number, options?: object): Function;
}
declare module "src/events/BaseEvent" {
    export default BaseEvent;
    class BaseEvent {
        constructor(context: any);
        context: any;
        handle(msg: any): void;
    }
}
declare module "src/events/PlaybackEvents" {
    export class StartPlaybackEvent extends BaseEvent {
    }
    export class StopPlaybackEvent extends BaseEvent {
    }
    import BaseEvent from "src/events/BaseEvent";
}
declare module "src/events/PublicEvent" {
    export default PublicEvent;
    class PublicEvent extends BaseEvent {
    }
    import BaseEvent from "src/events/BaseEvent";
}
declare module "src/events/AnnotationEvents" {
    export class StartAnnotationEvent extends PublicEvent {
        handle(): void;
    }
    export class StopAnnotationEvent extends PublicEvent {
        handle(): void;
    }
    import PublicEvent from "src/events/PublicEvent";
}
declare module "src/events/StfuEvent" {
    export default StfuEvent;
    class StfuEvent extends PublicEvent {
        handle(): void;
    }
    import PublicEvent from "src/events/PublicEvent";
}
declare module "src/events/IgnoreEvent" {
    export default IgnoreEvent;
    class IgnoreEvent extends BaseEvent {
        handle(): void;
    }
    import BaseEvent from "src/events/BaseEvent";
}
declare module "src/events/ForwardEvent" {
    export default ForwardEvent;
    class ForwardEvent extends BaseEvent {
    }
    import BaseEvent from "src/events/BaseEvent";
}
declare module "src/FullscreenHelper" {
    export default FullscreenHelper;
    /**
     * Fullscreen helper. Wrapper for screenfull plugin and fullscreen support
     */
    class FullscreenHelper {
        /**
         * Register on change event handler
         *
         * @param {function} callback - Callback change event handler
         */
        onChange(callback: Function): void;
        hasSupport: boolean;
        /**
         * Toggle fullscreen on element
         *
         * @param {Element|null} [element] - Element to toggle fullscreen, default documentElement
         * @param {object} [options] - https://developer.mozilla.org/en-US/docs/Web/API/Element/requestFullscreen#options
         * @return {Promise|null}
         */
        toggle(element?: Element | null, options?: object): Promise<any> | null;
        /**
         * Check if fullscreen is supported
         *
         * @return {boolean} - is supported
         */
        canFullscreen(): boolean;
        /**
         * Get current fullscreen state
         *
         * @return {boolean} - is fullscreen
         */
        isFullscreen(): boolean;
        /**
         * Remove all change event handler
         */
        off(): void;
    }
}
declare module "src/utils/utils" {
    export function isObject(item: any): boolean;
}
declare module "src/FeatureDetector" {
    namespace _default {
        function environment(): {
            canMix: boolean;
            canPip: boolean;
            canSFU: boolean;
            isPhone: boolean;
            inIframe: boolean;
            isIOSDevice: boolean;
            canUseEyeson: boolean;
            canFullscreen: boolean;
            hasMobileDevice: boolean;
            canToggleCamera: boolean;
            canPresentFiles: boolean;
            canScreenCapture: boolean;
            canAdjustSettings: boolean;
            canStreamLocalMedia: boolean;
            isExperimentalBrowser: boolean;
        };
        function platform(): any;
        function canUseEyeson(): boolean;
        function hasGetUserMedia(): boolean;
        function hasGetDisplayMedia(): boolean;
        function hasPeerConnection(): boolean;
        function hasCaptureStream(): boolean;
        function hasCanvasCaptureSupport(): boolean;
        function hasSenders(): boolean;
        function hasTrackOnUnmute(): boolean;
        function hasWebpSupport(): boolean;
        function canChangeAudioOutput(): boolean;
        function canChangeMicrophone(): boolean;
        function canMultipleDifferentMicrophones(): boolean;
        function canChangeCamera(): boolean;
        function canScreenCapture(): boolean;
        function canPresentFiles(): boolean;
        function canStreamLocalMedia(): boolean;
        function requiresLowerConstraints(): boolean;
        function browserName(): string;
        function browserVersion(): number;
        function isEdge(): boolean;
        function isFF(): boolean;
        function isChrome(): boolean;
        function isSafari(): boolean;
        function isMinimumRequiredBrowser(): boolean;
        function isMinimumRequiredEdge(): boolean;
        function isMinimumRequiredFF(): boolean;
        function isMinimumRequiredChrome(): boolean;
        function isMinimumRequiredSafari(): boolean;
        function isWorkingIOSBrowser(): boolean;
        function isExperimentalBrowser(): boolean;
        function hasPipSupport(): boolean;
        function iOSPipCheck(): Promise<any>;
        function isAndroidDevice(): boolean;
        function isIOSDevice(): boolean;
        function isIPhone(): boolean;
        function isAndroidPhone(): boolean;
        function isMacOS(): boolean;
        function inIframe(): boolean;
        function isPhone(): boolean;
        function hasMobileDevice(): boolean;
        function isTouchDevice(): boolean;
        function canDisplayTooltips(): boolean;
        function canAdjustDeviceSettings(): boolean;
        function canToggleCamera(): boolean;
        function canDrawCamera(): boolean;
        function canMix(): boolean;
        function stopsDeviceActivityIndicatorOnDisable(): boolean;
        function supportsBlurOnSVG(): boolean;
        function hasLocalStorage(): boolean;
        function canFullscreen(): boolean;
        function isFullscreen(): boolean;
        function canSFU(): boolean;
        function canDataChannel(): boolean;
        function disallowAudioSyncSrcChange(): boolean;
        function canShare(): boolean;
        function isWebView(): boolean;
        function isTestSuite(): boolean;
        function canVirtualBackground(): boolean;
        function canvasBlurSupport(): any;
        function canStereo(): boolean;
        function canChooseDisplaySurface(): boolean;
        function hasPipCamSupport(): boolean;
        function canMonitorSystemPressure(): any;
        function canSetCodecs(): boolean;
        function canSetCodecPreferences(): boolean;
        function canSetCodecsLegacy(): boolean;
        function canGeolocation(): boolean;
    }
    export default _default;
}
declare module "src/NinjaStream" {
    export default NinjaStream;
    /**
     * Ninja Stream
     **/
    class NinjaStream {
        _stream: MediaStream;
        get stream(): MediaStream;
        /**
         * Create a dummy stream from a canvas element.
         **/
        createStream(): MediaStream;
    }
}
declare module "src/LocalStorage" {
    export default LocalStorage;
    namespace LocalStorage {
        function store(key: string, value: object): boolean;
        function load(key: string, defaultValueParam: object): object;
    }
}
declare module "src/utils/StreamHelpers" {
    /**
     * Check if media stream has audio and audio track is enabled
     *
     * @param {MediaStream} stream
     * @return {boolean}
     */
    export function hasAudio(stream: MediaStream): boolean;
    /**
     * Check if media stream has video and video track is enabled
     *
     * @param {MediaStream} stream
     * @return {boolean}
     */
    export function hasVideo(stream: MediaStream): boolean;
    /**
     * Disable audio (=mute)
     *
     * @param {MediaStream} stream
     * @return {MediaStream}
     */
    export function disableAudio(stream: MediaStream): MediaStream;
    /**
     * Enable audio (=unmute)
     *
     * @param {MediaStream} stream
     * @return {MediaStream}
     */
    export function enableAudio(stream: MediaStream): MediaStream;
    /**
     * Toggle audio (=mute/unmute)
     *
     * @param {MediaStream} stream
     * @param {boolean} enabled
     * @return {MediaStream}
     */
    export function toggleAudio(stream: MediaStream, enabled: boolean): MediaStream;
    /**
     * Toggle video
     *
     * @param {MediaStream} stream
     * @param {boolean} enabled
     * @return {MediaStream}
     */
    export function toggleVideo(stream: MediaStream, enabled: boolean): MediaStream;
    /**
     * In order to be "informed" about track ending in compose_canvas where we
     * create offscreen/hidden video elements and need to clean them up afterwards,
     * we need to dispatch 'stopped' ourselves. The 'ended' event is not emitted
     * after stopping the track, as one might expect see:
     * @see https://stackoverflow.com/q/55953038/980524
     *
     * @param {MediaStreamTrack} track
     * @return {boolean} dispatchEvent return value
     */
    export function stopTrack(track: MediaStreamTrack): boolean;
    /**
     * Stop stream if exist
     *
     * @param {MediaStream} stream
     */
    export function stopStream(stream: MediaStream): void;
    export function isScreenAsVideoTrack(track: any): boolean;
    export function isNinjaStreamTrack(track: any): boolean;
    export function isVbgStreamTrack(track: any): boolean;
    export function getScreenTracks(stream: any): any;
    export function getScreenPresentationTracks(stream: any): any;
    export function getScreenAsVideoTracks(stream: any): any;
    export function getCameraTracks(stream: any): any;
    export function getVbgTracks(stream: any): any;
    export function stopCamera(stream: any): void;
    export function disableCamera(stream: any): any;
    export function enableCamera(stream: any): any;
    export function toggleCamera(stream: any, enabled: any): any;
    export function toggleVbgTrack(stream: any, enabled: any): any;
    export function getCanvasTracks(stream: any): any;
    export function isScreenStream(stream: any): any;
    export function isScreenPresentationStream(stream: any): any;
    export function isCanvasStream(stream: any): any;
    export function isVBGStream(stream: any): any;
    export function isCameraStream(stream: any): boolean;
    export function isCanvasPresentationStream(stream: any): any;
    export function isPresentationStream(stream: any): any;
    export function hasCameraVideo(stream: any): any;
    export function getFacingMode(stream: any): any;
    export function captureStream(canvas: any): any;
    /**
     * Generates a new MediaStream from a given external MediaStream and adds
     * missing audio or video track.
     *
     * @param {MediaStream} stream - External media stream
     * @param {boolean} [audioOnly] - Skip video for Eyeson Audio-only mode
     * @return {MediaStream|false} - Created MediaStream or false
     */
    export function createExternalStream(stream: MediaStream, audioOnly?: boolean): MediaStream | false;
    /**
     * Required once for browsers that don't support RTCRtpSender.getCapabilities().
     * Check with FeatureDetector.canSetCodecsLegacy()
     *
     * @return {Promise}
     */
    export function initLegacySenderCodecs(): Promise<any>;
    /**
     * Get list of supported sender codecs for type audio or video
     *
     * @param {string} kind - "video" or "audio"
     * @return {list} - List of supported sender codecs
     */
    export function getSenderCodecs(kind: string): list;
}
declare module "src/utils/immediate" {
    export default immediate;
    /**
     * Returns a function that is called asynchronious and immediately, even faster
     * than setTimeout. This implementation only works in browsers that support
     * window.postMessage.
     *
     * @see https://github.com/YuzuJS/setImmediate/blob/modern-browsers-only/setImmediate.js
     *
     * @param {function} fn - Function to be called immediately
     */
    function immediate(fn: Function): void;
}
declare module "src/utils/throttledAnimationFrame" {
    export default throttledAnimationFrame;
    function throttledAnimationFrame(fn: any, fps: any): {
        requestAnimationFrame: () => void;
        cancelAnimationFrame: () => void;
    };
}
declare module "src/utils/importScript" {
    export default importScript;
    /**
     * importScript
     * lazy-load script files, promise-based
     */
    function importScript(url: any, integrity?: any): Promise<any>;
}
declare module "src/utils/cacheStorage" {
    namespace _default {
        export { storeBlobURL };
        export { loadBlobURL };
        export { deleteBlob };
    }
    export default _default;
    function storeBlobURL(blobURL: any, path: any): Promise<void>;
    function loadBlobURL(path: any): Promise<string | false>;
    function deleteBlob(path: any): Promise<void>;
}
declare module "src/utils/canvasBlur" {
    export default canvasBlur;
    function canvasBlur(): {
        run: (imageBitmap: any, radius?: number) => any;
        reset: () => void;
    };
}
declare module "src/VirtualBackgroundMixer" {
    export default VirtualBackgroundMixer;
    class VirtualBackgroundMixer {
        static isTypeAllowed(type: any): boolean;
        static checkExternalImage(type: any): Promise<void>;
        static loadLocalImage(callbackFN: any): void;
        static getImageBlobOrFallback(isBlobAvailable?: boolean): "image:blob" | "blur:8";
        constructor(name?: string);
        name: string;
        canvas: HTMLCanvasElement;
        ctx: CanvasRenderingContext2D;
        originalStream: any;
        outStream: MediaStream;
        video: HTMLVideoElement;
        reader: any;
        size: {
            width: number;
            height: number;
        };
        segmentationMaskCanvas: any;
        segmentationMaskCtx: any;
        segmentationMask: ImageData;
        videoCanvas: any;
        videoCtx: any;
        playPromise: Promise<void>;
        abort: boolean;
        paused: boolean;
        raf: {
            requestAnimationFrame: () => void;
            cancelAnimationFrame: () => void;
        };
        backgroundOld: {
            type: any;
            value: any;
        };
        backgroundType: any;
        backgroundValue: any;
        blurInit: boolean;
        blurCanvas: any;
        canvasBlur: {
            run: (imageBitmap: any, radius?: number) => any;
            reset: () => void;
        };
        imageCanvas: any;
        state: string;
        loadingListener: any[];
        handleStateChange: () => void;
        storeLocalImageFile(): void;
        resetLocalImageFile(): void;
        saveLocalImageFile(): void;
        updateCache(type: any): void;
        onLoading(listener: any): void;
        offLoading(listener: any): void;
        emitLoading(loading: any): void;
        initiateStream(userMediaStream: any): any;
        start(): void;
        drawVideo(): Promise<void>;
        suspend(): void;
        resume(): void;
        drawBackground(frame: any): void;
        initBackground(): Promise<void>;
        setBackgroundFallback(): void;
        changeBackground(type: any): void;
        stop(): void;
        stopOriginalStream(): void;
        terminate(): void;
        destroy(): void;
    }
}
declare module "src/DeviceManager" {
    export default DeviceManager;
    /**
     * eyeson Device Manager used to handle cameras, microphones and speakers.
     */
    class DeviceManager {
        /**
         * Static method to get a list of available devices
         * @return {Promise<Array>} - devices list
         */
        static getDevices(): Promise<any[]>;
        /**
         * Get constraints for specified options { audio: true, video: true }
         * If a specific device is chosen it has to be stored in localStorage or will
         * be ignored.
         *
         * @param {MediaOptions} [optionsParam] - defaults to { audio: true, video: true }
         * @return {Promise<object>} - audio and video constraints
         */
        static getConstraints(optionsParam?: {
            /**
             * - default true
             */
            audio?: boolean;
            /**
             * - default true
             */
            video?: boolean;
            /**
             * - default false
             */
            eco?: boolean;
            /**
             * - default false
             */
            audioPassthrough?: boolean;
        }): Promise<object>;
        static determineConstraintsForDevices(devices: any, options: any): any;
        static applyLastUsedDevices(constraints: any, devices: any): void;
        static adjustVideoConstraints(constraints: any): void;
        static adjustAudioConstraints(constraints: any, options: any): void;
        /**
         * For now we handle the mobile options and constraints completely separately.
         * That way we can address the facingMode constraint.
         *
         * @param {LiteMediaOptions} options - { audio: true/false, video: true/false }
         * @return {Promise<object>} - audio and video contraints
         */
        static getMobileConstraints(options: {
            /**
             * - default true
             */
            audio?: boolean;
            /**
             * - default true
             */
            video?: boolean;
        }): Promise<object>;
        /**
         * Get sinkId.
         * @return {Promise<string>} sinkId
         */
        static getSinkId(): Promise<string>;
        /**
         * Return available devices in a friendly format.
         *
         * @return {Promise<object>} { cameras, microphones, speakers }
         */
        static fetchDevices(): Promise<object>;
        static fetchInputDevices(): Promise<any[]>;
        /**
         * Get stored virtual background type
         * @param {boolean} [isBlobAvailable] - default true
         * @return {string} type - defaults to "off"
         */
        static getStoredVirtualBackgroundType(isBlobAvailable?: boolean): string;
        /**
         * @typedef {object} MediaOptions
         * @prop {boolean} [audio] - default true
         * @prop {boolean} [video] - default true
         * @prop {boolean} [eco] - default false
         * @prop {boolean} [audioPassthrough] - default false
         */
        /**
         * @typedef {object} LiteMediaOptions
         * @prop {boolean} [audio] - default true
         * @prop {boolean} [video] - default true
         */
        /**
         * @param {MediaOptions} [options] - Options object. Defaults to { audio: true, video: true, eco: false }
         */
        constructor(options?: {
            /**
             * - default true
             */
            audio?: boolean;
            /**
             * - default true
             */
            video?: boolean;
            /**
             * - default false
             */
            eco?: boolean;
            /**
             * - default false
             */
            audioPassthrough?: boolean;
        });
        sinkId: string;
        options: {
            /**
             * - default true
             */
            audio?: boolean;
            /**
             * - default true
             */
            video?: boolean;
            /**
             * - default false
             */
            eco?: boolean;
            /**
             * - default false
             */
            audioPassthrough?: boolean;
        };
        stream: any;
        cameras: any[];
        listeners: any[];
        speakers: any[];
        microphones: any[];
        constraints: {};
        terminationInProgress: boolean;
        virtualBackground: VirtualBackgroundMixer;
        virtualBackgroundType: string;
        /**
         * Set active stream.
         *
         * NOTE: This can be called _after_ we have already stopped.
         */
        setStream(stream: any): Promise<void>;
        handleError(error: any): void;
        verifyStream(): void;
        /**
         * Store created constraints
         */
        storeConstraints(): void;
        adjustAudioTrack(stream: any): any;
        initiateVirtualBackground(stream: any): any;
        /**
         * Set virtual background type
         * @param {string} type - off, image:*, blur:8|16
         * @return {Promise}
         */
        setVirtualBackgroundType(type: string): Promise<any>;
        loadLocalImageForVirtualBackground(callbackFN: any): void;
        /**
         * Sets cameras, microphones, and speakers and starts a video stream
         * with supplied options.
         *
         * @param {boolean} [isMobile] - default false
         * @return {Promise}
         */
        start(isMobile?: boolean): Promise<any>;
        stopStream(): void;
        /**
         * Stop the media stream. Since we call getUserMedia on gotDevices we don't
         * have a stream in that case.
         */
        stop(): void;
        /**
         * Terminate device manager, remove event handlers etc.
         */
        terminate(): void;
        setDevices(devices: any): void;
        watchForNewDevices(): void;
        /**
         * Register listeners for changes on devices.
         *
         * @param {function} callback - Callback fnction on change event
         */
        onChange(callback: Function): void;
        /**
         * Remove a listener.
         *
         * @param {function} callback - Callback
         */
        removeListener(callback: Function): void;
        /**
         * Wrapper around mediaDevices getUserMedia. Ensures a running stream is
         * stopped and a new one started with newly defined constraints.
         *
         * @param {object} [constraints] - assign new constraints or use previous
         * @return {Promise}
         */
        update(constraints?: object): Promise<any>;
        /**
         * Similar to update but instead of directly supplying constraints,
         * update with options.
         *
         * @param {MediaOptions} [options] - Assign new options or use existing
         * @param {boolean} [isMobile] - default false
         */
        updateWithOptions(options?: {
            /**
             * - default true
             */
            audio?: boolean;
            /**
             * - default true
             */
            video?: boolean;
            /**
             * - default false
             */
            eco?: boolean;
            /**
             * - default false
             */
            audioPassthrough?: boolean;
        }, isMobile?: boolean): Promise<void>;
        /**
         * Set video input selection.
         *
         * @param {string} deviceId - device id of video device
         * @return {Promise} - performs stream update
         */
        setVideoInput(deviceId: string): Promise<any>;
        /**
         * Set audio input selection.
         *
         * @param {string} deviceId - device id of audio device
         * @param {object} [options] - options { preventUpdate }
         * @return {Promise} - performs stream update
         */
        setAudioInput(deviceId: string, options?: object): Promise<any>;
        /**
         * Set audio passthrough option.
         *
         * @param {bool} passthrough - audio passthrough enabled
         * @param {object} [options] - options { preventUpdate }
         * @return {Promise} - performs stream update
         */
        setAudioPassthrough(passthrough: bool, options?: object): Promise<any>;
        /**
         * Set and store audio output selection.
         *
         * @param {string} sinkId - device id of audio output device
         */
        setAudioOutput(sinkId: string): void;
        /**
         * emit bound listeners about changes.
         */
        emit(state: any): void;
    }
    import VirtualBackgroundMixer from "src/VirtualBackgroundMixer";
}
declare module "src/MediaStreamBuilder" {
    export default MediaStreamBuilder;
    /**
     * Options are basically what the user of MediaStreamBuilder "wants" to see in
     * the conference session. For example: no camera video -> options video: false
     * but we'd still have a media stream track with video because conference server
     * currently expects this behaviour and relies on mute_video command being
     * sent.
     **/
    class MediaStreamBuilder {
        constructor(options?: {
            eco: boolean;
            audio: boolean;
            video: boolean;
            screen: boolean;
            surface: any;
            screenStream: any;
            canvas: any;
            existingStream: any;
            micMixer: any;
            vbgMixer: any;
            isPresentation: boolean;
            virtualBackground: boolean;
            deviceMonitor: any;
            audioPassthrough: boolean;
        });
        options: {
            eco: boolean;
            audio: boolean;
            video: boolean;
            screen: boolean;
            surface: any;
            screenStream: any;
            canvas: any;
            existingStream: any;
            micMixer: any;
            vbgMixer: any;
            isPresentation: boolean;
            virtualBackground: boolean;
            deviceMonitor: any;
            audioPassthrough: boolean;
        };
        tempStream: MediaStream;
        brokenTrackCallback: any;
        bindMethods(): void;
        getMediaStream(devices: any): MediaStream | Promise<MediaStream>;
        addNinjaTrack(stream: any): any;
        addCanvasTrack(stream: any): any;
        addScreenTrack(stream: any): Promise<any>;
        adjustAudioTrack(stream: any): any;
        /**
         * Adjust audio and video tracks according to the supplied options.
         * We stop the video track so the camera indicator isn't active.
         * We add a filler video track, unless we're in eco mode, which would result
         * in sdp with media section for video & recvonly. meaning we'd still
         * receive video.
         * In case of iOS we have the cam track that shouldn't get stopped to get turned
         * on again
         **/
        adjustVideoTrack(stream: any): any;
        addScreenStreamTrack(stream: any, screenStream: any): void;
        initializeVirtualBackground(stream: any): any;
        /**
         * We always acquire a stream with at least audio enabled and adjust
         * the desired mute behaviour via the track.
         * Unless, we have no camera and microphones. In that case we use a
         * NinjaStream.
         * If the browser does not support updating the peerConnection
         * we acquire a audio and video stream and adjust the tracks accordingly.
         *
         * In case of replaceTrack support we stop the tracks before
         * acquiring a new stream. Since stopping a track also stops the source.
         * So, at least in Safari we'd stop the camera if the old and new track
         * use the same source.
         * Furthermore Safari on iOS behaves differently again. Camera muting
         * _sometimes_ freezes the remote stream video playback (audio fine).
         **/
        start(): Promise<any>;
        getDisplayMedia(): Promise<MediaStream>;
        cleanupTempStream(): void;
        onBrokenTrackError(callback: any): this;
    }
}
declare module "src/MicMixer" {
    export default MicMixer;
    class MicMixer {
        active: boolean;
        audioContext: any;
        acOut: any;
        micOnlyStream: MediaStream;
        originalStream: any;
        setMicOnlyStream(audioStream: any, videoStream: any): MediaStream;
        getMicOnlyStream(): MediaStream;
        getOriginalStream(): any;
        stopOriginalStream(): void;
        noMix(userMediaStream: any, outStream: any): void;
        initMixScreenshareMix(userMediaStream: any, displayStream: any, outStream: any): void;
        mixScreenshareAudio(userMediaStream: any, displayStream: any, outStream: any): void;
        destroy(): void;
    }
}
declare module "src/events/ChangeLocalStreamEvent" {
    export default ChangeLocalStreamEvent;
    /**
     * ChangeLocalStream (optimization after PodiumEvent).
     **/
    class ChangeLocalStreamEvent extends BaseEvent {
        handle({ audio, video, screen, surface }: {
            audio: any;
            video: any;
            screen?: boolean;
            surface: any;
        }): void;
    }
    import BaseEvent from "src/events/BaseEvent";
}
declare module "src/events/PodiumEvent" {
    export default PodiumEvent;
    class PodiumEvent extends BaseEvent {
        scanMessageForLocalStreamOptimization(session: any, msg: any): void;
        adjustResolution(session: any, msg: any): Promise<void>;
    }
    import BaseEvent from "src/events/BaseEvent";
}
declare module "src/events/SnapshotEvent" {
    export default SnapshotEvent;
    class SnapshotEvent extends BaseEvent {
        handle(): void;
    }
    import BaseEvent from "src/events/BaseEvent";
}
declare module "src/events/SetLayerEvent" {
    export default SetLayerEvent;
    class SetLayerEvent extends BaseEvent {
    }
    import BaseEvent from "src/events/BaseEvent";
}
declare module "src/events/SendChatEvent" {
    export default SendChatEvent;
    class SendChatEvent extends BaseEvent {
    }
    import BaseEvent from "src/events/BaseEvent";
}
declare module "src/events/StopRtmpEvent" {
    export default StopRtmpEvent;
    class StopRtmpEvent extends PublicEvent {
    }
    import PublicEvent from "src/events/PublicEvent";
}
declare module "src/events/SetLayoutEvent" {
    export default SetLayoutEvent;
    class SetLayoutEvent extends BaseEvent {
    }
    import BaseEvent from "src/events/BaseEvent";
}
declare module "src/events/StartRtmpEvent" {
    export default StartRtmpEvent;
    class StartRtmpEvent extends BaseEvent {
    }
    import BaseEvent from "src/events/BaseEvent";
}
declare module "src/sepp/eventEmitter" {
    export default EventEmitter;
    class EventEmitter {
        listeners: Map<any, any>;
        target: EventTarget;
        onEvent(cb: any): void;
        offEvent(cb: any): void;
        removeAllListeners(): void;
        emit(data: any): void;
    }
}
declare module "src/sepp/Transport" {
    export default Transport;
    class Transport extends EventEmitter {
        constructor(options: any);
        connection: WebSocket;
        options: any;
        wasOpen: boolean;
        connect(): void;
        isConnected(): boolean;
        send(message: any): boolean;
        destroy(): void;
    }
    import EventEmitter from "src/sepp/eventEmitter";
}
declare module "src/sepp/crlfNormalize" {
    export default crlfNormalize;
    function crlfNormalize(text: any): any;
}
declare module "src/sepp/parseJwtPayload" {
    export default parseJwtPayload;
    function parseJwtPayload(token: any): any;
}
declare module "src/sepp/uuid" {
    export default uuid;
    function uuid(): string;
}
declare module "src/sepp/SEPP" {
    namespace _default {
        export { UserAgent };
    }
    export default _default;
    class UserAgent extends EventEmitter {
        constructor(options: any);
        callId: any;
        sessionDescriptionHandler: any;
        options: any;
        debouncedHandleSDPUpdate: (...args: any[]) => void;
        onMessage(message: any): Promise<void>;
        termination: boolean;
        initAuthToken(): void;
        setCallId(callId: any): void;
        verifySender(message: any): void;
        handleSdpUpdate(data: any): Promise<void>;
        message(type?: string, data?: {}): void;
        connect(): void;
        transport: Transport;
        call(): Promise<void>;
        resume(authToken: any): void;
        terminate(): void;
    }
    import EventEmitter from "src/sepp/eventEmitter";
    import Transport from "src/sepp/Transport";
}
declare module "src/SigMessageWhitelist" {
    const _default: string[];
    export default _default;
}
declare module "src/PodiumFacade" {
    export default PodiumFacade;
    /**
     * Podium Facade.
     **/
    class PodiumFacade {
        constructor(message: any, clientId: any);
        clientId: any;
        sources: any;
        presenterIdx: any;
        audioSources: any;
        videoSources: any;
        dimensions: any;
        userSourceIndex: any;
        layers: {
            zIndex: number;
            id: any;
        }[];
        get isSolo(): boolean;
        get isSource(): any;
        get isPresenter(): boolean;
        get presenter(): any;
        get hasMedia(): any;
        get hasPresenter(): boolean;
        get hasVideoSources(): boolean;
        get hasAudioPosition(): any;
        get hasVideoPosition(): any;
        get hasMutedVideoPeers(): boolean;
        get userDimensions(): any;
        get allUserDimensions(): any[];
        parseLayer(data: any): {
            zIndex: number;
            id: any;
        }[];
    }
}
declare module "src/SigMessageTransformer" {
    export default SigMessageTransformer;
    /**
     * SipMessageTransformer
     **/
    class SigMessageTransformer {
        constructor(clientId: any);
        clientId: any;
        /**
         * Put a stamp with _src on the message.
         **/
        stamp(message: any): any;
        default(message: any): any;
        process(message: any): any;
        sourceUpdate(message: any): {
            type: string;
            solo: boolean;
            audio: any;
            video: any;
            media: any;
            layers: {
                zIndex: number;
                id: any;
            }[];
            sources: any;
            isSource: any;
            presenter: any;
            isPresenter: boolean;
            hasPresenter: boolean;
            videoSources: any;
            userDimensions: any;
            hasVideoSources: boolean;
            hasDesktopSources: any;
            allUserDimensions: any[];
            hasMutedVideoPeers: boolean;
        };
        voiceActivity(message: any): any;
    }
}
declare module "src/SessionDescriptionHandler" {
    export default SessionDescriptionHandler;
    /**
     * SessionDescriptionHandler
     */
    class SessionDescriptionHandler {
        constructor(options: any);
        datachannel: any;
        peerConnection: RTCPeerConnection;
        localStream: any;
        remoteStream: any;
        connected: boolean;
        iceCheckingTimer: NodeJS.Timeout;
        peerConnectionReady: Promise<any>;
        options: any;
        connection: any;
        handleConnectionStateChange(): void;
        /**
         * Gets the local description from the underlying media implementation
         */
        getDescription(): Promise<{
            type: string;
            sdp: string;
        }>;
        /**
         * Set the remote description to the underlying media implementation
         */
        setDescription(sessionDescription: any): Promise<void>;
        updateDescription(sessionDescription: any): Promise<{
            type: string;
            sdp: string;
        }>;
        close(): void;
        initPeerConnection(): void;
        initPeerConnectionStreamTracks(): void;
        /**
         * Only signal (handleAccept) that we have a remote stream once ontrack
         * says so. Is called twice, once for audio and once for video track.
         */
        handleOntrack({ track, streams }: {
            track: any;
            streams: any;
        }): void;
        handleDatachannel(channel: any): void;
        /**
         * We need to re-format the iceServers here. SIP.js used to offer a
         * higher level api and we supplied the servers in a different format e.g:
         *
         * { stunServers: ["stun:stun1.visocon.com:3478"] }
         * { turnServers: [{ urls: [1,2,3], username: "bob", password: "nob" }] }
         *
         * We currently have the api set return the creds in that format.
         * The peerConnection however expects:
         *
         * {
         *   "iceServers": [
         *     { "urls": "stun:stun1.visocon.com:3478" },
         *     { "urls": [1,2,3], "username": "bob", "credential": "nob" }
         *   ]
         * }
         */
        buildPeerConnectionOptions(): {
            sdpSemantics: string;
            iceServers: {
                urls: any;
            }[];
        };
        getLocalStream(): any;
        getRemoteStream(): any;
        setStream(newStream: any): Promise<any>;
        stopUnusedTracks(oldStream: any, newStream: any): void;
        tracksExist(): boolean;
        scaleResolution(factor: any, maxWidth?: any, maxHeight?: any): Promise<void>;
        limitFramerate(fps: any): Promise<void>;
        setSendEncodings(sendEncodings?: {}): void;
        applyCodecSelection(): void;
        /**
         * Stop all tracks
         */
        stopAllTracks(): void;
    }
}
declare module "src/SigConnection" {
    export default SigConnection;
    /**
     * eyeson Sip Connection.
     *
     * Registers with provided sip credentials and handles events received.
     **/
    class SigConnection {
        constructor(signaling: any, user: any);
        listeners: any[];
        messageListener: any[];
        datachannel: any;
        uaOptions: {
            client_id: any;
            conf_id: any;
            client_name: any;
            mute_video: boolean;
            sessionDescriptionHandlerFactory: (options: any) => SessionDescriptionHandler;
            sessionDescriptionHandlerFactoryOptions: {
                stun_servers: any;
                turn_servers: any;
            };
            transportOptions: {
                auth_token: any;
                endpoint: any;
            };
        } | {
            client_id: any;
        };
        clientId: any;
        userAgent: {
            callId: any;
            sessionDescriptionHandler: any;
            options: any;
            debouncedHandleSDPUpdate: (...args: any[]) => void;
            onMessage(message: any): Promise<void>;
            termination: boolean;
            initAuthToken(): void;
            setCallId(callId: any): void;
            verifySender(message: any): void;
            handleSdpUpdate(data: any): Promise<void>;
            message(type?: string, data?: {}): void;
            connect(): void;
            transport: import("src/sepp/Transport").default;
            call(): Promise<void>;
            resume(authToken: any): void;
            terminate(): void;
            listeners: Map<any, any>;
            target: EventTarget;
            onEvent(cb: any): void;
            offEvent(cb: any): void;
            removeAllListeners(): void;
            emit(data: any): void;
        };
        transformer: SigMessageTransformer;
        seppMessaging: boolean;
        initUserAgentOptions(signaling: any, user: any): {
            client_id: any;
            conf_id: any;
            client_name: any;
            mute_video: boolean;
            sessionDescriptionHandlerFactory: (options: any) => SessionDescriptionHandler;
            sessionDescriptionHandlerFactoryOptions: {
                stun_servers: any;
                turn_servers: any;
            };
            transportOptions: {
                auth_token: any;
                endpoint: any;
            };
        } | {
            client_id: any;
        };
        /**
         * Connect and register to the configured WebSocket server.
         **/
        start(): Promise<any>;
        /**
         * Start a session on current connection.
         **/
        startSession(options: any): {
            callId: any;
            sessionDescriptionHandler: any;
            options: any;
            debouncedHandleSDPUpdate: (...args: any[]) => void;
            onMessage(message: any): Promise<void>;
            termination: boolean;
            initAuthToken(): void;
            setCallId(callId: any): void;
            verifySender(message: any): void;
            handleSdpUpdate(data: any): Promise<void>;
            message(type?: string, data?: {}): void;
            connect(): void;
            transport: import("src/sepp/Transport").default;
            call(): Promise<void>;
            resume(authToken: any): void;
            terminate(): void;
            listeners: Map<any, any>;
            target: EventTarget;
            onEvent(cb: any): void;
            offEvent(cb: any): void;
            removeAllListeners(): void;
            emit(data: any): void;
        };
        updateAuthAndRestartSession(roomData: any): void;
        updateAuthAndResume(roomData: any): void;
        initDatachannel(channel: any): void;
        /**
         * Stop listening for messages.
         **/
        close(): void;
        /**
         * Parse, filter, transform and finally forward messages received from SIP
         * connection.
         **/
        onMessage(callback: any): void;
        handleMessage(message: any): void;
        /**
         * Transport a message over current connection.
         **/
        send(msg: any): void;
        sendSeppMessage(msg: any): void;
        onError(errorHandler: any): this;
        emit(msg: any): void;
    }
    import SessionDescriptionHandler from "src/SessionDescriptionHandler";
    import SigMessageTransformer from "src/SigMessageTransformer";
}
declare module "src/events/RoomReceivedEvent" {
    export default RoomReceived;
    class RoomReceived extends PublicEvent {
    }
    import PublicEvent from "src/events/PublicEvent";
}
declare module "src/events/FetchRoomEvent" {
    export default FetchRoomEvent;
    class FetchRoomEvent extends PublicEvent {
        handle(): void;
    }
    import PublicEvent from "src/events/PublicEvent";
}
declare module "src/events/DeleteFileEvent" {
    export default DeleteFileEvent;
    /**
     * Deletes a file using the com api.
     **/
    class DeleteFileEvent extends BaseEvent {
    }
    import BaseEvent from "src/events/BaseEvent";
}
declare module "src/events/UploadFileEvent" {
    export default UploadFileEvent;
    /**
     * Uploads a file using the com api.
     **/
    class UploadFileEvent extends PublicEvent {
        addFile(response: any): void;
    }
    import PublicEvent from "src/events/PublicEvent";
}
declare module "src/events/ReceiveChatEvent" {
    export default ReceiveChatEvent;
    class ReceiveChatEvent extends PublicEvent {
        msg: any;
        forwardMessage(user: any): void;
    }
    import PublicEvent from "src/events/PublicEvent";
}
declare module "src/events/StartStreamEvent" {
    export default StartStreamEvent;
    class StartStreamEvent extends BaseEvent {
        handle({ audio, video, virtualBackground, screen, surface, audioPassthrough }: {
            audio?: boolean;
            video?: boolean;
            virtualBackground?: boolean;
            screen?: boolean;
            surface?: any;
            audioPassthrough?: boolean;
        }): Promise<void>;
    }
    import BaseEvent from "src/events/BaseEvent";
}
declare module "src/events/ChangeStreamEvent" {
    export default ChangeStreamEvent;
    /**
     * ChangeStreamEvent "changes" a stream with the given options.
     *
     * The MediaStream is only updated if the Browser turns off device activity
     * indicators on disable (i.e. setting the video tracks `.enabled` prop to
     * false). This is the case for Firefox (May 2019).
     *
     * For other Browsers, a totally new MediaStream is acquired. Although some
     * of its tracks might be re-used / kept alive.
     * See `.setStream` in SDH for more details of current implementation.
     **/
    class ChangeStreamEvent extends BaseEvent {
        handle({ audio, video, screen, surface }: {
            audio?: boolean;
            video?: boolean;
            screen?: boolean;
            surface: any;
        }): Promise<void>;
    }
    import BaseEvent from "src/events/BaseEvent";
}
declare module "src/events/ReplaceStreamEvent" {
    export default ReplaceStreamEvent;
    /**
     * ChangeStreamEvent "changes" a stream with the given options.
     *
     * The MediaStream is only updated if the Browser turns off device activity
     * indicators on disable (i.e. setting the video tracks `.enabled` prop to
     * false). This is the case for Firefox (May 2019).
     *
     * For other Browsers, a totally new MediaStream is acquired. Although some
     * of its tracks might be re-used / kept alive.
     * See `.setStream` in SDH for more details of current implementation.
     **/
    class ReplaceStreamEvent extends BaseEvent {
        handle(msg: any): any;
    }
    import BaseEvent from "src/events/BaseEvent";
}
declare module "src/events/ToggleCameraEvent" {
    export default ToggleCameraEvent;
    class ToggleCameraEvent extends BaseEvent {
        handle({ facingMode }: {
            facingMode: any;
        }): void;
    }
    import BaseEvent from "src/events/BaseEvent";
}
declare module "src/events/AcceptSessionEvent" {
    export default AcceptSessionEvent;
    class AcceptSessionEvent extends PublicEvent {
    }
    import PublicEvent from "src/events/PublicEvent";
}
declare module "src/events/StopRecordingEvent" {
    export default StopRecordingEvent;
    class StopRecordingEvent extends PublicEvent {
    }
    import PublicEvent from "src/events/PublicEvent";
}
declare module "src/events/VoiceActivityEvent" {
    export default VoiceActivityEvent;
    /**
     * VoiceActivityEvent
     **/
    class VoiceActivityEvent extends BaseEvent {
        getUser(id: any): Promise<any>;
    }
    import BaseEvent from "src/events/BaseEvent";
}
declare module "src/events/StartRecordingEvent" {
    export default StartRecordingEvent;
    class StartRecordingEvent extends PublicEvent {
    }
    import PublicEvent from "src/events/PublicEvent";
}
declare module "src/events/ScreenCaptureEvent" {
    export default ScreenCaptureEvent;
    class ScreenCaptureEvent extends BaseEvent {
        handle({ audio, screen, screenStream, surface }: {
            audio: any;
            screen?: boolean;
            screenStream: any;
            surface: any;
        }): void;
    }
    import BaseEvent from "src/events/BaseEvent";
}
declare module "src/events/StartPresentingEvent" {
    export default StartPresentingEvent;
    class StartPresentingEvent extends BaseEvent {
        streamVideo(): void;
        handle({ stream, present }: {
            stream?: any;
            present?: string;
        }): Promise<void>;
    }
    import BaseEvent from "src/events/BaseEvent";
}
declare module "src/events/StopPresentingEvent" {
    export default StopPresentingEvent;
    class StopPresentingEvent extends BaseEvent {
        handle(): void;
    }
    import BaseEvent from "src/events/BaseEvent";
}
declare module "src/events/StopBroadcastsEvent" {
    export default StopBroadcastsEvent;
    class StopBroadcastsEvent extends PublicEvent {
    }
    import PublicEvent from "src/events/PublicEvent";
}
declare module "src/events/ClearFrontLayerEvent" {
    export default ClearFrontLayerEvent;
    class ClearFrontLayerEvent extends BaseEvent {
        handle(): void;
    }
    import BaseEvent from "src/events/BaseEvent";
}
declare module "src/events/RequestGuestUserEvent" {
    export default RequestGuestUserEvent;
    /**
     * Request a user from guest token.
     * use same error if meeting is locked due to backwards compatibility for mobile apps
     * error 423 Locked = meeting locked
     **/
    class RequestGuestUserEvent extends PublicEvent {
        handle(msg: any): Promise<any>;
    }
    import PublicEvent from "src/events/PublicEvent";
}
declare module "src/events/SessionTerminationEvent" {
    export default SessionTerminationEvent;
    class SessionTerminationEvent extends BaseEvent {
        handle(): void;
    }
    import BaseEvent from "src/events/BaseEvent";
}
declare module "src/events/ParticipantListUpdateEvent" {
    export default ParticipantListUpdateEvent;
    /**
     * We handle participants list update is separated in two actions: one to
     * add, one to remove. In order to keep it easy to handle, the user data is
     * fetched from api (or later received via websocket). Not to mess with
     * comApi current handling, we keep it here for a while.
     **/
    class ParticipantListUpdateEvent extends BaseEvent {
        getUser(id: any): Promise<any>;
    }
    import BaseEvent from "src/events/BaseEvent";
}
declare module "src/utils/scale" {
    export default scale;
    function scale(width: any, height: any, max: any): {
        width: number;
        height: number;
    };
}
declare module "src/utils/debounce" {
    export default debounce;
    /**
     * Returns a function, that, as long as it continues to be invoked, will not
     * be triggered. The function will be called after it stops being called for
     * N milliseconds. If `immediate` is passed, trigger the function on the
     * leading edge, instead of the trailing.
     *
     * @see https://davidwalsh.name/javascript-debounce-function
     *
     * @param {function} func - Function to be debounced
     * @param {number} wait - N milliseconds for execution
     * @param {boolean} [immediate] - If true, trigger on the leading edge, default false
     * @return {function} - debounced version of given function
     */
    function debounce(func: Function, wait: number, immediate?: boolean): Function;
}
declare module "src/CanvasMixer" {
    export default CanvasMixer;
    class CanvasMixer {
        constructor(canvas: any, stream: any);
        canvas: any;
        stream: any;
        camera: any;
        screen: any;
        canvasTrack: any;
        context: any;
        xPos: number;
        camSize: {
            width: number;
            height: number;
        };
        isCanvasCapture: boolean;
        draw(): Promise<void>;
        start(): void;
        stop(): void;
        onError(errorCallback: any): void;
        onRedraw(redrawCallback: any): void;
        setStream(newStream: any): void;
        setCamera(position: any, size: any): void;
        drawFrame(video: any, pos: any, size: any, isCanvasCapture: any, isScreenStream: any): void;
        calcSizesAndPositions(): void;
        bouncedDraw: Function;
        errorCallback: any;
        redrawCallback: any;
        screenStream: MediaStream;
        cameraStream: MediaStream;
        redrawQueued: boolean;
        cameraPosition: any;
        cameraSizeInWords: any;
        sizes: {
            screen: {
                width: any;
                height: any;
            };
            camera: {
                width: number;
                height: number;
            };
        };
        positions: {
            screen: {
                x: number;
                y: number;
            };
            camera: {
                x: number;
                y: number;
            };
        };
    }
}
declare module "src/events/MixerEvents" {
    export class StartMixerEvent extends BaseEvent {
        handle({ audio, video, canvas, screen, surface, onRedraw, changeStream, present }: {
            audio: any;
            video: any;
            canvas: any;
            screen?: boolean;
            surface: any;
            onRedraw: any;
            changeStream?: boolean;
            present?: string;
        }): void;
    }
    export class UpdateMixerEvent extends BaseEvent {
        handle({ position, size }: {
            position: any;
            size: any;
        }): void;
    }
    import BaseEvent from "src/events/BaseEvent";
}
declare module "src/VideoPlayer" {
    export default VideoPlayer;
    class VideoPlayer {
        constructor({ canvas, file, onReady, onDuration, onTimeUpdate, onEnd, performAction }: {
            canvas: any;
            file: any;
            onReady: any;
            onDuration: any;
            onTimeUpdate: any;
            onEnd: any;
            performAction: any;
        });
        ac: any;
        acOut: any;
        gainNode: any;
        timer: number;
        canvas: any;
        url: string;
        ctx: any;
        video: HTMLVideoElement;
        callback: {
            onReady: any;
            onDuration: any;
            onTimeUpdate: any;
            onEnd: any;
            performAction: any;
        };
        errorCallback: any;
        boundDrawVideoFrame: any;
        boundInitCanvasStream: any;
        isPlaying: boolean;
        blockTimeUpdate: boolean;
        micOnlyStream: MediaStream;
        userMediaStream: any;
        initTimeout: NodeJS.Timeout;
        invokationTimer: number;
        drawVideoFrame(): void;
        initVideo(): void;
        onVideoReady(): void;
        onVideoAction(type: any, value: any): Promise<void> | Promise<boolean>;
        onPlayAction(): Promise<boolean>;
        onPauseAction(): Promise<boolean>;
        onTimeAction(time: any): void;
        onVolumeAction(volume: any): void;
        onVideoPlay(): void;
        onVideoPause(): void;
        onVideoSeeked(): void;
        onVideoTimeUpdate(): void;
        onVideoError(): void;
        onVideoEnd(): void;
        initCanvasStream(): void;
        invokeStream(userMediaStream: any): MediaStream;
        isStreaming(): boolean;
        getMicOnlyStream(): MediaStream;
        onError(callback: any): void;
        destroy(): void;
    }
}
declare module "src/events/MediaEvents" {
    export class StartMediaEvent extends BaseEvent {
    }
    import BaseEvent from "src/events/BaseEvent";
}
declare module "src/events/LockMeetingEvent" {
    export default LockMeetingEvent;
    class LockMeetingEvent extends BaseEvent {
        handle(): void;
    }
    import BaseEvent from "src/events/BaseEvent";
}
declare module "src/events/TerminateMeetingEvent" {
    export default TerminateMeetingEvent;
    class TerminateMeetingEvent extends BaseEvent {
        handle(): void;
    }
    import BaseEvent from "src/events/BaseEvent";
}
declare module "src/events/KickUserEvent" {
    export default KickUserEvent;
    class KickUserEvent extends BaseEvent {
    }
    import BaseEvent from "src/events/BaseEvent";
}
declare module "src/events/VirtualBackgroundEvent" {
    export default VirtualBackgroundEvent;
    class VirtualBackgroundEvent extends BaseEvent {
    }
    import BaseEvent from "src/events/BaseEvent";
}
declare module "src/events/ScreenVideoChangeEvent" {
    export default ScreenVideoChangeEvent;
    class ScreenVideoChangeEvent extends BaseEvent {
        handle({ surface }: {
            surface: any;
        }): Promise<void>;
    }
    import BaseEvent from "src/events/BaseEvent";
}
declare module "src/events/ScreenVideoStoppedEvent" {
    export default ScreenVideoStoppedEvent;
    class ScreenVideoStoppedEvent extends BaseEvent {
        handle(): void;
    }
    import BaseEvent from "src/events/BaseEvent";
}
declare module "src/events/PresentationUpdateEvent" {
    export default PresentationUpdateEvent;
    class PresentationUpdateEvent extends PublicEvent {
    }
    import PublicEvent from "src/events/PublicEvent";
}
declare module "src/events/RequestPermalinkMeetingInfoEvent" {
    export default RequestPermalinkMeetingInfoEvent;
    /**
     * Request permalink meeting info from user or guest token.
     **/
    class RequestPermalinkMeetingInfoEvent extends PublicEvent {
    }
    import PublicEvent from "src/events/PublicEvent";
}
declare module "src/DeviceMonitor" {
    export default DeviceMonitor;
    class DeviceMonitor {
        tempAudioTrack: any;
        tempVideoTrack: any;
        audioTrack: any;
        videoTrack: any;
        audioEnded: NodeJS.Timeout;
        videoEnded: NodeJS.Timeout;
        defaultMic: any;
        boundOnAudioEnd: any;
        boundOnVideoEnd: any;
        boundOnAudioDeviceChange: any;
        listeners: any[];
        addAudioTrack(track: any): void;
        addVideoTrack(track: any): void;
        applyTempTracks(): void;
        discardTempTracks(): void;
        checkDefaultMic(): Promise<void>;
        onAudioDeviceChange(): Promise<void>;
        abortAudioDeviceChange(): void;
        onAudioEnd(): void;
        onVideoEnd(): void;
        onEvent(callback: any): void;
        emit(msg: any): void;
        clearTracks(): void;
        destroy(): void;
    }
}
declare module "src/PipCam" {
    export default PipCam;
    class PipCam {
        constructor(session: any);
        video: HTMLVideoElement;
        stream: any;
        canvasStream: MediaStream;
        vbgMixer: VirtualBackgroundMixer;
        deviceMonitor: DeviceMonitor;
        session: any;
        isActive: boolean;
        startTimer: NodeJS.Timeout;
        start(): Promise<void>;
        onError(error: any): void;
        updateCamera(): Promise<void>;
        initFakeStream(): void;
        initVideoAndPip(): Promise<void>;
        initCamera(): Promise<void>;
        onExitPip(): void;
        onVideoPause(video: any): void;
        onDeviceEvent({ type }: {
            type: any;
        }): void;
        stop(): Promise<void>;
        destroy(): Promise<void>;
    }
    import VirtualBackgroundMixer from "src/VirtualBackgroundMixer";
    import DeviceMonitor from "src/DeviceMonitor";
}
declare module "src/events/PipCamEvents" {
    export class StartPipCamEvent extends BaseEvent {
        handle(): void;
    }
    export class StopPipCamEvent extends BaseEvent {
        handle(): void;
    }
    export class UpdatePipCamEvent extends BaseEvent {
        handle(): void;
    }
    import BaseEvent from "src/events/BaseEvent";
}
declare module "src/events/DeviceEndEvents" {
    export class AudioDeviceEndEvent extends PublicEvent {
        handle(msg: any): Promise<void>;
    }
    export class VideoDeviceEndEvent extends PublicEvent {
        handle(msg: any): Promise<void>;
    }
    export class AllDevicesEndEvent extends PublicEvent {
        handle(msg: any): Promise<void>;
    }
    import PublicEvent from "src/events/PublicEvent";
}
declare module "src/EventHandler" {
    export default EventHandler;
    /**
     * Event Handler uses the connection credentials for the room and
     * the user to setup a (monitored) connection, start a session and
     * listen for any events.
     **/
    class EventHandler {
        listeners: any[];
        _eyeson: any;
        _session: any;
        _monitor: any;
        _connection: any;
        _rtConnection: any;
        /**
         * On receiving an event, notify all registered listeners.
         **/
        send(msg: any): void;
        destroy(): void;
        _api: any;
        set connection(con: any);
        get connection(): any;
        set rtConnection(con: any);
        get rtConnection(): any;
        set monitor(mon: any);
        get monitor(): any;
        set session(ses: any);
        get session(): any;
        set api(api: any);
        get api(): any;
        set rtData(data: any);
        get rtData(): any;
        _rtData: any;
        set eyeson(eyeson: any);
        get eyeson(): any;
        /**
         * Register a new listener.
         **/
        onReceive(callback: any): void;
        /**
         * Unregisters a listener or all listeners.
         **/
        removeListener(callback: any): void;
    }
}
declare module "src/SDPModifiers" {
    export function getModifiers(options: any): {
        active: ((sdp: any) => any)[];
        passive: ((sdp: any) => any)[];
    };
}
declare module "src/ConferenceSession" {
    export default ConferenceSession;
    /**
     * Conference Session is starting a session from active connection,
     * delegating events to registered listeners.
     **/
    class ConferenceSession {
        constructor(connection: any, comApi: any, options?: {});
        options: {};
        accepted: boolean;
        listeners: any[];
        restarting: boolean;
        connection: any;
        comApi: any;
        sipSession: any;
        startAttempts: number;
        maxStartAttempts: number;
        tryAuthUpdate: boolean;
        tryResume: boolean;
        tryWaitResume: boolean;
        resumeTimer: NodeJS.Timeout;
        waitResumeTimer: NodeJS.Timeout;
        /**
         * End a conference session.
         **/
        end(): void;
        /**
         * On receiving an event, notify all registered listeners.
         **/
        emit(msg: any): void;
        /**
         * Replace the active stream with newStream and emit 'stream_update' with the
         * new stream.
         *
         * In case of an error (as will be the case in current EDGE (May 2019))
         * report back the current streams.
         **/
        setStream(newStream: any): Promise<any>;
        /**
         * Before terminating the session, remove all listeners and stop all
         * streams.
         **/
        endSession(): void;
        /**
         * Init session and start stream.
         **/
        initSession(stream: any): void;
        /**
         * Forward failed event unless we attempt a recovery.
         **/
        handleFailed(reason: any): void;
        /**
         * Forward accept event, build expected message format.
         **/
        handleAccept(remoteStream: any): void;
        handleUnmute(track: any): void;
        /**
         * End the previously started session, but keep already registered listeners.
         **/
        restartSession(): boolean;
        /**
         * Conference session may recover from `failure` if a recovery for that
         * `failure` is known and its condition applies.
         **/
        tryRecoveryFrom(failure: any): boolean;
        /**
         * Depending on the state of the session, this function may send a CANCEL
         * request, a non-2xx final response, a BYE request, or even no request at
         * all.
         * https://sipjs.com/api/0.7.0/session/#terminateoptions
         **/
        terminateSession(): void;
        remoteDescriptionUpdate(sdpWrapper: any): void;
        get peerConnection(): any;
        get localStream(): any;
        get remoteStream(): any;
        get defaultRTCConstraints(): {
            offerToReceiveAudio: boolean;
            offerToReceiveVideo: boolean;
        };
        /**
         * Request stream and invoke session start.
         **/
        start(): void;
        initExternalStream(): void;
        externalStream: MediaStream;
        initVirtualBackground(): void;
        vbgMixer: VirtualBackgroundMixer;
        initDeviceMonitor(): void;
        deviceMonitor: DeviceMonitor;
        buildSessionOptions(stream: any): {
            stream: any;
            sendOnly: any;
            sendEncodings: any;
            codecSelection: any;
            receiveConstraints: any;
            SDPModifiers: {
                active: ((sdp: any) => any)[];
                passive: ((sdp: any) => any)[];
            };
            connection: any;
            handleAccept: (remoteStream: any) => void;
            handleUnmute: (track: any) => void;
            RTCConstraints: any;
            remoteDescriptionUpdate: (sdpWrapper: any) => void;
            mediaOptions: {
                audio: any;
                video: any;
            };
        };
        stopPresentingSet: boolean;
        /**
         * Trigger local track unmuted event.
         * Used to prevent iOS issue black video after incoming call.
         */
        onUnmute(stream: any): void;
        /**
         * Register a session monitor.
         **/
        setMonitor(monitor: any): void;
        monitor: any;
        /**
         * Once we have accepted the session, we need to adjust the video podium,
         * according to the current options.
         **/
        adjustVideoPodium(): void;
        /**
         * On Termination log to debug what happened.
         **/
        handleTermination(reason: any, code: any): void;
        /**
         * Forward exit event
         **/
        handleExit(): void;
        errorCodeName(key: any, name: any): string;
        /**
         * Register event listeners.
         **/
        onEvent(callback: any): void;
        /**
         * Transport a message over the connection.
         **/
        send(msg: any): any;
    }
    import VirtualBackgroundMixer from "src/VirtualBackgroundMixer";
    import DeviceMonitor from "src/DeviceMonitor";
}
declare module "src/utils/ConnectionStatistics" {
    export default ConnectionStatistics;
    class ConnectionStatistics {
        peerConnection: any;
        timer: NodeJS.Timeout;
        listeners: any[];
        history: any[];
        entry: {
            jitter: number;
            packetLoss: number;
            packetLossRecv: number;
            roundTripTime: number;
            nack: number;
            time: number;
            bitrateSend: number;
            bitrateRecv: number;
        };
        lastStat: {
            time: any;
            bytesSent: any;
            bytesReceived: any;
            audio: {
                out: {
                    packetsSent: any;
                    packetsLost: any;
                    bytesSent: any;
                };
                in: {
                    bytesReceived: any;
                    packetsReceived: any;
                    packetsLost: any;
                };
            };
            video: {
                out: {
                    packetsSent: any;
                    packetsLost: any;
                    bytesSent: any;
                    nackCount: any;
                };
                in: {
                    bytesReceived: any;
                    packetsReceived: any;
                    packetsLost: any;
                };
            };
        };
        boundPrintStats: any;
        init(peerConnection: any): void;
        printStats(): Promise<void>;
        getCurrentStatistics(): {
            jitter: number;
            packetLoss: number;
            packetLossRecv: number;
            roundTripTime: number;
            nack: number;
            bitrateSend: number;
            bitrateRecv: number;
            status: number;
        };
        onUpdate(listener: any): void;
        emit(statistics: any): void;
        destroy(): void;
    }
    namespace ConnectionStatistics {
        export { Status };
    }
    namespace Status {
        let NO_CONNECTION: number;
        let BAD: number;
        let OK: number;
        let GOOD: number;
    }
}
declare module "src/ConnectionMonitor" {
    export default ConnectionMonitor;
    /**
     * Connection Monitor informs about on and offline and ice state changes.
     * I.e. when the connection to the conf server (from a webRTC point of view)
     * is breaking up or degrading.
     **/
    class ConnectionMonitor {
        pc: any;
        statistics: ConnectionStatistics;
        listeners: any[];
        disconnectTimer: number;
        prevIceState: string;
        onOffline(): void;
        handleIceStateChange(event: any): void;
        handleConnectionStateChange(event: any): void;
        addEventListeners(): void;
        observe(peerConnection: any): void;
        destroy(): void;
        onEvent(listener: any): void;
        emit(msg: any): void;
    }
    import ConnectionStatistics from "src/utils/ConnectionStatistics";
}
declare module "src/ActionCableConnection" {
    export default ActionCableConnection;
    /**
     * Registers with provided token and room.
     **/
    class ActionCableConnection {
        constructor(uri: any);
        channels: {};
        onMessageHandler: (msg: any) => void;
        onReceived(msg: any): void;
        offMessage(): void;
        onConnected(): void;
        startSession(): void;
        onDisconnected(): void;
        cable: any;
        handleReconnect(): void;
        disconnectTimestamp: number;
        onMessage(onMessageHandler: any): void;
        defaultMessageHandler(msg: any): void;
        /**
         * msg has the format { channel: 'xyz', type: 'abc' }
         **/
        send({ channel, type }: {
            channel?: string;
            type?: string;
        }): void;
        close(): void;
    }
}
declare module "src/eyeson" {
    export default eyeson;
    const eyeson: Eyeson;
    /****** The following represents the public API, adapt with caution! *********/
    class Eyeson {
        /**
         * The room, user and links to be updated when fetched from the ComAPI.
         */
        config: {
            version: string;
            api: string;
            allowSafariSFU: boolean;
            screencapture: boolean;
            verbose: boolean;
            vbgScriptPath: string;
            hdCamera: boolean;
        };
        core: {
            eventHandler: EventHandler;
        };
        room: {};
        user: {};
        links: {};
        options: {
            widescreen: boolean;
        };
        /****** Public helper methods **********************************************/
        /**
         * Attach event listener
         *
         * @param {function} listener - Event listener
         */
        onEvent(listener: Function): void;
        /**
         * Remove event listener
         *
         * @param {function} [listener] - Event listener. Leave empty to remove all
         */
        offEvent(listener?: Function): void;
        /**
         * Prepare required core connections.
         *
         * @param {string} token - accessKey
         */
        connect(token: string): void;
        /**
         * Resolve permalink and prepare required core connections.
         *
         * @param {string} userToken - permalink user_token
         */
        connectPermalink(userToken: string): void;
        /**
         * @typedef {object} MediaOptions
         * @prop {boolean} [audio] - default true
         * @prop {boolean} [video] - default true
         * @prop {boolean} [eco] - default false
         * @prop {boolean} [audioPassthrough] - default false
         */
        /**
         * Join a session with supplied mediaOptions (audio/video).
         *
         * @param {MediaOptions} mediaOptions - Media options like audio and video
         */
        join(mediaOptions: {
            /**
             * - default true
             */
            audio?: boolean;
            /**
             * - default true
             */
            video?: boolean;
            /**
             * - default false
             */
            eco?: boolean;
            /**
             * - default false
             */
            audioPassthrough?: boolean;
        }): void;
        /**
         * Start an eyeson room meeting.
         *
         * @param {string} token - accessKey
         * @param {MediaOptions} [mediaOptions] - Media options like audio and video
         */
        start(token: string, mediaOptions?: {
            /**
             * - default true
             */
            audio?: boolean;
            /**
             * - default true
             */
            video?: boolean;
            /**
             * - default false
             */
            eco?: boolean;
            /**
             * - default false
             */
            audioPassthrough?: boolean;
        }): void;
        /**
         * Destroy and cleanup a session.
         */
        destroy(): void;
        /**
         * Receive an event from client.
         *
         * @param {object} msg - Event object with type parameter
         */
        send(msg: object): void;
        /**
         * When invoked repeatedly, will only actually call the original function at
         * most once per every wait milliseconds.
         *
         * @param {object} msg - Event object with type parameter
         * @return {function} - A new, throttled send function
         */
        throttledSend(msg: object): Function;
        _throttledSend: Function;
        /**
         * Create a new instance
         *
         * @return {Eyeson} - A new separate Eyeson session
         */
        createInstance(): Eyeson;
    }
    import EventHandler from "src/EventHandler";
}
declare module "src/utils/GiphyApi" {
    export default GiphyApi;
    class GiphyApi {
        constructor(roomUrl: any);
        roomUrl: any;
        search(query: any): Promise<any>;
        random(): Promise<any>;
        trending(): Promise<any[]>;
        staff(): Promise<any>;
        randomForQuery(query: any): Promise<any>;
        request(url: any): Promise<any>;
    }
}
declare module "src/SoundMeter" {
    export default SoundMeter;
    /**
     * Sound Meter that generates a number correlated to audio volume. The meter
     * itself displays nothing, but it makes the instantaneous and time-decaying
     * volumes available for inspection. It also reports on the fraction of samples
     * that were at or near the top of the measurement range.
     */
    class SoundMeter {
        level: number;
        instant: number;
        silenceDuration: number;
        intervalCounter: number;
        track: any;
        context: any;
        source: any;
        analyser: any;
        volumes: Uint8Array<any>;
        listener: any[];
        timer: NodeJS.Timeout;
        errorTimer: NodeJS.Timeout;
        boundOnTrackEnded: any;
        initError: boolean;
        /**
         * Initialize audio context and prepare script processor to read input
         * channel data.
         */
        init(): void;
        /**
         * Connect to a media stream.
         *
         * @param {MediaStream} stream - MediaStream including the audio track
         * @return {SoundMeter} - SoundMeter instance
         */
        connectToSource(stream: MediaStream): SoundMeter;
        running: boolean;
        /**
         * Read audio level. Avoids triggering a re-render of the device-dialog
         * when the change is below 1% which wouldn't be noticable anyways.
         *
         * NOTE: When an USB Microphone is abruptly disconnected. The
         * intervalCounter reacts: when switching to a different mic, it seems to
         * take a bit to not return 0.00 for the audio level.
         */
        analyse(): void;
        resetSilenceCounter(): void;
        /**
         * Stop read interval and disconnect from stream.
         */
        stop(): void;
        /**
         * Add event listener
         *
         * @param {function} listener - Callback on update
         */
        onUpdate(listener: Function): void;
        /**
         * Remove all listeners
         */
        offUpdate(): void;
        onTrackEnded(): void;
        emit(message: any): void;
    }
}
declare module "src/utils/Geolocation" {
    export default _instance;
    namespace _instance {
        export { getPermissionStatus };
        export { getCurrentPosition };
        export { linkContainsCoordinates };
        export { generateLinkFromCoordinates };
        export { parseCoordinatesFromLink };
    }
    /**
     * getPermissionStatus
     * @returns {Promise<"prompt"|"denied"|"granted">}
     */
    function getPermissionStatus(): Promise<"prompt" | "denied" | "granted">;
    /**
     * getCurrentPosition
     * Timeout is 12s
     * @returns {Promise<GeolocationCoordinates>} - see https://developer.mozilla.org/en-US/docs/Web/API/GeolocationCoordinates
     */
    function getCurrentPosition(): Promise<GeolocationCoordinates>;
    /**
     * linkContainsCoordinates
     * @param {string} link
     * @returns {boolean}
     */
    function linkContainsCoordinates(link: string): boolean;
    /**
     * generateLinkFromCoordinates
     * @param {number|string} latitude
     * @param {number|string} longitude
     * @returns {{ what3words: string, googleMaps: string, openStreetMap: string, bingMaps: string, wegoHere: string }}
     */
    function generateLinkFromCoordinates(latitude: number | string, longitude: number | string): {
        what3words: string;
        googleMaps: string;
        openStreetMap: string;
        bingMaps: string;
        wegoHere: string;
    };
    /**
     * parseCoordinatesFromLink
     * @param {string} link
     * @returns {{ latitude: number, longitude: number } | null}
     */
    function parseCoordinatesFromLink(link: string): {
        latitude: number;
        longitude: number;
    } | null;
}
declare module "src/utils/WebHIDManager" {
    export default WebHIDManager;
    /**
     * WebHIDManager. Handles call control devices and synchronises call and mute
     * states.
     * Attention! Do not call constructor - use static WebHIDManager.initialize
     *
     * @see https://docs.eyeson.com/blog/call-control-devices
     */
    class WebHIDManager {
        /**
         * WebHIDManager.supported
         *
         * @return {boolean} - support in current browser and frame
         */
        static get supported(): boolean;
        /**
         * Initialize WebHIDManager instance.
         *
         * @param {object} [options] - Currently just default { verbose: true }
         * @return {Promise<WebHIDManager>}
         */
        static initialize(options?: object): Promise<WebHIDManager>;
        constructor(options: any);
        status: {
            call: {
                active: boolean;
            };
            mute: {
                active: boolean;
            };
        };
        verbose: any;
        devices: Map<any, any>;
        listeners: any[];
        channel: BroadcastChannel;
        boundOnInputReport: any;
        boundOnBeforeUnload: any;
        boundOnDeviceConnect: any;
        boundOnDeviceDisconnect: any;
        restrictMultipleInstances(): Promise<any>;
        blocked: boolean;
        /**
         * Register event handler
         *
         * @param {function} fn - Callback event handler
         */
        onEvent(fn: Function): void;
        /**
         * Remove event handler
         *
         * @param {function|undefined} fn - Callback event handler - leave empty to remove all handler
         */
        offEvent(fn: Function | undefined): void;
        emit(message: any): void;
        /**
         * Set mute active state. Synchronizes all devices
         *
         * @param {boolean} active - Mute active state
         */
        setMuteActive(active: boolean): void;
        /**
         * Set call active state. Synchronizes all devices
         *
         * @param {boolean} active - Call active state
         */
        setCallActive(active: boolean): void;
        initDeviceList(): Promise<void>;
        /**
         * Emit "devicelist" event
         */
        emitDeviceList(): void;
        /**
         * Trigger browser pair device request.
         *
         * @return {Promise}
         */
        pairDeviceRequest(): Promise<any>;
        initDevice(device: any): Promise<boolean>;
        onInputReport({ device, reportId, data }: {
            device: any;
            reportId: any;
            data: any;
        }): void;
        onStatusChange(type: any, status: any, deviceStatus: any, deviceInfoType: any, device: any): void;
        onDeviceConnect({ device }: {
            device: any;
        }): Promise<void>;
        onDeviceDisconnect({ device }: {
            device: any;
        }): void;
        /**
         *
         * @param {string} id - id of paired device "xxxx:xxxx"
         * @return {Promise}
         */
        removeDevice(id: string): Promise<any>;
        onBeforeUnload(): void;
        /**
         * Destroy WebHIDManager instance.
         */
        destroy(): void;
    }
}
declare module "src/SystemPressureMonitor" {
    export default SystemPressureMonitor;
    class SystemPressureMonitor {
        /**
         * @param {{ sampleInterval: number }} [options]
         */
        constructor(options?: {
            sampleInterval: number;
        });
        _listener: any[];
        _monitor: any;
        _running: boolean;
        state: any;
        sampleInterval: number;
        onUpdate(listener: any): void;
        offUpdate(listener: any): void;
        _emit(records: any): void;
        start(): Promise<void>;
        stop(): void;
        destroy(): void;
    }
}
declare module "eyeson" {
    export default eyeson;
    import Logger from "src/Logger";
    import MicMixer from "src/MicMixer";
    import GiphyApi from "src/utils/GiphyApi";
    import debounce from "src/utils/debounce";
    import throttle from "src/utils/throttle";
    import immediate from "src/utils/immediate";
    import SoundMeter from "src/SoundMeter";
    import Geolocation from "src/utils/Geolocation";
    import LocalStorage from "src/LocalStorage";
    import * as StreamHelpers from "src/utils/StreamHelpers";
    import DeviceManager from "src/DeviceManager";
    import WebHIDManager from "src/utils/WebHIDManager";
    import FeatureDetector from "src/FeatureDetector";
    import FullscreenHelper from "src/FullscreenHelper";
    import MediaStreamBuilder from "src/MediaStreamBuilder";
    import ConnectionStatistics from "src/utils/ConnectionStatistics";
    import SystemPressureMonitor from "src/SystemPressureMonitor";
    import eyeson from "src/eyeson";
    export { Logger, MicMixer, GiphyApi, debounce, throttle, immediate, SoundMeter, Geolocation, LocalStorage, StreamHelpers, DeviceManager, WebHIDManager, FeatureDetector, FullscreenHelper, MediaStreamBuilder, ConnectionStatistics, SystemPressureMonitor };
}