/** @internal */
declare interface ActiveLiveStreamTime {
    startTime: number;
    endTime: number;
}

declare type AdapterDataConfig = {
    [key: string]: {
        value: string;
        objectType?: string;
    };
};

declare class BaseProvider<MI> {
    private _partnerId;
    private _widgetId?;
    protected _ks: string;
    private _uiConfId?;
    _dataLoader: DataLoaderManager;
    private _playerVersion;
    _logger: any;
    _referrer?: string;
    protected _isAnonymous: boolean | undefined;
    protected _clientTag: string | undefined;
    _networkRetryConfig: ProviderNetworkRetryParameters;
    get partnerId(): number;
    get widgetId(): string;
    get defaultWidgetId(): string;
    get uiConfId(): number | undefined;
    get ks(): string;
    set ks(value: string);
    get playerVersion(): string;
    get isAnonymous(): boolean | undefined;
    get clientTag(): string | undefined;
    constructor(options: ProviderOptionsObject, playerVersion: string);
    getMediaConfig(mediaInfo: MI): Promise<ProviderMediaConfigObject>;
    getPlaylistConfig(playlistInfo: ProviderPlaylistInfoObject): Promise<ProviderPlaylistObject>;
    getEntryListConfig(entryListInfo: ProviderEntryListObject): Promise<ProviderPlaylistObject>;
    protected _verifyHasSources(sources: ProviderMediaConfigSourcesObject): void;
    get LogLevel(): LogLevelType;
    getLogLevel(name?: string): any;
    setLogLevel(level: any, name?: string): void;
}

declare class Bumper {
    /**
     * @member - bumper url
     * @type {string}
     */
    url: string;
    /**
     * @member - bumper click through url
     * @type {string}
     */
    clickThroughUrl: string;
    /**
     * @constructor
     * @param {Object} data - The bumper response
     */
    constructor(data: any);
}

declare class DataLoaderManager {
    /**
     * @member - Loaders response map index
     * @type {Map<string,Array<number>>}
     * @private
     */
    private _loadersResponseMap;
    /**
     * @member - Loaders multi request
     * @type {MultiRequestBuilder}
     * @protected
     */
    protected _multiRequest: MultiRequestBuilder;
    /**
     * @member - Loaders single requests
     * @type {RequestSequenceBuilder}
     * @protected
     */
    protected _singleRequests: RequestSequenceBuilder;
    /**
     * @member - Loaders multi response
     * @type {MultiRequestResult}
     * @private
     */
    private _multiResponse;
    /**
     * @member - Loaders to execute
     * @type {Map<string,Function>}
     * @private
     */
    private _loaders;
    private _networkRetryConfig;
    constructor(networkRetryConfig: ProviderNetworkRetryParameters);
    /**
     * Add loader to execution loaders map
     * @function
     * @param {Function} loader Loader to add
     * @param {Object} params Loader params
     * @param {string} ks ks
     * @returns {void}
     */
    add(loader: {
        new (...params: any[]): ILoader;
        id: string;
    }, params: any, ks?: string): void;
    /**
     * Get data from all loaders using multi request
     * @param {boolean} requestsMustSucceed whether all of the requests must succeed or not
     * @param {boolean} filterErrorResults whether the results of the request need to filter error results
     * @function
     * @returns {Promise} Promise
     */
    fetchData(requestsMustSucceed?: boolean, filterErrorResults?: boolean): Promise<any>;
    /**
     * Prepare fetched data
     * @function
     * @param {MultiRequestResult} response - The multi request result
     * @returns {Object} - The prepared data
     */
    prepareData(response: MultiRequestResult): any;
}

declare class DocumentSource {
    /**
     * @member - media source id
     * @type {string}
     */
    id: string;
    /**
     * @member - media source url
     * @type {string}
     */
    url: string;
    /**
     * @member - thumbnail url
     * @type {string}
     */
    thumbnailUrl: string;
    /**
     * @member - media source mimetype
     * @type {string}
     */
    mimetype: string;
    constructor(entry: any);
}

declare class Drm {
    /**
     * @member - license url
     * @type {string}
     */
    licenseUrl: string;
    /**
     * @member - drm scheme
     * @type {string}
     */
    scheme: string;
    /**
     * @member - drm certificate
     * @type {string}
     */
    certificate?: string;
    /**
     * @constructor
     * @param {string} licenseUrl - the license url
     * @param {string} scheme - the drm scheme
     * @param {?string} certificate - the drm certificate
     */
    constructor(licenseUrl: string, scheme: string, certificate?: string);
    /**
     * Convert class to native js object.
     * @returns {ProviderDrmDataObject} - The json class object.
     */
    toJSON(): ProviderDrmDataObject;
}

declare class EntryList {
    /**
     * @member - entry list items
     * @type {Array<MediaEntry>}
     */
    items: Array<MediaEntry>;
    constructor();
}

declare interface ILoader {
    requests: Array<RequestBuilder>;
    response: any;
    isValid(): boolean;
}

declare class ImageSource {
    /**
     * @member - media source id
     * @type {string}
     */
    id: string;
    /**
     * @member - media source url
     * @type {string}
     */
    url: string;
    /**
     * @member - media source mimetype
     * @type {string}
     */
    mimetype: string;
    constructor(entry: any);
    /**
     * Extract the base thumbnail url.
     * @param {string} url - dataUrl.
     * @returns {string} - The base thumbnail url.
     */
    static extractBaseThumbnailUrl(url: string): string;
}

