import * as i0 from '@angular/core';
import { OnInit, OnDestroy, DoCheck, ElementRef, EventEmitter, QueryList, ChangeDetectorRef, AfterContentInit } from '@angular/core';
import { Subscription, Observable, Subject } from 'rxjs';
import * as i4 from '@angular/common';

declare class VgCuePointsDirective implements OnInit, OnDestroy, DoCheck {
    ref: ElementRef;
    onEnterCuePoint: EventEmitter<any>;
    onUpdateCuePoint: EventEmitter<any>;
    onExitCuePoint: EventEmitter<any>;
    onCompleteCuePoint: EventEmitter<any>;
    subscriptions: Subscription[];
    cuesSubscriptions: Subscription[];
    onLoad$: Observable<any>;
    onEnter$: Observable<any>;
    onExit$: Observable<any>;
    totalCues: number;
    constructor(ref: ElementRef);
    ngOnInit(): void;
    onLoad(event: any): void;
    updateCuePoints(cues: TextTrackCue[]): void;
    onEnter(event: any): void;
    onExit(event: any): void;
    ngDoCheck(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<VgCuePointsDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<VgCuePointsDirective, "[vgCuePoints]", never, {}, { "onEnterCuePoint": "onEnterCuePoint"; "onUpdateCuePoint": "onUpdateCuePoint"; "onExitCuePoint": "onExitCuePoint"; "onCompleteCuePoint": "onCompleteCuePoint"; }, never, never, false, never>;
}

interface IPlayable {
    id: string;
    elem: any;
    time: any;
    buffer: any;
    track?: any;
    canPlay: boolean;
    canPlayThrough: boolean;
    isMetadataLoaded: boolean;
    isWaiting: boolean;
    isCompleted: boolean;
    isLive: boolean;
    textTracks: TextTrackList;
    state: string;
    subscriptions: IMediaSubscriptions;
    duration: number;
    currentTime: number;
    play: Function;
    pause: Function;
    addTextTrack?: Function;
    dispatchEvent?: Function;
}
interface IMediaSubscriptions {
    abort: Observable<any>;
    bufferDetected: Subject<boolean>;
    canPlay: Observable<any>;
    canPlayThrough: Observable<any>;
    durationChange: Observable<any>;
    emptied: Observable<any>;
    encrypted: Observable<any>;
    ended: Observable<any>;
    error: Observable<any>;
    loadedData: Observable<any>;
    loadedMetadata: Observable<any>;
    loadStart: Observable<any>;
    pause: Observable<any>;
    play: Observable<any>;
    playing: Observable<any>;
    progress: Observable<any>;
    rateChange: Observable<any>;
    seeked: Observable<any>;
    seeking: Observable<any>;
    stalled: Observable<any>;
    suspend: Observable<any>;
    timeUpdate: Observable<any>;
    volumeChange: Observable<any>;
    waiting: Observable<any>;
    startAds: Observable<any>;
    endAds: Observable<any>;
}

interface MSMediaKeyNeededEvent extends Event {
    readonly initData: Uint8Array | null;
}

interface AudioTrack {
    enabled: boolean;
    readonly id: string;
    kind: string;
    readonly label: string;
    language: string;
    readonly sourceBuffer: SourceBuffer | null;
}
interface AudioTrackListEventMap {
    addtrack: TrackEvent;
    change: Event;
    removetrack: TrackEvent;
}
/** Used to represent a list of the audio tracks contained within a given HTML media element, with each track represented by a separate AudioTrack object in the list. */
interface AudioTrackList extends EventTarget {
    readonly length: number;
    onaddtrack: ((this: AudioTrackList, ev: TrackEvent) => any) | null;
    onchange: ((this: AudioTrackList, ev: Event) => any) | null;
    onremovetrack: ((this: AudioTrackList, ev: TrackEvent) => any) | null;
    getTrackById(id: string): AudioTrack | null;
    item(index: number): AudioTrack;
    addEventListener<K extends keyof AudioTrackListEventMap>(type: K, listener: (this: AudioTrackList, ev: AudioTrackListEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
    removeEventListener<K extends keyof AudioTrackListEventMap>(type: K, listener: (this: AudioTrackList, ev: AudioTrackListEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
    [index: number]: AudioTrack;
}
/** A single video track from a <video> element. */
interface VideoTrack {
    readonly id: string;
    kind: string;
    readonly label: string;
    language: string;
    selected: boolean;
    readonly sourceBuffer: SourceBuffer | null;
}
interface VideoTrackListEventMap {
    addtrack: TrackEvent;
    change: Event;
    removetrack: TrackEvent;
}
/** Used to represent a list of the video tracks contained within a <video> element, with each track represented by a separate VideoTrack object in the list. */
interface VideoTrackList extends EventTarget {
    readonly length: number;
    onaddtrack: ((this: VideoTrackList, ev: TrackEvent) => any) | null;
    onchange: ((this: VideoTrackList, ev: Event) => any) | null;
    onremovetrack: ((this: VideoTrackList, ev: TrackEvent) => any) | null;
    readonly selectedIndex: number;
    getTrackById(id: string): VideoTrack | null;
    item(index: number): VideoTrack;
    addEventListener<K extends keyof VideoTrackListEventMap>(type: K, listener: (this: VideoTrackList, ev: VideoTrackListEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
    removeEventListener<K extends keyof VideoTrackListEventMap>(type: K, listener: (this: VideoTrackList, ev: VideoTrackListEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
    [index: number]: VideoTrack;
}

interface IMediaElement {
    /**
     * Returns the id of the element.
     */
    id: string;
    /**
     * Returns the node name. Only available on native HTML tags.
     */
    readonly nodeName?: string;
    /**
     * Returns the node element. Only available on Angular classes.
     */
    readonly elem?: any;
    /**
     * Returns an AudioTrackList object with the audio tracks for a given video element.
     */
    readonly audioTracks: AudioTrackList;
    /**
     * Gets or sets a value that indicates whether to start playing the media automatically.
     */
    autoplay: boolean;
    /**
     * Gets a collection of buffered time ranges.
     */
    readonly buffered: TimeRanges;
    /**
     * Gets or sets a flag that indicates whether the client provides a set of controls for
     * the media (in case the developer does not include controls for the player).
     */
    controls: boolean;
    crossOrigin: string | null;
    /**
     * Gets the address or URL of the current media resource that is selected by IHTMLMediaElement.
     */
    readonly currentSrc: string;
    /**
     * Gets or sets the current playback position, in seconds.
     */
    currentTime: number;
    defaultMuted: boolean;
    /**
     * Gets or sets the default playback rate when the user is not using fast forward or reverse for a video or audio resource.
     */
    defaultPlaybackRate: number;
    /**
     * Returns the duration in seconds of the current media resource. A NaN value is returned if duration
     * is not available, or Infinity if the media resource is streaming.
     */
    readonly duration: number;
    /**
     * Gets information about whether the playback has ended or not.
     */
    readonly ended: boolean;
    /**
     * Returns an object representing the current error state of the audio or video element.
     */
    readonly error: MediaError;
    /**
     * Gets or sets a flag to specify whether playback should restart after it completes.
     */
    loop: boolean;
    readonly mediaKeys: MediaKeys | null;
    /**
     * Specifies the purpose of the audio or video media, such as background audio or alerts.
     */
    msAudioCategory: string;
    /**
     * Specifies the output device id that the audio will be sent to.
     */
    msAudioDeviceType: string;
    /**
     * Gets or sets whether the DLNA PlayTo device is available.
     */
    msPlayToDisabled: boolean;
    /**
     * Gets or sets the path to the preferred media source. This enables the Play To target device to
     * stream the media content, which can be DRM protected, from a different location, such as a cloud media server.
     */
    msPlayToPreferredSourceUri: string;
    /**
     * Gets or sets the primary DLNA PlayTo device.
     */
    msPlayToPrimary: boolean;
    /**
     * Gets the source associated with the media element for use by the PlayToManager.
     */
    readonly msPlayToSource: any;
    /**
     * Specifies whether or not to enable low-latency playback on the media element.
     */
    msRealTime: boolean;
    /**
     * Gets or sets a flag that indicates whether the audio (either audio or the audio track on video media) is muted.
     */
    muted: boolean;
    /**
     * Gets the current network activity for the element.
     */
    readonly networkState: number;
    onencrypted: (this: HTMLMediaElement, ev: MediaEncryptedEvent) => any;
    onmsneedkey: (this: HTMLMediaElement, ev: MSMediaKeyNeededEvent) => any;
    /**
     * Gets a flag that specifies whether playback is paused.
     */
    readonly paused: boolean;
    /**
     * Gets or sets the current rate of speed for the media resource to play. This speed is
     * expressed as a multiple of the normal speed of the media resource.
     */
    playbackRate: number;
    /**
     * Gets TimeRanges for the current media resource that has been played.
     */
    readonly played: TimeRanges;
    /**
     * Gets or sets the current playback position, in seconds.
     */
    preload: string;
    readyState: number;
    /**
     * Returns a TimeRanges object that represents the ranges of the current media resource that can be seeked.
     */
    readonly seekable: TimeRanges;
    /**
     * Gets a flag that indicates whether the the client is currently moving to a new playback position in the media resource.
     */
    readonly seeking: boolean;
    /**
     * The address or URL of the a media resource that is to be considered.
     */
    src: string;
    srcObject: MediaStream | null;
    readonly textTracks: TextTrackList;
    readonly videoTracks: VideoTrackList;
    /**
     * Gets or sets the volume level for audio portions of the media element.
     */
    volume: number;
    readonly HAVE_CURRENT_DATA: number;
    readonly HAVE_ENOUGH_DATA: number;
    readonly HAVE_FUTURE_DATA: number;
    readonly HAVE_METADATA: number;
    readonly HAVE_NOTHING: number;
    readonly NETWORK_EMPTY: number;
    readonly NETWORK_IDLE: number;
    readonly NETWORK_LOADING: number;
    readonly NETWORK_NO_SOURCE: number;
    addTextTrack(kind: string, label?: string, language?: string): TextTrack;
    /**
     * Returns a string that specifies whether the client can play a given media resource type.
     */
    canPlayType(type: string): string;
    /**
     * Resets the audio or video object and loads a new media resource.
     */
    load(): void;
    /**
     * Clears all effects from the media pipeline.
     */
    msClearEffects(): void;
    msGetAsCastingSource(): any;
    /**
     * Inserts the specified audio effect into media pipeline.
     */
    msInsertAudioEffect(activatableClassId: string, effectRequired: boolean, config?: any): void;
    /**
     * Specifies the media protection manager for a given media pipeline.
     */
    msSetMediaProtectionManager(mediaProtectionManager?: any): void;
    /**
     * Pauses the current playback and sets paused to TRUE. This can be used to test whether the media is
     * playing or paused. You can also use the pause or play events to tell whether the media is playing or not.
     */
    pause(): void;
    /**
     * Loads and starts playback of a media resource.
     */
    play(): Promise<any>;
    setMediaKeys(mediaKeys: MediaKeys | null): Promise<void>;
    addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
}

declare class VgFullscreenApiService {
    polyfill: any;
    onchange: string;
    onerror: string;
    nativeFullscreen: boolean;
    isFullscreen: boolean;
    isAvailable: boolean;
    videogularElement: HTMLElement;
    medias: QueryList<VgMediaDirective>;
    fsChangeSubscription: Subscription;
    onChangeFullscreen: EventEmitter<any>;
    constructor();
    init(elem: HTMLElement, medias: QueryList<VgMediaDirective>): void;
    onFullscreenChange(): void;
    toggleFullscreen(element?: any): Promise<void>;
    request(elem: any): Promise<void>;
    enterElementInFullScreen(elem: any): Promise<void>;
    exit(): Promise<void>;
    static ɵfac: i0.ɵɵFactoryDeclaration<VgFullscreenApiService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<VgFullscreenApiService>;
}

declare class VgApiService {
    medias: {};
    videogularElement: any;
    playerReadyEvent: EventEmitter<VgApiService>;
    isPlayerReady: boolean;
    fsAPI: VgFullscreenApiService;
    constructor();
    onPlayerReady(fsAPI: VgFullscreenApiService): void;
    getDefaultMedia(): IPlayable;
    getMasterMedia(): IPlayable;
    isMasterDefined(): boolean;
    getMediaById(id?: string): IPlayable;
    play(): void;
    pause(): void;
    get duration(): any;
    set currentTime(seconds: any);
    get currentTime(): any;
    set state(state: any);
    get state(): any;
    set volume(volume: any);
    get volume(): any;
    set playbackRate(rate: any);
    get playbackRate(): any;
    get canPlay(): any;
    get canPlayThrough(): any;
    get isMetadataLoaded(): any;
    get isWaiting(): any;
    get isCompleted(): any;
    get isLive(): any;
    get isMaster(): any;
    get time(): any;
    get buffer(): any;
    get buffered(): any;
    get subscriptions(): any;
    get textTracks(): any;
    seekTime(value: number, byPercent?: boolean): void;
    $$seek(media: IPlayable, value: number, byPercent?: boolean): void;
    addTextTrack(type: string, label?: string, language?: string): void;
    $$addTextTrack(media: IPlayable, type: string, label?: string, language?: string): void;
    $$getAllProperties(property: string): any;
    $$setAllProperties(property: string, value: any): void;
    registerElement(elem: HTMLElement): void;
    registerMedia(media: IPlayable): void;
    unregisterMedia(media: IPlayable): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<VgApiService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<VgApiService>;
}

declare class VgMediaDirective implements OnInit, OnDestroy, IPlayable {
    private api;
    private ref;
    elem: any;
    vgMedia: IMediaElement;
    vgMaster: boolean;
    state: string;
    time: any;
    buffer: any;
    track: any;
    subscriptions: IMediaSubscriptions | any;
    canPlay: boolean;
    canPlayThrough: boolean;
    isMetadataLoaded: boolean;
    isWaiting: boolean;
    isCompleted: boolean;
    isLive: boolean;
    isBufferDetected: boolean;
    checkInterval: number;
    currentPlayPos: number;
    lastPlayPos: number;
    specifiedDuration: number;
    checkBufferSubscription: any;
    syncSubscription: Subscription;
    canPlayAllSubscription: any;
    playAtferSync: boolean;
    mutationObs: Subscription;
    canPlayObs: Subscription;
    canPlayThroughObs: Subscription;
    loadedMetadataObs: Subscription;
    waitingObs: Subscription;
    progressObs: Subscription;
    endedObs: Subscription;
    playingObs: Subscription;
    playObs: Subscription;
    pauseObs: Subscription;
    timeUpdateObs: Subscription;
    volumeChangeObs: Subscription;
    errorObs: Subscription;
    bufferDetected: Subject<boolean>;
    playPromise: Promise<any>;
    constructor(api: VgApiService, ref: ChangeDetectorRef);
    ngOnInit(): void;
    prepareSync(): void;
    startSync(): void;
    onMutation(mutations: Array<MutationRecord>): void;
    loadMedia(): void;
    play(): Promise<any>;
    pause(): void;
    get id(): any;
    get duration(): number;
    set currentTime(seconds: number);
    get currentTime(): number;
    set volume(volume: number);
    get volume(): number;
    set playbackRate(rate: number);
    get playbackRate(): number;
    get buffered(): TimeRanges;
    get textTracks(): TextTrackList;
    onCanPlay(event: any): void;
    onCanPlayThrough(event: any): void;
    onLoadMetadata(event: any): void;
    onWait(event: any): void;
    onComplete(event: any): void;
    onStartPlaying(event: any): void;
    onPlay(event: any): void;
    onPause(event: any): void;
    onTimeUpdate(event: any): void;
    onProgress(event: any): void;
    onVolumeChange(event: any): void;
    onError(event: any): void;
    bufferCheck(): void;
    startBufferCheck(): void;
    stopBufferCheck(): void;
    seekTime(value: number, byPercent?: boolean): void;
    addTextTrack(type: string, label?: string, language?: string, mode?: 'disabled' | 'hidden' | 'showing'): TextTrack;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<VgMediaDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<VgMediaDirective, "[vgMedia]", never, { "vgMedia": { "alias": "vgMedia"; "required": false; }; "vgMaster": { "alias": "vgMaster"; "required": false; }; }, {}, never, never, false, never>;
}

declare class VgControlsHiddenService {
    isHidden: Observable<boolean>;
    private isHiddenSubject;
    constructor();
    state(hidden: boolean): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<VgControlsHiddenService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<VgControlsHiddenService>;
}

declare class VgPlayerComponent implements AfterContentInit, OnDestroy {
    api: VgApiService;
    fsAPI: VgFullscreenApiService;
    private controlsHidden;
    elem: HTMLElement;
    isFullscreen: boolean;
    isNativeFullscreen: boolean;
    areControlsHidden: boolean;
    zIndex: string;
    onPlayerReady: EventEmitter<VgApiService>;
    onMediaReady: EventEmitter<any>;
    medias: QueryList<VgMediaDirective>;
    subscriptions: Subscription[];
    constructor(ref: ElementRef, api: VgApiService, fsAPI: VgFullscreenApiService, controlsHidden: VgControlsHiddenService);
    ngAfterContentInit(): void;
    onChangeFullscreen(fsState: boolean): void;
    onHideControls(hidden: boolean): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<VgPlayerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<VgPlayerComponent, "vg-player", never, {}, { "onPlayerReady": "onPlayerReady"; "onMediaReady": "onMediaReady"; }, ["medias"], ["*"], false, never>;
}

declare class VgCoreModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<VgCoreModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<VgCoreModule, [typeof VgCuePointsDirective, typeof VgMediaDirective, typeof VgPlayerComponent], [typeof i4.CommonModule], [typeof VgCuePointsDirective, typeof VgMediaDirective, typeof VgPlayerComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<VgCoreModule>;
}

interface BitrateOptions {
    qualityIndex: number;
    width: number;
    height: number;
    bitrate: number;
    mediaType: string;
    label?: string;
}

interface IDRMLicenseServer {
    [index: string]: {
        serverURL: string;
    };
}

interface IHLSConfig {
    abrController: () => void;
    fLoader: () => void;
    fetchSetup: () => void;
    loader: () => void;
    pLoader: () => void;
    timelineController: () => void;
    xhrSetup: () => void;
    startLevel: number;
    defaultAudioCodec: string;
    autoStartLoad: boolean;
    startPosition: number;
    capLevelToPlayerSize: boolean;
    debug: boolean;
    initialLiveManifestSize: number;
    maxBufferLength: number;
    maxMaxBufferLength: number;
    maxBufferSize: number;
    maxBufferHole: number;
    maxSeekHole: number;
    seekHoleNudgeDuration: number;
    maxFragLookUpTolerance: number;
    liveSyncDurationCount: number;
    liveMaxLatencyDurationCount: number;
    enableWorker: boolean;
    enableSoftwareAES: boolean;
    manifestLoadingTimeOut: number;
    manifestLoadingMaxRetry: number;
    manifestLoadingRetryDelay: number;
    manifestLoadingMaxRetryTimeout: number;
    levelLoadingTimeOut: number;
    levelLoadingMaxRetry: number;
    levelLoadingRetryDelay: number;
    levelLoadingMaxRetryTimeout: number;
    fragLoadingTimeOut: number;
    fragLoadingMaxRetry: number;
    fragLoadingRetryDelay: number;
    fragLoadingMaxRetryTimeout: number;
    startFragPrefech: boolean;
    appendErrorMaxRetry: number;
    enableCEA708Captions: boolean;
    stretchShortVideoTrack: boolean;
    forceKeyFrameOnDiscontinuity: boolean;
    abrEwmaFastLive: number;
    abrEwmaSlowLive: number;
    abrEwmaFastVoD: number;
    abrEwmaSlowVoD: number;
    abrEwmaDefaultEstimate: number;
    abrBandWidthFactor: number;
    abrBandWidthUpFactor: number;
    minAutoBitrate: number;
}

declare class VgMediaElement implements IMediaElement {
    id: string;
    elem: any;
    get audioTracks(): AudioTrackList;
    autoplay: boolean;
    buffered: TimeRanges;
    controls: boolean;
    crossOrigin: string | any;
    currentSrc: string;
    currentTime: number;
    defaultMuted: boolean;
    defaultPlaybackRate: number;
    duration: number;
    ended: boolean;
    error: MediaError;
    loop: boolean;
    mediaKeys: MediaKeys | any;
    msAudioCategory: string;
    msAudioDeviceType: string;
    msPlayToDisabled: boolean;
    msPlayToPreferredSourceUri: string;
    msPlayToPrimary: boolean;
    msPlayToSource: any;
    msRealTime: boolean;
    muted: boolean;
    networkState: number;
    onencrypted: (ev: MediaEncryptedEvent) => any;
    onmsneedkey: (ev: MSMediaKeyNeededEvent) => any;
    paused: boolean;
    playbackRate: number;
    played: TimeRanges;
    preload: string;
    readyState: number;
    seekable: TimeRanges;
    seeking: boolean;
    src: string;
    srcObject: MediaStream | any;
    textTracks: TextTrackList;
    videoTracks: VideoTrackList;
    volume: number;
    HAVE_CURRENT_DATA: number;
    HAVE_ENOUGH_DATA: number;
    HAVE_FUTURE_DATA: number;
    HAVE_METADATA: number;
    HAVE_NOTHING: number;
    NETWORK_EMPTY: number;
    NETWORK_IDLE: number;
    NETWORK_LOADING: number;
    NETWORK_NO_SOURCE: number;
    addTextTrack(kind: string, label?: string, language?: string): TextTrack;
    canPlayType(type: string): string;
    load(): void;
    msClearEffects(): void;
    msGetAsCastingSource(): any;
    msInsertAudioEffect(_activatableClassId: string, _effectRequired: boolean, _config?: any): void;
    msSetMediaProtectionManager(mediaProtectionManager?: any): void;
    pause(): void;
    play(): Promise<any>;
    setMediaKeys(mediaKeys: MediaKeys | any): Promise<void>;
    addEventListener(_type: string, _listener: EventListenerOrEventListenerObject, _useCapture?: boolean): void;
}

declare class VgUtilsService {
    /**
     * Inspired by Paul Irish
     * https://gist.github.com/paulirish/211209
     */
    static getZIndex(): number;
    static isMobileDevice(): boolean;
    static isiOSDevice(): boolean;
    static isIpadOS(): boolean;
    static isCordova(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<VgUtilsService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<VgUtilsService>;
}

declare class VgEvents {
    static VG_ABORT: string;
    static VG_CAN_PLAY: string;
    static VG_CAN_PLAY_THROUGH: string;
    static VG_DURATION_CHANGE: string;
    static VG_EMPTIED: string;
    static VG_ENCRYPTED: string;
    static VG_ENDED: string;
    static VG_ERROR: string;
    static VG_LOADED_DATA: string;
    static VG_LOADED_METADATA: string;
    static VG_LOAD_START: string;
    static VG_PAUSE: string;
    static VG_PLAY: string;
    static VG_PLAYING: string;
    static VG_PROGRESS: string;
    static VG_RATE_CHANGE: string;
    static VG_SEEK: string;
    static VG_SEEKED: string;
    static VG_SEEKING: string;
    static VG_STALLED: string;
    static VG_SUSPEND: string;
    static VG_TIME_UPDATE: string;
    static VG_VOLUME_CHANGE: string;
    static VG_WAITING: string;
    static VG_LOAD: string;
    static VG_ENTER: string;
    static VG_EXIT: string;
    static VG_START_ADS: string;
    static VG_END_ADS: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<VgEvents, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<VgEvents>;
}

declare class VgStates {
    static VG_ENDED: string;
    static VG_PAUSED: string;
    static VG_PLAYING: string;
    static VG_LOADING: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<VgStates, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<VgStates>;
}

export { VgApiService, VgControlsHiddenService, VgCoreModule, VgCuePointsDirective, VgEvents, VgFullscreenApiService, VgMediaDirective, VgMediaElement, VgPlayerComponent, VgStates, VgUtilsService };
export type { AudioTrack, AudioTrackList, AudioTrackListEventMap, BitrateOptions, IDRMLicenseServer, IHLSConfig, IMediaElement, IMediaSubscriptions, IPlayable, MSMediaKeyNeededEvent, VideoTrack, VideoTrackList, VideoTrackListEventMap };