@playkit-js/playkit-js-providers 2.40.1 → 2.40.2-canary.0-c7a43ae

package/src/k-provider/ovp/provider.ts

@@ -0,0 +1,358 @@
+import getLogger from '../../util/logger';
+import OVPConfiguration from './config';
+import OVPProviderParser from './provider-parser';
+import {KalturaMediaEntry} from './response-types';
+import OVPMediaEntryLoader from './loaders/media-entry-loader';
+import OVPSessionLoader from './loaders/session-loader';
+import OVPDataLoaderManager from './loaders/data-loader-manager';
+import OVPPlaylistLoader from './loaders/playlist-loader';
+import BaseProvider from '../common/base-provider';
+import MediaEntry from '../../entities/media-entry';
+import OVPEntryListLoader from './loaders/entry-list-loader';
+import Error from '../../util/error/error';
+import RegexActionHandler from './regex-action-handler';
+import {
+  ILoader,
+  OVPProviderMediaInfoObject,
+  ProviderEntryListObject,
+  ProviderFilterOptionsObject,
+  ProviderMediaConfigObject,
+  ProviderMediaConfigSourcesObject,
+  ProviderOptionsObject, ProviderPlaylistInfoObject,
+  ProviderPlaylistObject, RequestLoader
+} from '../../types';
+
+export default class OVPProvider extends BaseProvider<OVPProviderMediaInfoObject> {
+  private _filterOptionsConfig: ProviderFilterOptionsObject = {redirectFromEntryId: true};
+  /**
+   * @constructor
+   * @param {ProviderOptionsObject} options - provider options
+   * @param {string} playerVersion - player version
+   */
+  constructor(options: ProviderOptionsObject, playerVersion: string) {
+    super(options, playerVersion);
+    this._logger = getLogger('OVPProvider');
+    OVPConfiguration.set(options.env);
+    this._setFilterOptionsConfig(options.filterOptions);
+    this._networkRetryConfig = Object.assign(this._networkRetryConfig, options.networkRetryParameters);
+  }
+
+  public get env(): any {
+    return OVPConfiguration.get();
+  }
+
+  /**
+   * Gets the backend media config object.
+   * @param {OVPProviderMediaInfoObject} mediaInfo - ovp media info
+   * @returns {Promise<ProviderMediaConfigObject>} - The provider media config
+   */
+  public getMediaConfig(mediaInfo: OVPProviderMediaInfoObject): Promise<ProviderMediaConfigObject> {
+    if (mediaInfo.ks) {
+      this.ks = mediaInfo.ks;
+      this._isAnonymous = false;
+    }
+    if (this.widgetId !== this.defaultWidgetId) {
+      this._isAnonymous = false;
+    }
+    this._dataLoader = new OVPDataLoaderManager(this.playerVersion, this.partnerId, this.ks, this._networkRetryConfig);
+    return new Promise((resolve, reject) => {
+      const entryId = mediaInfo.entryId;
+      const referenceId = mediaInfo.referenceId;
+      if (entryId || referenceId) {
+        let ks: string = this.ks;
+        if (!ks) {
+          ks = '{1:result:ks}';
+          this._dataLoader.add(OVPSessionLoader, {widgetId: this.widgetId});
+        }
+        const redirectFromEntryId = this._getEntryRedirectFilter(mediaInfo);
+        this._dataLoader.add(OVPMediaEntryLoader, {entryId, ks, redirectFromEntryId, referenceId});
+        return this._dataLoader.fetchData().then(
+          response => {
+            try {
+              const mediaConfig = this._parseDataFromResponse(response);
+              RegexActionHandler.handleRegexAction(mediaConfig, response).then(resolve);
+            } catch (err) {
+              reject(err);
+            }
+          },
+          err => {
+            reject(err);
+          }
+        );
+      } else {
+        reject(new Error(Error.Severity.CRITICAL, Error.Category.PROVIDER, Error.Code.MISSING_MANDATORY_PARAMS, {message: 'missing entry id'}));
+      }
+    });
+  }
+
+  public doRequest(loaders: Array<RequestLoader>, ks?: string): Promise<any> {
+    const theKs: string = ks || this.ks;
+    const dataLoader = new OVPDataLoaderManager(this.playerVersion, this.partnerId, theKs, this._networkRetryConfig);
+
+    return new Promise((resolve, reject) => {
+      if (!theKs) {
+        dataLoader.add(OVPSessionLoader, {widgetId: this.widgetId});
+      }
+      loaders.forEach((loaderRequest: RequestLoader) => {
+        // eslint-disable-next-line  @typescript-eslint/ban-ts-comment
+        // @ts-ignore
+        dataLoader.add(loaderRequest.loader, loaderRequest.params, theKs || '{1:result:ks}');
+      });
+      return dataLoader.fetchData().then(
+        response => {
+          try {
+            resolve(response);
+          } catch (err) {
+            reject(err);
+          }
+        },
+        err => {
+          reject(err);
+        }
+      );
+    });
+  }
+
+  private _getEntryRedirectFilter(mediaInfo: any): boolean {
+    return typeof mediaInfo.redirectFromEntryId === 'boolean'
+      ? mediaInfo.redirectFromEntryId
+      : typeof this._filterOptionsConfig.redirectFromEntryId === 'boolean'
+        ? this._filterOptionsConfig.redirectFromEntryId
+        : true;
+  }
+
+  private _setFilterOptionsConfig(options?: ProviderFilterOptionsObject): void {
+    if (options && typeof options.redirectFromEntryId === 'boolean') {
+      this._filterOptionsConfig.redirectFromEntryId = options.redirectFromEntryId;
+    }
+  }
+
+  private _parseDataFromResponse(data: Map<string, ILoader>): ProviderMediaConfigObject {
+    this._logger.debug('Data parsing started');
+    const mediaConfig: ProviderMediaConfigObject = {
+      session: {
+        isAnonymous: this._isAnonymous,
+        partnerId: this.partnerId
+      },
+      sources: this._getDefaultSourcesObject(),
+      plugins: {}
+    } as ProviderMediaConfigObject;
+
+    if (this.uiConfId) {
+      mediaConfig.session.uiConfId = this.uiConfId;
+    }
+
+    if (data) {
+      if (data.has(OVPSessionLoader.id)) {
+        const sessionLoader = data.get(OVPSessionLoader.id);
+        if (sessionLoader && sessionLoader.response) {
+          mediaConfig.session.ks = sessionLoader.response;
+          if (this.widgetId !== this.defaultWidgetId) {
+            this.ks = mediaConfig.session.ks!;
+          }
+        }
+      } else {
+        mediaConfig.session.ks = this.ks;
+      }
+      if (data.has(OVPMediaEntryLoader.id)) {
+        const mediaLoader = data.get(OVPMediaEntryLoader.id);
+        if (mediaLoader && mediaLoader.response) {
+          const response = (mediaLoader as OVPMediaEntryLoader).response;
+          if (OVPProviderParser.hasBlockAction(response)) {
+            throw new Error(Error.Severity.CRITICAL, Error.Category.SERVICE, Error.Code.BLOCK_ACTION, {
+              action: OVPProviderParser.getBlockAction(response),
+              messages: OVPProviderParser.getErrorMessages(response)
+            });
+          }
+          const mediaEntry = OVPProviderParser.getMediaEntry(this.isAnonymous ? '' : this.ks, this.partnerId, this.uiConfId, response);
+          Object.assign(mediaConfig.sources, this._getSourcesObject(mediaEntry));
+          this._verifyMediaStatus(mediaEntry);
+          this._verifyHasSources(mediaConfig.sources);
+          const bumper = OVPProviderParser.getBumper(response, this.isAnonymous ? '' : this.ks, this.partnerId);
+          if (bumper) {
+            Object.assign(mediaConfig.plugins, {bumper});
+          }
+        }
+      }
+    }
+    this._logger.debug('Data parsing finished', mediaConfig);
+    return mediaConfig;
+  }
+
+  /**
+   * Checks if media is ready for playback (not being imported or converted)
+   * @param {MediaEntry} mediaEntry - the media entry info
+   * @returns {void}
+   */
+  private _verifyMediaStatus(mediaEntry: MediaEntry): void {
+    if ([KalturaMediaEntry.EntryStatus.IMPORT, KalturaMediaEntry.EntryStatus.PRECONVERT].includes(mediaEntry.status!)) {
+      throw new Error(Error.Severity.CRITICAL, Error.Category.SERVICE, Error.Code.MEDIA_STATUS_NOT_READY, {
+        messages: `Status of entry id ${mediaEntry.id} is ${mediaEntry.status} and is still being imported or converted`,
+        data: {status}
+      });
+    }
+  }
+  /**
+   * Gets the backend playlist config.
+   * @param {ProviderPlaylistInfoObject} playlistInfo - ovp playlist info
+   * @returns {Promise<ProviderPlaylistObject>} - The provider playlist config
+   */
+  public getPlaylistConfig(playlistInfo: ProviderPlaylistInfoObject): Promise<ProviderPlaylistObject> {
+    if (playlistInfo.ks) {
+      this.ks = playlistInfo.ks;
+      this._isAnonymous = false;
+    }
+    if (this.widgetId !== this.defaultWidgetId) {
+      this._isAnonymous = false;
+    }
+    this._dataLoader = new OVPDataLoaderManager(this.playerVersion, this.partnerId, this.ks, this._networkRetryConfig);
+    return new Promise((resolve, reject) => {
+      const playlistId = playlistInfo.playlistId;
+      if (playlistId) {
+        let ks: string = this.ks;
+        if (!ks) {
+          ks = '{1:result:ks}';
+          this._dataLoader.add(OVPSessionLoader, {widgetId: this.widgetId});
+        }
+        this._dataLoader.add(OVPPlaylistLoader, {playlistId, ks});
+        this._dataLoader.fetchData().then(
+          response => {
+            resolve(this._parsePlaylistDataFromResponse(response));
+          },
+          err => {
+            reject(err);
+          }
+        );
+      } else {
+        reject({success: false, data: 'Missing mandatory parameter'});
+      }
+    });
+  }
+
+  private _parsePlaylistDataFromResponse(data: Map<string, ILoader>): ProviderPlaylistObject {
+    this._logger.debug('Data parsing started');
+    const playlistConfig: ProviderPlaylistObject = this._getPlaylistObject();
+    if (data && data.has(OVPPlaylistLoader.id)) {
+      const playlistLoader = data.get(OVPPlaylistLoader.id);
+      if (playlistLoader && playlistLoader.response) {
+        const playlist = OVPProviderParser.getPlaylist(playlistLoader.response);
+        playlistConfig.id = playlist.id!;
+        playlistConfig.poster = playlist.poster!;
+        playlistConfig.metadata.name = playlist.name!;
+        playlistConfig.metadata.description = playlist.description!;
+        playlistConfig.playlistLastEntryId = playlist.playlistLastEntryId;
+        playlist.items.forEach(i => playlistConfig.items.push({sources: this._getSourcesObject(i)}));
+      }
+    }
+    this._logger.debug('Data parsing finished', playlistConfig);
+    return playlistConfig;
+  }
+
+  /**
+   * Gets playlist config from entry list.
+   * @param {ProviderEntryListObject} entryListInfo - ovp entry list info
+   * @returns {Promise<ProviderPlaylistObject>} - The provider playlist config
+   */
+  public getEntryListConfig(entryListInfo: ProviderEntryListObject): Promise<ProviderPlaylistObject> {
+    if (entryListInfo.ks) {
+      this.ks = entryListInfo.ks;
+      this._isAnonymous = false;
+    }
+    if (this.widgetId !== this.defaultWidgetId) {
+      this._isAnonymous = false;
+    }
+    this._dataLoader = new OVPDataLoaderManager(this.playerVersion, this.partnerId, this.ks, this._networkRetryConfig);
+    return new Promise((resolve, reject) => {
+      const entries = entryListInfo.entries;
+      if (entries && entries.length) {
+        let ks: string = this.ks;
+        if (!ks) {
+          ks = '{1:result:ks}';
+          this._dataLoader.add(OVPSessionLoader, {widgetId: this.widgetId});
+        }
+        const redirectFromEntryId = this._getEntryRedirectFilter(entryListInfo);
+        this._dataLoader.add(OVPEntryListLoader, {entries, ks, redirectFromEntryId});
+        this._dataLoader.fetchData(false).then(
+          response => {
+            resolve(this._parseEntryListDataFromResponse(response));
+          },
+          err => {
+            reject(err);
+          }
+        );
+      } else {
+        reject({success: false, data: 'Missing mandatory parameter'});
+      }
+    });
+  }
+
+  private _parseEntryListDataFromResponse(data: Map<string, ILoader>): ProviderPlaylistObject {
+    this._logger.debug('Data parsing started');
+    const playlistConfig: ProviderPlaylistObject = this._getPlaylistObject();
+    if (data && data.has(OVPEntryListLoader.id)) {
+      const playlistLoader = data.get(OVPEntryListLoader.id);
+      if (playlistLoader && playlistLoader.response) {
+        const entryList = OVPProviderParser.getEntryList(playlistLoader.response);
+        entryList.items.forEach(i => playlistConfig.items.push({sources: this._getSourcesObject(i)}));
+      }
+    }
+    this._logger.debug('Data parsing finished', playlistConfig);
+    return playlistConfig;
+  }
+
+  private _getPlaylistObject(): ProviderPlaylistObject {
+    return {
+      id: '',
+      metadata: {
+        name: '',
+        description: ''
+      },
+      poster: '',
+      playlistLastEntryId: '',
+      items: []
+    };
+  }
+
+  private _getDefaultSourcesObject(): ProviderMediaConfigSourcesObject {
+    return {
+      hls: [],
+      dash: [],
+      progressive: [],
+      image: [],
+      id: '',
+      duration: 0,
+      type: MediaEntry.Type.UNKNOWN,
+      poster: '',
+      dvr: false,
+      vr: null,
+      metadata: {
+        name: '',
+        description: '',
+        tags: ''
+      }
+    };
+  }
+
+  private _getSourcesObject(mediaEntry: MediaEntry): ProviderMediaConfigSourcesObject {
+    const sourcesObject: ProviderMediaConfigSourcesObject = this._getDefaultSourcesObject();
+    const mediaSources = mediaEntry.sources.toJSON();
+    sourcesObject.hls = mediaSources.hls;
+    sourcesObject.dash = mediaSources.dash;
+    sourcesObject.progressive = mediaSources.progressive;
+    sourcesObject.image = mediaSources.image;
+    sourcesObject.id = mediaEntry.id;
+    sourcesObject.duration = mediaEntry.duration;
+    sourcesObject.type = mediaEntry.type;
+    sourcesObject.dvr = !!mediaEntry.dvrStatus;
+    sourcesObject.poster = mediaEntry.poster;
+    sourcesObject.downloadUrl = mediaEntry.downloadUrl;
+    if (mediaEntry.sources.captions) {
+      sourcesObject.captions = mediaEntry.sources.captions;
+    }
+    if (mediaEntry.metadata && typeof mediaEntry.metadata.tags === 'string' && mediaEntry.metadata.tags.split(', ').includes('360')) {
+      sourcesObject.vr = {};
+    }
+    Object.assign(sourcesObject.metadata, mediaEntry.metadata);
+    return sourcesObject;
+  }
+}