declare class KalturaAccessControlMessage {
    /**
     * @member - The access control message
     * @type {string}
     */
    message: string;
    /**
     *  @member - The access control message code
     * @@type {string}
     */
    code: string;
    /**
     * @constructor
     * @param {Object} data The json response
     */
    constructor(data: any);
}

declare class KalturaAccessControlModifyRequestHostRegexAction extends KalturaRuleAction {
    /**
     * @member - Request host regex pattern
     * @type {string}
     */
    pattern: string;
    /**
     * @member - Request host regex replacement
     * @type {string}
     */
    replacement: string;
    /**
     * @member - serverNodeId to generate replacment host from
     * @type {number}
     */
    replacmenServerNodeId: number;
    /**
     * @member - checkAliveTimeout in milliseconds
     * @type {number}
     */
    checkAliveTimeoutMs: number;
    /**
     * @constructor
     * @param {Object} data - The response
     */
    constructor(data: any);
}

declare class KalturaBaseEntryListResponse extends ServiceResult {
    /**
     * @member - The total count
     * @type {number}
     */
    totalCount: number;
    /**
     * @member - The entries
     * @type {Array<KalturaMediaEntry>}
     */
    entries: Array<KalturaMediaEntry>;
    /**
     * @constructor
     * @param {Object} responseObj The json response
     */
    constructor(responseObj: any);
}

declare class KalturaBumper {
    /**
     * @member - The bumper entry ID
     * @type {string}
     */
    entryId: string;
    /**
     * @member - The bumper click through url
     * @type {string}
     */
    clickThroughUrl: string;
    /**
     * @member - The bumper sources
     * @type {Array<KalturaPlaybackSource>}
     */
    sources: Array<KalturaPlaybackSource>;
    constructor(data: any);
}

declare class KalturaDrmPlaybackPluginData {
    static Scheme: {
        [scheme: string]: string;
    };
    /**
     * @member - The drm scheme
     * @type {string}
     */
    scheme: string;
    /**
     * @member - The license URL
     * @type {string}
     */
    licenseURL: string;
    /**
     * @member - The drm certificate
     * @type {?string}
     */
    certificate?: string;
    /**
     * @constructor
     * @param {Object} drm The json response
     */
    constructor(drm: any);
}

declare class KalturaFlavorAsset {
    static Status: {
        [status: string]: number;
    };
    /**
     * @member - The ID of the Flavor Asset
     * @type {string}
     */
    id: string;
    /**
     * @member -The Flavor Params used to create this Flavor Asset
     * @type {string}
     */
    flavorParamsId: string;
    /**
     * @member -The file extension
     * @type {string}
     */
    fileExt: string;
    /**
     * @member - The overall bitrate (in KBits) of the Flavor Asset
     *  @type {string}
     */
    bitrate: number;
    /**
     * @member - The width of the Flavor Asset
     * @type {number}
     */
    width: number;
    /**
     * @member - The height of the Flavor Asset
     * @type {number}
     */
    height: number;
    /**
     * @member - The frame rate (in FPS) of the Flavor Asset
     * @type {number}
     */
    frameRate: number;
    /**
     * @member - True if this Flavor Asset is the original source
     * @type {number}
     */
    isOriginal: boolean;
    /**
     * @member - True if this Flavor Asset is playable in KDP
     * @type {boolean}
     */
    isWeb: boolean;
    /**
     * @member - The container format
     * @type {boolean}
     */
    containerFormat: string;
    /**
     *@member - The video codec
     * @type {boolean}
     */
    videoCodecId: string;
    /**
     * @member - The status of the Flavor Asset
     * @type {number}
     */
    status: number;
    /**
     * @member - The language of the flavor asset
     * @type {Status}
     */
    language: string;
    /**
     * @member - The label of the flavor asset
     * @type {string}
     */
    label: string;
    /**
     * @member - tags
     * @type {Array<string>}
     */
    tags: Array<string>;
    /**
     * @function
     * @param {string} tags The tags
     * @returns {Array<string>} tags array
     * @static
     */
    static parseTags(tags?: string): Array<string>;
    /**
     * @constructor
     * @param {Object} data The json response
     */
    constructor(data: any);
}

declare class KalturaMediaEntries extends ServiceResult {
    /**
     * @member - The entries
     * @type {Array<KalturaMediaEntry>}
     */
    entries: Array<KalturaMediaEntry>;
    /**
     * @constructor
     * @param {Object} responseObj The json response
     */
    constructor(responseObj: any);
}

