/** @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;
}

export declare const ContextType: {
    [type: string]: string;
};

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 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 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;
};

export declare const MediaType: {
    [type: string]: string;
};

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 OVPProviderMediaInfoObject = {
    entryId?: string;
    referenceId?: string;
    ks?: string;
    clientTag?: string;
};

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

export declare class Provider extends BaseProvider<OTTProviderMediaInfoObject> {
    /**
     * @constructor
     * @param {ProviderOptionsObject} options - provider options
     * @param {string} playerVersion - player version
     */
    constructor(options: ProviderOptionsObject, playerVersion: string);
    get env(): any;
    /**
     * Gets the backend media config.
     * @param {OTTProviderMediaInfoObject} mediaInfo - ott media info
     * @returns {Promise<ProviderMediaConfigObject>} - The provider media config
     */
    getMediaConfig(mediaInfo: OTTProviderMediaInfoObject): Promise<ProviderMediaConfigObject>;
    private _parseDataFromResponse;
    /**
     * Gets the playlist config from entry list.
     * @param {ProviderEntryListObject} entryListInfo - ott entry list info
     * @returns {Promise<ProviderPlaylistObject>} - The provider playlist config
     */
    getEntryListConfig(entryListInfo: ProviderEntryListObject): Promise<ProviderPlaylistObject>;
    private _parseEntryListDataFromResponse;
    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 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 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;
};

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;
};

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;
}

/**
 * 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 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 { }