package/src/k-provider/ovp/regex-action-handler.ts

@@ -0,0 +1,149 @@
+import getLogger from '../../util/logger';
+import OVPConfiguration from './config';
+import {KalturaAccessControlModifyRequestHostRegexAction} from './response-types';
+import OVPMediaEntryLoader from './loaders/media-entry-loader';
+import {ILoader, ProviderMediaConfigObject} from '../../types';
+
+class RegexActionHandler {
+  private static _logger = getLogger('RegexActionHandler');
+
+  /**
+   * Applies the request host regex on the url
+   * @function _applyRegexAction
+   * @param {KalturaAccessControlModifyRequestHostRegexAction} regexAction - The regex action
+   * @param {string} url - The url to modify
+   * @returns {string} - The request host regex applied url
+   * @static
+   * @private
+   */
+  private static _applyRegexAction(regexAction: KalturaAccessControlModifyRequestHostRegexAction, url: string): string {
+    if (regexAction) {
+      const regex = new RegExp(regexAction.pattern, 'i');
+      if (url.match(regex)) {
+        return url.replace(regex, regexAction.replacement + '/');
+      }
+    }
+    return url;
+  }
+
+  /**
+   * Ping the ECDN url to check if alive
+   * @function _pingECDNUrl
+   * @param {KalturaAccessControlModifyRequestHostRegexAction} regexAction - The regex action
+   * @param {string} cdnUrl - The CDN url
+   * @returns {Promise<boolean>} - Whether the media config sources urls should be modified or not
+   * @static
+   * @private
+   */
+  private static async _isECDNUrlAlive(regexAction: KalturaAccessControlModifyRequestHostRegexAction, cdnUrl: string): Promise<boolean> {
+    const urlPing = cdnUrl + '/api_v3/service/system/action/ping/format/1';
+    const req = new XMLHttpRequest();
+    req.open('GET', urlPing);
+    req.timeout = regexAction.checkAliveTimeoutMs;
+    req.onreadystatechange = (): boolean => {
+      if (req.readyState === 4) {
+        if (req.status === 200) {
+          return true;
+        }
+        return false;
+      }
+      return false;
+    };
+    req.ontimeout = (): boolean => {
+      RegexActionHandler._logger.warn(`Got timeout while pinging the ECDN url. the ping url: ${urlPing}`);
+      return false;
+    };
+    req.send();
+    return false;
+  }
+
+  /**
+   * Handles regex action
+   * @function handleRegexAction
+   * @param {ProviderMediaConfigObject} mediaConfig - The media config
+   * @param {Map<string, Function>} rawResponse - The raw response data from backend
+   * @returns {Promise<ProviderMediaConfigObject>} - The media config with old or modified urls
+   * @static
+   */
+  public static async handleRegexAction(mediaConfig: ProviderMediaConfigObject, rawResponse: Map<string, ILoader>): Promise<ProviderMediaConfigObject> {
+    const cdnUrl = OVPConfiguration.get().cdnUrl;
+    const regexAction = RegexActionHandler._extractRegexActionFromData(rawResponse);
+    const regExp = RegexActionHandler._getRegExp(regexAction);
+
+    if (
+      cdnUrl &&
+      regexAction &&
+      regExp &&
+      cdnUrl.match(regExp) &&
+      // we need to make the replacement in all cases except for when the checkAliveTimeoutMs > 0 && the ping has failed
+      !(
+        regexAction.checkAliveTimeoutMs > 0 &&
+        !(await RegexActionHandler._isECDNUrlAlive(regexAction, cdnUrl.replace(regExp, regexAction.replacement)))
+      )
+    ) {
+      RegexActionHandler._replaceHostUrls(mediaConfig, regexAction);
+      return mediaConfig;
+    }
+
+    RegexActionHandler._logger.debug('exiting handleRegexAction - not applying regex action.');
+    return mediaConfig;
+  }
+
+  /**
+   * Modify the host urls - injects the configured cdn before the original host, to route requests
+   * @function _replaceHostUrls
+   * @param {ProviderMediaConfigObject} mediaConfig - The media config
+   * @param {KalturaAccessControlModifyRequestHostRegexAction} regexAction - The regex action
+   * @returns {void}
+   * @static
+   * @private
+   */
+  private static _replaceHostUrls(mediaConfig: ProviderMediaConfigObject, regexAction: KalturaAccessControlModifyRequestHostRegexAction): void {
+    RegexActionHandler._logger.debug('Starting to modify urls...');
+    const sources = mediaConfig.sources;
+    const {hls, dash, progressive, image} = sources;
+
+    [...hls, ...dash, ...progressive, ...image].forEach(src => (src.url = RegexActionHandler._applyRegexAction(regexAction, src.url)));
+
+    if (!OVPConfiguration.get().replaceHostOnlyManifestUrls) {
+      RegexActionHandler._logger.debug('replaceHostOnlyManifestUrls flag is off - modifying captions and poster URLs');
+      if (sources.captions) {
+        sources.captions.forEach(src => (src.url = RegexActionHandler._applyRegexAction(regexAction, src.url)));
+      }
+
+      // fix flow - poster can also be an array, but only for ott.
+      if (typeof sources.poster === 'string') {
+        sources.poster = RegexActionHandler._applyRegexAction(regexAction, sources.poster);
+      }
+    }
+    RegexActionHandler._logger.debug('Finished modifying urls');
+  }
+
+  /**
+   * Extracts the regex action from the data response
+   * @function _extractRegexActionFromData
+   * @param {Map<string, Function>} data - The response data
+   * @returns {KalturaAccessControlModifyRequestHostRegexAction} regexAction - The regex action
+   * @static
+   * @private
+   */
+  private static _extractRegexActionFromData(data: Map<string, ILoader>): KalturaAccessControlModifyRequestHostRegexAction | undefined {
+    return data.get(OVPMediaEntryLoader.id)?.response?.playBackContextResult.getRequestHostRegexAction();
+  }
+
+  /**
+   * Extracts the regex action from the data response
+   * @function _extractRegexActionFromData
+   * @param {KalturaAccessControlModifyRequestHostRegexAction} regexAction - The regex action
+   * @returns {RegExp} The regex expression
+   * @static
+   * @private
+   */
+  private static _getRegExp(regexAction: KalturaAccessControlModifyRequestHostRegexAction | undefined): RegExp | undefined {
+    if (regexAction && regexAction.pattern && regexAction.replacement) {
+      return new RegExp(regexAction.pattern, 'i');
+    }
+  }
+}
+
+export default RegexActionHandler;