declare class KalturaMediaEntry {
    static EntryType: {
        [entryType: string]: {
            value: number | string;
        };
    };
    static MediaType: {
        [mediaType: string]: {
            value: number;
        };
    };
    static EntryStatus: {
        [status: string]: string | number;
    };
    static EntryModerationStatus: {
        [status: string]: number;
    };
    /**
     * @member - The entry id
     * @type {string}
     */
    id: string;
    /**
     * @member - The entry referenceId
     * @type {string}
     */
    referenceId: string;
    /**
     * @member - The entry externalSourceType
     * @type {string}
     */
    externalSourceType: string;
    /**
     * @member - Entry name (Min 1 chars)
     * @type {string}
     */
    name: string;
    /**
     * @member - Entry description
     * @type {string}
     */
    description: string;
    /**
     * @member - The URL used for playback. This is not the download URL.
     * @type {string}
     */
    dataUrl: string;
    /**
     * @member - Comma separated flavor params ids that exists for this media entry
     * @type {string}
     */
    flavorParamsIds: string;
    /**
     * @member - The entry duration
     * @type {number}
     */
    duration: number;
    /**
     * @member - The type of the entry, this is auto filled by the derived entry object
     * @type {string | number}
     */
    type: string | number;
    /**
     * @member - The type of the entry, this is auto filled by the derived entry object (Image, Audio etc.)
     * @type {number}
     */
    entryType: number;
    /**
     * @member - Entry poster image
     * @type {string}
     */
    poster: string;
    /**
     * @member - DVR status
     * @type {number}
     */
    dvrStatus: number;
    /**
     * @member - Entry tags
     * @type {string}
     */
    tags: string;
    /**
     * @member - Entry status
     * @type {number}
     */
    status: number;
    /**
     * @member - Entry creation date as Unix timestamp (In seconds)
     * @type {number}
     */
    createdAt: number;
    /**
     * @member - Entry updation date as Unix timestamp (In seconds)
     * @type {number}
     */
    updatedAt: number;
    /**
     * @member - Entry end date as Unix timestamp (In seconds)
     * @type {number}
     */
    endDate: number;
    /**
     * @member - Number of plays
     * @type {number}
     */
    plays: number;
    /**
     * @member - Number of views
     * @type {number}
     */
    views: number;
    /**
     * @member - The download URL of the entry.
     * @type {string}
     */
    downloadUrl: string;
    /**
     * @member - ID of entry creator.
     * @type {string}
     */
    creatorId: string;
    /**
     * @member - ID of entry owner.
     * @type {string}
     */
    userId: string;
    /**
     * @member - The raw thumbnail URL
     * @type {string}
     */
    rawThumbnailUrl: string;
    /**
     * @member - The root entry ID
     * @type {string}
     */
    rootEntryId: string;
    /**
     * @member - The capabilities of the entry
     * @type {string}
     */
    capabilities: string;
    /**
     * @member - Admin tags
     * @type {string}
     */
    adminTags: string;
    /**
     * @constructor
     * @param {Object} entry The json response
     */
    constructor(entry: any);
}

declare class KalturaMetadata {
    static ObjectType: {
        [type: string]: string | number;
    };
    static Status: {
        [status: string]: number;
    };
    id: number;
    metadataProfileId: number;
    metadataProfileVersion: number;
    metadataObjectType: string | number;
    objectId: string;
    version: number;
    created: Date;
    updated: Date;
    status: number;
    xml: string;
    /**
     * @constructor
     * @param {Object} data The response
     */
    constructor(data: any);
}

declare class KalturaMetadataListResponse extends ServiceResult {
    totalCount: number;
    metas: Array<KalturaMetadata>;
    /**
     * @constructor
     * @param {Object} responseObj The response
     */
    constructor(responseObj: any);
}

declare class KalturaPlaybackContext extends ServiceResult {
    /**
     * @member - The playback sources
     * @type {Array<KalturaPlaybackSource>}
     */
    sources: Array<KalturaPlaybackSource>;
    /**
     * @member - Array of actions as received from the rules that invalidated
     * @type {Array<KalturaRuleAction>}
     */
    actions: Array<KalturaRuleAction>;
    /**
     * @member - Array of actions as received from the rules that invalidated
     * @type {Array<KalturaAccessControlMessage>}
     */
    messages: Array<KalturaAccessControlMessage>;
    /**
     * @member - The flavor assets
     * @type {Array<KalturaFlavorAsset>}
     */
    flavorAssets: Array<KalturaFlavorAsset>;
    /**
     * @member - The bumper data
     * @type {Array<KalturaBumper>}
     */
    bumperData: Array<KalturaBumper>;
    activeLiveStreamTime?: ActiveLiveStreamTime | undefined;
    /**
     * @constructor
     * @param {Object} response The response
     */
    constructor(response: any);
    hasBlockAction(): boolean;
    getBlockAction(): KalturaRuleAction | undefined;
    hasScheduledRestriction(): boolean;
    getErrorMessages(): Array<KalturaAccessControlMessage>;
    /**
     * Get the KalturaAccessControlModifyRequestHostRegexAction action
     * @function getRequestHostRegexAction
     * @returns {?KalturaAccessControlModifyRequestHostRegexAction} The action
     * */
    getRequestHostRegexAction(): KalturaAccessControlModifyRequestHostRegexAction | undefined;
}

declare class KalturaPlaybackSource {
    /**
     * @member - source format according to delivery profile streamer type (applehttp, mpegdash etc.)
     * @type {string}
     */
    format: string;
    /**
     * @member - delivery profile Id
     * @type {string}
     */
    deliveryProfileId: string;
    /**
     * @member - The source URL
     * @type {string}
     */
    url: string;
    /**
     * @member - comma separated string according to deliveryProfile media protocols ('http,https' etc.)
     * @type {string}
     */
    protocols: string;
    /**
     * @member - comma separated string of flavor ids
     * @type {string}
     */
    flavorIds: string;
    /**
     * @member - drm data object containing relevant license url ,scheme name and certificate
     * @type {Array<KalturaDrmPlaybackPluginData>}
     */
    drm: Array<KalturaDrmPlaybackPluginData>;
    /**
     * @constructor
     * @param {Object} source The response
     */
    constructor(source: any);
    /**
     * Checks if source has DRM data
     * @function hasDrmData
     * @returns {boolean} Is source has DRM
     */
    hasDrmData(): boolean;
    /**
     * Checks if source has flavor IDs
     * @function hasFlavorIds
     * @returns {boolean} Is source ha flavor IDs
     */
    hasFlavorIds(): boolean;
    /**
     * Returns source desired protocol if supported
     * @param {string} protocol - the desired protocol for the source (base play url protocol)
     * @returns {string} - protocol if protocol is in the protocols list - if not empty string returned
     */
    getProtocol(protocol: string): string;
}

declare class KalturaPlaylist {
    /**
     * @member - playlist id
     * @type {string}
     */
    id: string;
    /**
     * @member - playlist name
     * @type {string}
     */
    name: string;
    /**
     * @member - playlist description
     * @type {string}
     */
    description: string;
    /**
     * @member - playlist poster image
     * @type {string}
     */
    poster: string;
    /**
     * @constructor
     * @param {Object} playlist - The json response
     */
    constructor(playlist: any);
}

declare class KalturaRuleAction {
    static Type: {
        [type: string]: string | number;
    };
    /**
     * @member - The type of the action
     * @type {string|number}
     */
    type: string | number;
    /**
     * @constructor
     * @param {Object} data - The response
     */
    constructor(data: any);
}

declare class KalturaUIConfResponse extends ServiceResult {
    static Type: {
        [type: string]: number;
    };
    static CreationMode: {
        [mode: string]: number;
    };
    description: string;
    objTypeAsString: string;
    width: number;
    height: number;
    htmlParams: string;
    swfUrl: string;
    confFilePath: string;
    confFile: string;
    confFileFeatures: string;
    name: string;
    config: string;
    confVars: string;
    useCdn: boolean;
    tags: string;
    swfUrlVersion: string;
    created: Date;
    updated: Date;
    html5Url: string;
    version: string;
    partnerTags: string;
    objType: number;
    creationMode: number;
    /**
     * @constructor
     * @param {Object} data The json response
     */
    constructor(data: any);
}

declare class KalturaUserEntry {
    /**
     * @member - The last played playlist entry
     * @type {string}
     */
    playlistLastEntryId: string;
    /**
     * @member - The entry referenceId
     * @type {string}
     */
    private entryId;
    /**
     * @member - The entry id
     * @type {number}
     */
    private id;
    /**
     * @member - username
     * @type {string}
     */
    private userId;
    /**
     * @member - partner id
     * @type {number}
     */
    private partnerId;
    /**
     * @member - entry status
     * @type {number}
     */
    private status;
    /**
     * @member - Entry creation date as Unix timestamp (In seconds)
     * @type {number}
     */
    private createdAt;
    /**
     * @member - Entry updation date as Unix timestamp (In seconds)
     * @type {number}
     */
    private updatedAt;
    /**
     * @constructor
     * @param {Object} entry The json response
     */
    constructor(entry: any);
}

declare class KalturaUserEntryListResponse extends ServiceResult {
    /**
     * @member - The total count
     * @type {number}
     */
    private totalCount;
    /**
     * @member - The entries
     * @type {Array<KalturaUserEntry>}
     */
    private entries;
    /**
     * @constructor
     * @param {Object} responseObj The json response
     */
    constructor(responseObj: any);
}

declare type loggerFunctionType = {
    VERSION: string;
    DEBUG: LogLevelObject;
    ERROR: LogLevelObject;
    INFO: LogLevelObject;
    OFF: LogLevelObject;
    TIME: LogLevelObject;
    TRACE: LogLevelObject;
    WARN: LogLevelObject;
    createDefaultHandler: () => any;
    debug: () => any;
    enabledFor: () => any;
    error: () => any;
    get: () => any;
    getLevel: () => any;
    info: () => any;
    log: () => any;
    setHandler: () => any;
    setLevel: () => any;
    time: () => any;
    timeEnd: () => any;
    trace: () => any;
    useDefaults: () => any;
    warn: () => any;
};

declare type LoggerType = {
    getLogger: loggerFunctionType;
    LogLevel: LogLevelType;
};

declare type LogLevelObject = {
    value: number;
    name: string;
};

declare type LogLevelType = {
    [level: string]: LogLevelObject;
};

declare class MediaEntry {
    static Type: {
        [type: string]: string;
    };
    static DvrStatus: {
        [type: string]: number;
    };
    /**
     * @member - entry id
     * @type {string}
     */
    id?: string;
    /**
     * @member - entry name
     * @type {string}
     */
    name?: string;
    /**
     * @member - entry sources
     * @type {MediaSources}
     */
    sources: MediaSources;
    /**
     * @member - entry duration
     * @type {number}
     */
    duration?: number;
    /**
     * @member - entry type
     * @type {string}
     */
    type: string;
    /**
     * @member - entry metadata
     * @type {Object}
     */
    metadata: any;
    /**
     * @member - DVR status
     * @type {number}
     */
    dvrStatus?: number;
    /**
     * @member - media status
     * @type {number}
     */
    status?: number;
    /**
     * @member - media poster
     * @type {string | Array<Object>}
     */
    poster?: string | Poster[];
    /**
     * @member - assetReferenceType
     * @type {string }
     */
    assetReferenceType?: string;
    /**
     * @member - The download URL of the entry.
     * @type {string}
     */
    downloadUrl?: string;
    /**
     * @member - The raw thumbnail URL
     * @type {string}
     */
    rawThumbnailUrl?: string;
    /**
     * @member - The root entry ID
     * @type {string}
     */
    rootEntryId?: string;
    /**
     * @member - The capabilities of the entry
     * @type {Array<string>}
     */
    capabilities?: Array<string>;
    activeLiveStreamTime?: ActiveLiveStreamTime;
    /**
     * @constructor
     */
    constructor();
    /**
     * Convert class to native js object.
     * @returns {ProviderMediaEntryObject} - The json class object.
     */
    toJSON(): ProviderMediaEntryObject;
}