package/src/k-provider/ovp/request-params/base-entry-response-profile.ts

@@ -0,0 +1,28 @@
+const FIELDS =
+  'id,referenceId,name,description,thumbnailUrl,dataUrl,duration,msDuration,flavorParamsIds,mediaType,type,tags,dvrStatus,externalSourceType,status,createdAt,updatedAt,endDate,plays,views,downloadUrl,creatorId';
+const RESPONSE_PROFILE_TYPE = {
+  INCLUDE_FIELDS: 1,
+  EXCLUDE_FIELDS: 2
+};
+export class BaseEntryResponseProfile {
+  public static Type: {[type: string]: number} = RESPONSE_PROFILE_TYPE;
+  /**
+   * @member - the response profile type
+   * @type {number}
+   */
+  public type: number;
+  /**
+   * @member - Comma separated fields list to be included or excluded
+   * @type {string}
+   */
+  public fields: string;
+
+  /**
+   * @constructor
+   * @param {Object} responseProfile -
+   */
+  constructor(responseProfile: any = {}) {
+    this.type = responseProfile.type || BaseEntryResponseProfile.Type.INCLUDE_FIELDS;
+    this.fields = responseProfile.fields || FIELDS;
+  }
+}

package/src/k-provider/ovp/response-types/index.ts