declare class MediaSource_2 {
    /**
     * @member - media source id
     * @type {string}
     */
    id: string;
    /**
     * @member - media source url
     * @type {string}
     */
    url: string;
    /**
     * @member - media source mimetype
     * @type {string}
     */
    mimetype: string;
    /**
     * @member - media source drm data
     * @type {Array<Drm>}
     */
    drmData?: Array<Drm>;
    /**
     * @member - media source bandwidth
     * @type {number}
     */
    bandwidth?: number;
    /**
     * @member - media source width
     * @type {number}
     */
    width?: number;
    /**
     * @member - media source height
     * @type {number}
     */
    height?: number;
    /**
     * @member - media source label
     * @type {string}
     */
    label?: string;
    /**
     * Convert class to native js object.
     * @returns {ProviderMediaSourceObject} - The json class object.
     */
    toJSON(): ProviderMediaSourceObject;
}

declare class MediaSources {
    /**
     * Progressive download media sources container.
     * @type {Array<MediaSource>}
     * @public
     */
    progressive: Array<MediaSource_2>;
    /**
     * Dash media sources container.
     * @type {Array<MediaSource>}
     * @public
     */
    dash: Array<MediaSource_2>;
    /**
     * Hls media sources container.
     * @type {Array<MediaSource>}
     * @public
     */
    hls: Array<MediaSource_2>;
    image: Array<ImageSource>;
    document: Array<DocumentSource>;
    captions?: Array<PKExternalCaptionObject>;
    /**
     * @constructor
     */
    constructor();
    /**
     * Maps the source to one of the containers according to his media format.
     * @param {MediaSource} source - The source to add to one of the containers.
     * @param {MediaFormat} mediaFormat - The media format of the source.
     * @returns {void}
     */
    map(source: MediaSource_2, mediaFormat?: ProviderMediaFormatType): void;
    /**
     * Convert class to native js object.
     * @returns {ProviderMediaSourcesObject} - The json class object.
     */
    toJSON(): ProviderMediaSourcesObject;
}

declare class MultiRequestBuilder extends RequestBuilder {
    private static _logger;
    /**
     * @memberof - MultiRequestBuilder
     * @type {Array<RequestBuilder>}
     */
    requests: Array<RequestBuilder>;
    /**
     * Adds request to requests array
     * @function add
     * @param {RequestBuilder} request The request
     * @returns {MultiRequestBuilder} The multiRequest
     */
    add(request: RequestBuilder): MultiRequestBuilder;
    /**
     * Executes a multi request
     * @function execute
     * @param {boolean} requestsMustSucceed whether all of the requests must succeed or not
     * @param {boolean} filterErrorResults whether the results of the request need to filter error results   * @returns {Promise} The multirequest execution promise
     */
    execute(requestsMustSucceed?: boolean, filterErrorResults?: boolean): Promise<any>;
}

declare class MultiRequestResult {
    private static _logger;
    /**
     * @memberof MultiRequestResult
     * @type {boolean}
     */
    success: boolean;
    /**
     * @memberof MultiRequestResult
     * @type {Object}
     */
    results: Array<ServiceResult>;
    /**
     * @constructor
     * @param {Object} response data
     * @param {boolean} requestsMustSucceed whether all of the requests must succeed
     * @param {boolean} filterErrorResults whether the results of the request need to filter error results
     */
    constructor(response: any, requestsMustSucceed?: boolean, filterErrorResults?: boolean);
}

export declare const NAME: string;

declare type OTTProviderMediaInfoObject = OVPProviderMediaInfoObject & {
    mediaType: string;
    contextType: string;
    protocol?: string;
    fileIds?: string;
    streamerType?: string;
    urlType?: string;
    adapterData?: AdapterDataConfig;
    assetReferenceType?: string;
    formats?: Array<string>;
};

declare type OVPMediaEntryLoaderResponse = {
    entry: KalturaMediaEntry;
    playBackContextResult: KalturaPlaybackContext;
    metadataListResult: KalturaMetadataListResponse;
};

declare type OVPProviderMediaInfoObject = {
    entryId?: string;
    referenceId?: string;
    ks?: string;
    clientTag?: string;
};

declare type PKExternalCaptionObject = {
    url: string;
    label: string;
    language: string;
    default?: boolean;
    type?: string;
};

declare class Playlist {
    /**
     * @member - playlist id
     * @type {string}
     */
    id?: string;
    /**
     * @member - playlist name
     * @type {string}
     */
    name?: string;
    /**
     * @member - playlist description
     * @type {string}
     */
    description?: string;
    /**
     * @member - playlist poster
     * @type {string}
     */
    poster?: string;
    /**
     * @member - playlist items
     * @type {Array<MediaEntry>}
     */
    items: Array<MediaEntry>;
    /**
     * @member - playlist last played entry
     * @type {string}
     */
    playlistLastEntryId?: string;
    constructor();
}

declare interface Poster {
    width: number;
    height: number;
    url: string;
}

export declare class Provider extends BaseProvider<OVPProviderMediaInfoObject> {
    private _filterOptionsConfig;
    private _vrTag;
    private _retryAttempts;
    private _useHeaderForKs;
    /**
     * @constructor
     * @param {ProviderOptionsObject} options - provider options
     * @param {string} playerVersion - player version
     */
    constructor(options: ProviderOptionsObject, playerVersion: string);
    get env(): any;
    initializeUserResponse(serviceUrl: string, ks: string): Promise<void>;
    /**
     * Gets the backend media config object.
     * @param {OVPProviderMediaInfoObject} mediaInfo - ovp media info
     * @returns {Promise<ProviderMediaConfigObject>} - The provider media config
     */
    getMediaConfig(mediaInfo: OVPProviderMediaInfoObject): Promise<ProviderMediaConfigObject>;
    doRequest(loaders: Array<RequestLoader>, ks?: string, requestsMustSucceed?: boolean, filterErrorResults?: boolean): Promise<any>;
    private _getEntryRedirectFilter;
    private _setFilterOptionsConfig;
    private _parseDataFromResponse;
    /**
     * Checks if media is ready for playback (not being imported or converted)
     * @param {MediaEntry} mediaEntry - the media entry info
     * @returns {void}
     */
    private _verifyMediaStatus;
    /**
     * Gets the backend playlist config.
     * @param {ProviderPlaylistInfoObject} playlistInfo - ovp playlist info
     * @returns {Promise<ProviderPlaylistObject>} - The provider playlist config
     */
    getPlaylistConfig(playlistInfo: ProviderPlaylistInfoObject): Promise<ProviderPlaylistObject>;
    private _handlePlaylistResponse;
    private _handlePlaylistSuccess;
    private _handlePlaylistRetry;
    private _handleMaxRetriesReached;
    private _schedulePlaylistRetry;
    private _parsePlaylistDataFromResponse;
    /**
     * Gets playlist config from entry list.
     * @param {ProviderEntryListObject} entryListInfo - ovp entry list info
     * @returns {Promise<ProviderPlaylistObject>} - The provider playlist config
     */
    getEntryListConfig(entryListInfo: ProviderEntryListObject): Promise<ProviderPlaylistObject>;
    private _parseEntryListDataFromResponse;
    private _getPlaylistObject;
    private _getDefaultSourcesObject;
    private _getSourcesObject;
}

declare type ProviderDrmDataObject = {
    licenseUrl: string;
    scheme: string;
    certificate?: string;
};

declare type ProviderEntryListObject = {
    entries: Array<ProviderMediaInfoObject>;
    ks?: string;
    clientTag?: string;
};

declare type ProviderEnvConfigObject = {
    serviceUrl: string;
    cdnUrl?: string;
    analyticsServiceUrl?: string;
    useApiCaptions?: boolean;
    replaceHostOnlyManifestUrls?: boolean;
    overrideServiceUrl?: string;
    initCallToServer?: string;
};

declare type ProviderFilterOptionsObject = {
    redirectFromEntryId?: boolean;
};

declare type ProviderMediaConfigMetadataObject = {
    name: string;
    description?: string;
    mediaType?: string;
    contextType?: string;
    metas?: any;
    tags?: any;
    epgId?: string;
    recordingId?: string;
    updatedAt?: number;
    creatorId?: string;
    userId?: string;
    views?: number;
};

declare type ProviderMediaConfigObject = {
    session: ProviderMediaConfigSessionObject;
    sources: ProviderMediaConfigSourcesObject;
    plugins: {
        [plugin: string]: any;
    };
};

declare type ProviderMediaConfigSessionObject = {
    partnerId: number;
    uiConfId?: number;
    ks?: string;
    isAnonymous?: boolean;
};

declare type ProviderMediaConfigSourcesObject = {
    activeLiveStreamTime?: ActiveLiveStreamTime;
    dash: Array<ProviderMediaSourceObject>;
    hls: Array<ProviderMediaSourceObject>;
    progressive: Array<ProviderMediaSourceObject>;
    image: Array<ImageSource>;
    document: Array<DocumentSource>;
    duration?: number;
    type: string;
    id?: string;
    poster?: string | Array<any>;
    dvr: boolean;
    vr?: any;
    metadata: ProviderMediaConfigMetadataObject;
    captions?: Array<PKExternalCaptionObject>;
    downloadUrl?: string;
    rawThumbnailUrl?: string;
    seekFrom?: number;
    clipTo?: number;
    rootEntryId?: string;
    capabilities?: Array<string>;
};

declare type ProviderMediaEntryObject = {
    id?: string;
    name?: string;
    sources: ProviderMediaSourcesObject;
    duration?: number;
    dvrStatus?: number;
    status?: number;
    metadata: any;
    type: string;
    poster?: string | Poster[];
    downloadUrl?: string;
    assetReferenceType?: string;
    rawThumbnailUrl?: string;
    rootEntryId?: string;
    capabilities?: Array<string>;
};

declare type ProviderMediaFormatType = {
    name: string;
    mimeType: string;
    pathExt: string;
};

declare type ProviderMediaInfoObject = OVPProviderMediaInfoObject | OTTProviderMediaInfoObject;