@@ -0,0 +1,21 @@
+import BaseServiceResult from '../../common/base-service-result';
+
+export {KalturaBaseEntryListResponse} from './kaltura-base-entry-list-response';
+export {KalturaMediaEntry} from './kaltura-media-entry';
+export {KalturaAccessControlModifyRequestHostRegexAction} from './kaltura-access-control-modify-request-host-regex-action';
+export {KalturaBumper} from './kaltura-bumper';
+export {KalturaFlavorAsset} from './kaltura-flavor-asset';
+export {KalturaMediaEntries} from './kaltura-media-entries';
+export {KalturaMetadata} from './kaltura-metadata';
+export {KalturaMetadataListResponse} from './kaltura-metadata-list-response';
+export {KalturaPlaybackContext} from './kaltura-playback-context';
+export {KalturaPlaybackSource} from './kaltura-playback-source';
+export {KalturaPlaylist} from './kaltura-playlist';
+export {KalturaRuleAction} from './kaltura-rule-action';
+export {KalturaUIConfResponse} from './kaltura-ui-conf-response';
+export {KalturaDrmPlaybackPluginData} from '../../common/response-types/kaltura-drm-playback-plugin-data';
+export {KalturaAccessControlMessage} from '../../common/response-types/kaltura-access-control-message';
+export {BaseServiceResult};
+export {KalturaUserEntry} from './kaltura-user-entry'
+export {KalturaUserEntryListResponse} from './kaltura-user-entry-list-response'
+