declare type ProviderMediaSourceObject = {
    id: string;
    url: string;
    mimetype: string;
    bandwidth?: number;
    width?: number;
    height?: number;
    label?: string;
    drmData?: Array<ProviderDrmDataObject>;
};

declare type ProviderMediaSourcesObject = {
    progressive: Array<ProviderMediaSourceObject>;
    dash: Array<ProviderMediaSourceObject>;
    hls: Array<ProviderMediaSourceObject>;
    image: Array<ImageSource>;
    document: Array<DocumentSource>;
    captions?: Array<PKExternalCaptionObject>;
};

declare type ProviderNetworkRetryParameters = {
    async: boolean;
    timeout?: number;
    maxAttempts?: number;
};

declare type ProviderOptionsObject = {
    partnerId: number;
    widgetId?: string;
    logger?: LoggerType;
    ks?: string;
    uiConfId?: number;
    env?: ProviderEnvConfigObject;
    networkRetryParameters?: ProviderNetworkRetryParameters;
    filterOptions?: ProviderFilterOptionsObject;
    ignoreServerConfig?: boolean;
    loadThumbnailWithKs?: boolean;
    referrer?: string;
    vrTag?: string;
    unisphereLoaderUrl?: string;
    useHeaderForKs?: boolean;
    clientTag?: string;
};

export declare class ProviderParser {
    private static _logger;
    /**
     * Returns parsed media entry by given OVP response objects
     * @function getMediaEntry
     * @param {string} ks - The ks
     * @param {number} partnerId - The partner ID
     * @param {number} uiConfId - The uiConf ID
     * @param {any} mediaEntryResponse - The media entry response
     * @returns {MediaEntry} - The media entry
     * @static
     * @public
     */
    static getMediaEntry(ks: string, partnerId: number, uiConfId: number | undefined, mediaEntryResponse: any): MediaEntry;
    /**
     * Returns the url with KS
     * @function addKsToUrl
     * @param {String} url - The url to add the KS
     * @param {string} ks - The ks
     * @returns {string} - The url with KS
     * @static
     * @public
     */
    static addKsToUrl(url: string, ks: string): string;
    /**
     * Returns parsed playlist by given OVP response objects
     * @function getPlaylist
     * @param {any} playlistResponse - The playlist response
     * @returns {Playlist} - The playlist
     * @static
     * @public
     */
    static getPlaylist(playlistResponse: any): Playlist;
    /**
     * Returns parsed entry list by given OVP response objects
     * @function getEntryList
     * @param {any} playlistResponse - response
     * @returns {Playlist} - The entry list
     * @static
     * @public
     */
    static getEntryList(playlistResponse: any): EntryList;
    /**
     * Returns parsed bumper by given OTT response objects.
     * @function getBumper
     * @param {any} assetResponse - The asset response.
     * @param {string} ks - The ks
     * @param {number} partnerId - The partner ID
     * @returns {?Bumper} - The bumper
     * @static
     * @public
     */
    static getBumper(assetResponse: any, ks: string, partnerId: number): Bumper | undefined;
    private static _fillBaseData;
    private static _getEntryType;
    /**
     * Returns the parsed sources
     * @function _getParsedSources
     * @param {Array<KalturaPlaybackSource>} kalturaSources - The kaltura sources
     * @param {string} ks - The ks
     * @param {number} partnerId - The partner ID
     * @param {number} uiConfId - The uiConf ID
     * @param {Object} entry - The entry
     * @param {KalturaPlaybackContext} playbackContext - The playback context
     * @return {MediaSources} - A media sources
     * @static
     * @private
     */
    private static _getParsedSources;
    /**
     * Returns a parsed adaptive source
     * @function _parseAdaptiveSource
     * @param {KalturaPlaybackSource} kalturaSource - A kaltura source
     * @param {KalturaPlaybackContext} playbackContext - The playback context
     * @param {string} ks - The ks
     * @param {number} partnerId - The partner ID
     * @param {number} uiConfId - The uiConf ID
     * @param {string} entryId - The entry id
     * @returns {?MediaSource} - The parsed adaptive kalturaSource
     * @static
     * @private
     */
    private static _parseAdaptiveSource;
    /**
     * Returns parsed progressive sources
     * @function _parseProgressiveSources
     * @param {KalturaPlaybackSource} kalturaSource - A kaltura source
     * @param {KalturaPlaybackContext} playbackContext - The playback context
     * @param {string} ks - The ks
     * @param {number} partnerId - The partner ID
     * @param {number} uiConfId - The uiConf ID
     * @param {string} entryId - The entry id
     * @returns {Array<MediaSource>} - The parsed progressive kalturaSources
     * @static
     * @private
     */
    private static _parseProgressiveSources;
    /**
     * Ovp metadata parser
     * @function _parseMetaData
     * @param {KalturaMetadataListResponse} metadataList The metadata list
     * @returns {Object} Parsed metadata
     * @static
     * @private
     */
    private static _parseMetadata;
    /**
     * Returns the base protocol
     * @function _getBaseProtocol
     * @returns {string} - The base protocol
     * @static
     * @private
     */
    private static _getBaseProtocol;
    static hasBlockAction(response: OVPMediaEntryLoaderResponse): boolean;
    static getBlockAction(response: OVPMediaEntryLoaderResponse): KalturaRuleAction | undefined;
    static hasScheduledRestriction(response: OVPMediaEntryLoaderResponse): boolean;
    static getErrorMessages(response: OVPMediaEntryLoaderResponse): Array<KalturaAccessControlMessage>;
}

declare type ProviderPlaylistInfoObject = {
    playlistId: string;
    ks?: string;
};

declare type ProviderPlaylistItemObject = {
    sources: ProviderMediaConfigSourcesObject;
};

declare type ProviderPlaylistMetadataObject = {
    name: string;
    description: string;
};

declare type ProviderPlaylistObject = {
    id: string;
    metadata: ProviderPlaylistMetadataObject;
    poster: string;
    items: Array<ProviderPlaylistItemObject>;
    playlistLastEntryId?: string;
};

export declare class RequestBuilder {
    /**
     * @member - Service name
     * @type {string}
     */
    service: string;
    /**
     * @member - Service action
     * @type {string}
     */
    action: string;
    /**
     * @member - Service params
     * @type {any}
     */
    params: any;
    /**
     * @memberof - Service headers
     * @type {Map<string, string>}
     */
    headers: Map<string, string>;
    /**
     * @memberof - Service URL
     * @type {string}
     */
    url: string;
    /**
     * @memberof - Service method (POST,GET,DELETE etc..)
     * @type {string}
     */
    method: string;
    /**
     * @memberof - Service tag
     * @type {string}
     */
    tag: string;
    /**
     * @memberof - the response headers of the arra
     * @type {Array<string>}
     */
    responseHeaders: Array<string>;
    /**
     * @description network retry configuration
     * @memberof RequestBuilder
     * @type {ProviderNetworkRetryParameters}
     */
    retryConfig: ProviderNetworkRetryParameters;
    /**
     * @description number of xhr attempts for the same multi - request.
     * @memberof RequestBuilder
     * @type {number}
     * @private
     */
    private _attemptCounter;
    /**
     * @description hold the promise result of the XHR request(s) - if all tries fails, it rejects with the error.
     * @memberof RequestBuilder
     * @type {Object}
     * @private
     */
    private _requestPromise;
    /**
     * @constructor
     * @param {Map<string, string>} headers The request headers
     */
    constructor(headers?: Map<string, string>);
    /**
     * Builds restful service URL
     * @function getUrl
     * @param {string} serviceUrl - The service base URL
     * @returns {string} The service URL
     */
    getUrl(serviceUrl: string): string;
    /**
     * Executes service
     * @function doHttpRequest
     * @returns {Promise.<any>} Service response as promise
     */
    doHttpRequest(): Promise<any>;
    private _createXHR;
    private _getResponseHeaders;
    private _handleError;
    private _createError;
}

declare type RequestLoader = {
    loader: ILoader;
    params: any;
};

/**
 * RequestSequenceBuilder provides a builder pattern for executing multiple individual requests
 * sequentially, as an alternative to the MultiRequestBuilder which batches them together.
 * @class RequestSequenceBuilder
 */
declare class RequestSequenceBuilder {
    private _logger;
    /**
     * Loaders to be executed
     * @type {Map<string, ILoader>}
     * @private
     */
    loaders: Map<string, ILoader>;
    /**
     * Global parameters for all requests
     * @type {Record<string, unknown>}
     * @private
     */
    private _globalParams;
    /**
     * Add a loader to the builder
     * @function add
     * @param {ILoader} loader The loader to add
     */
    add(loader: ILoader): void;
    /**
     * Executes a single request
     * @function execute
     * @param {RequestBuilder} request - The request to execute
     * @returns {Promise<ServiceResult>} - Promise with the service result
     */
    private _executeRequest;
    /**
     * Executes multiple requests sequentially
     * @function executeSequence
     * @param {Array<RequestBuilder>} requests - The requests to execute in order
     * @returns {Promise<SingleRequestsResult>} - Promise with the combined results
     */
    private _executeSequence;
    /**
     * Executes all added loaders as separate requests
     * @function execute
     * @returns {Promise<Map<string, ILoader>>} - Promise with the loaded loaders
     */
    execute(): Promise<Map<string, ILoader>>;
}

declare namespace ResponseTypes {
    export {
        KalturaBaseEntryListResponse,
        KalturaMediaEntry,
        KalturaAccessControlModifyRequestHostRegexAction,
        KalturaBumper,
        KalturaFlavorAsset,
        KalturaMediaEntries,
        KalturaMetadata,
        KalturaMetadataListResponse,
        KalturaPlaybackContext,
        KalturaPlaybackSource,
        KalturaPlaylist,
        KalturaRuleAction,
        KalturaUIConfResponse,
        KalturaDrmPlaybackPluginData,
        KalturaAccessControlMessage,
        ServiceResult as BaseServiceResult,
        KalturaUserEntry,
        KalturaUserEntryListResponse
    }
}
export { ResponseTypes }

declare class ServiceError {
    /**
     * @member - The error code
     * @type {string}
     */
    code: string;
    /**
     * @member - The error message
     * @type {string}
     */
    message: string;
    /**
     * @constructor
     * @param {string} code - The result code
     * @param {string} message - The result message
     */
    constructor(code: string, message: string);
}

declare class ServiceResult {
    /**
     * @member - Is service returned an error
     * @type {boolean}
     */
    hasError: boolean;
    /**
     * @member - The service error
     * @type {ServiceError}
     */
    error: ServiceError;
    /**
     * @member - The service result data
     * @type {Object}
     */
    data: any;
    /**
     * @constructor
     * @param {Object} response - Service response
     */
    constructor(response: any);
}

export declare const VERSION: string;

export { }