package/src/k-provider/ovp/response-types/kaltura-access-control-modify-request-host-regex-action.ts

@@ -0,0 +1,35 @@
+import {KalturaRuleAction} from './kaltura-rule-action';
+
+export class KalturaAccessControlModifyRequestHostRegexAction extends KalturaRuleAction {
+  /**
+   * @member - Request host regex pattern
+   * @type {string}
+   */
+  public pattern: string;
+  /**
+   * @member - Request host regex replacement
+   * @type {string}
+   */
+  public replacement: string;
+  /**
+   * @member - serverNodeId to generate replacment host from
+   * @type {number}
+   */
+  public replacmenServerNodeId: number;
+  /**
+   * @member - checkAliveTimeout in milliseconds
+   * @type {number}
+   */
+  public checkAliveTimeoutMs: number;
+  /**
+   * @constructor
+   * @param {Object} data - The response
+   */
+  constructor(data: any) {
+    super(data);
+    this.pattern = data.pattern;
+    this.replacement = data.replacement;
+    this.replacmenServerNodeId = data.replacmenServerNodeId;
+    this.checkAliveTimeoutMs = data.checkAliveTimeoutMs;
+  }
+}

package/src/k-provider/ovp/response-types/kaltura-base-entry-list-response.ts

@@ -0,0 +1,30 @@
+import ServiceResult from '../../common/base-service-result';
+import {KalturaMediaEntry} from './kaltura-media-entry';
+
+export class KalturaBaseEntryListResponse extends ServiceResult {
+  /**
+   * @member - The total count
+   * @type {number}
+   */
+  public totalCount!: number;
+  /**
+   * @member - The entries
+   * @type {Array<KalturaMediaEntry>}
+   */
+  public entries!: Array<KalturaMediaEntry>;
+
+  /**
+   * @constructor
+   * @param {Object} responseObj The json response
+   */
+  constructor(responseObj: any) {
+    super(responseObj);
+    if (!this.hasError) {
+      this.totalCount = responseObj.totalCount;
+      if (this.totalCount > 0) {
+        this.entries = [];
+        responseObj.objects.map(entry => this.entries.push(new KalturaMediaEntry(entry)));
+      }
+    }
+  }
+}

package/src/k-provider/ovp/response-types/kaltura-bumper.ts

@@ -0,0 +1,25 @@
+import {KalturaPlaybackSource} from './kaltura-playback-source';
+
+export class KalturaBumper {
+  /**
+   * @member - The bumper entry ID
+   * @type {string}
+   */
+  public entryId: string;
+  /**
+   * @member - The bumper click through url
+   * @type {string}
+   */
+  public clickThroughUrl: string;
+  /**
+   * @member - The bumper sources
+   * @type {Array<KalturaPlaybackSource>}
+   */
+  public sources: Array<KalturaPlaybackSource>;
+
+  constructor(data: any) {
+    this.entryId = data.entryId;
+    this.clickThroughUrl = data.url;
+    this.sources = data.sources ? data.sources.map(source => new KalturaPlaybackSource(source)) : [];
+  }
+}