@playkit-js/playkit-js-providers 2.39.1 → 2.39.2

package/src/k-provider/ott/provider-parser.js

@@ -1,282 +0,0 @@
-//@flow
-import getLogger from '../../util/logger';
-import KalturaPlaybackSource from './response-types/kaltura-playback-source';
-import KalturaPlaybackContext from './response-types/kaltura-playback-context';
-import KalturaAsset from './response-types/kaltura-asset';
-import MediaEntry from '../../entities/media-entry';
-import Drm from '../../entities/drm';
-import MediaSource from '../../entities/media-source';
-import MediaSources from '../../entities/media-sources';
-import EntryList from '../../entities/entry-list';
-import Bumper from '../../entities/bumper';
-import {SupportedStreamFormat, isProgressiveSource} from '../../entities/media-format';
-import {KalturaDrmPlaybackPluginData} from '../common/response-types/kaltura-drm-playback-plugin-data';
-import KalturaRuleAction from './response-types/kaltura-rule-action';
-import {KalturaAccessControlMessage} from '../common/response-types/kaltura-access-control-message';
-import type {OTTAssetLoaderResponse} from './loaders/asset-loader';
-import KalturaBumpersPlaybackPluginData from './response-types/kaltura-bumper-playback-plugin-data';
-
-const LIVE_ASST_OBJECT_TYPE: string = 'KalturaLiveAsset';
-
-const MediaTypeCombinations: {[mediaType: string]: Object} = {
-  [KalturaAsset.Type.MEDIA]: {
-    [KalturaPlaybackContext.Type.TRAILER]: () => ({type: MediaEntry.Type.VOD}),
-    [KalturaPlaybackContext.Type.PLAYBACK]: mediaAssetData => {
-      if (mediaAssetData.objectType === LIVE_ASST_OBJECT_TYPE) {
-        return {type: MediaEntry.Type.LIVE, dvrStatus: mediaAssetData.enableTrickPlay ? MediaEntry.DvrStatus.ON : MediaEntry.DvrStatus.OFF};
-      } else if (parseInt(mediaAssetData.externalIds) > 0) {
-        return {type: MediaEntry.Type.LIVE, dvrStatus: MediaEntry.DvrStatus.OFF};
-      }
-      return {type: MediaEntry.Type.VOD};
-    }
-  },
-  [KalturaAsset.Type.EPG]: {
-    [KalturaPlaybackContext.Type.CATCHUP]: () => ({type: MediaEntry.Type.VOD}),
-    [KalturaPlaybackContext.Type.START_OVER]: () => ({type: MediaEntry.Type.LIVE, dvrStatus: MediaEntry.DvrStatus.ON})
-  },
-  [KalturaAsset.Type.RECORDING]: {
-    [KalturaPlaybackContext.Type.PLAYBACK]: () => ({type: MediaEntry.Type.VOD})
-  }
-};
-
-export default class OTTProviderParser {
-  static _logger = getLogger('OTTProviderParser');
-
-  /**
-   * Returns parsed media entry by given OTT response objects.
-   * @function getMediaEntry
-   * @param {any} assetResponse - The asset response.
-   * @param {Object} requestData - The request data object.
-   * @returns {MediaEntry} - The media entry
-   * @static
-   * @public
-   */
-  static getMediaEntry(assetResponse: any, requestData: Object): MediaEntry {
-    const mediaEntry = new MediaEntry();
-    OTTProviderParser._fillBaseData(mediaEntry, assetResponse, requestData);
-    const playbackContext = assetResponse.playBackContextResult;
-    const mediaAsset = assetResponse.mediaDataResult;
-    const kalturaSources = playbackContext.sources;
-    const filteredKalturaSources = OTTProviderParser._filterSourcesByFormats(kalturaSources, requestData.formats);
-    mediaEntry.sources = OTTProviderParser._getParsedSources(filteredKalturaSources);
-    const typeData = OTTProviderParser._getMediaType(mediaAsset.data, requestData.mediaType, requestData.contextType);
-    mediaEntry.type = typeData.type;
-    mediaEntry.dvrStatus = typeData.dvrStatus;
-    mediaEntry.duration = Math.max.apply(
-      Math,
-      kalturaSources.map(source => source.duration)
-    );
-    return mediaEntry;
-  }
-
-  /**
-   * Returns parsed entry list by given OTT response objects
-   * @function getEntryList
-   * @param {any} playlistResponse - response
-   * @param {Array<ProviderMediaInfoObject>} requestEntries - entries list
-   * @returns {Playlist} - The entry list
-   * @static
-   * @public
-   */
-  static getEntryList(playlistResponse: any, requestEntries: Array<ProviderMediaInfoObject>): EntryList {
-    const entryList = new EntryList();
-    const playlistItems = playlistResponse.playlistItems.entries;
-    playlistItems.forEach(entry => {
-      const mediaEntry = new MediaEntry();
-      const requestData = requestEntries.find(requestEntry => requestEntry.entryId === entry.mediaDataResult.id);
-      OTTProviderParser._fillBaseData(mediaEntry, entry, requestData);
-      entryList.items.push(mediaEntry);
-    });
-    return entryList;
-  }
-
-  /**
-   * Returns parsed bumper by given OTT response objects.
-   * @function getBumper
-   * @param {any} assetResponse - The asset response.
-   * @returns {?Bumper} - The bumper
-   * @static
-   * @public
-   */
-  static getBumper(assetResponse: any): ?Bumper {
-    const playbackContext = assetResponse.playBackContextResult;
-    const progressiveBumper = playbackContext.plugins.find(
-      bumper => bumper.streamertype === KalturaBumpersPlaybackPluginData.StreamerType.PROGRESSIVE
-    );
-    if (progressiveBumper) {
-      return new Bumper(progressiveBumper);
-    }
-  }
-
-  static _fillBaseData(mediaEntry: MediaEntry, assetResponse: any, requestData: any) {
-    const mediaAsset = assetResponse.mediaDataResult;
-    const metaData = OTTProviderParser.reconstructMetadata(mediaAsset);
-    metaData.description = mediaAsset.description;
-    metaData.name = mediaAsset.name;
-    if (mediaAsset.data.entryId) metaData.entryId = mediaAsset.data.entryId;
-    if (mediaAsset.data.epgId) metaData.epgId = mediaAsset.data.epgId;
-    if (mediaAsset.data.recordingId) metaData.recordingId = mediaAsset.data.recordingId;
-    if (requestData && requestData.mediaType) metaData.mediaType = requestData.mediaType;
-    if (requestData && requestData.contextType) metaData.contextType = requestData.contextType;
-    mediaEntry.metadata = metaData;
-    mediaEntry.poster = OTTProviderParser._getPoster(mediaAsset.pictures);
-    mediaEntry.id = mediaAsset.id;
-    return mediaEntry;
-  }
-
-  /**
-   * reconstruct the metadata
-   * @param {Object} mediaAsset the mediaAsset that contains the response with the metadata.
-   * @returns {Object} reconstructed metadata object
-   */
-  static reconstructMetadata(mediaAsset: Object): Object {
-    const metadata = {
-      metas: OTTProviderParser.addToMetaObject(mediaAsset.metas),
-      tags: OTTProviderParser.addToMetaObject(mediaAsset.tags)
-    };
-    return metadata;
-  }
-
-  /**
-   * transform an array of [{key: value},{key: value}...] to an object
-   * @param {Array<Object>} list a list of objects
-   * @returns {Object} an mapped object of the arrayed list.
-   */
-  static addToMetaObject(list: Array<Object>): Object {
-    let categoryObj = {};
-    if (list) {
-      list.forEach(item => {
-        categoryObj[item.key] = item.value;
-      });
-    }
-    return categoryObj;
-  }
-
-  /**
-   * Gets the poster url without width and height.
-   * @param {Array<Object>} pictures - Media pictures.
-   * @returns {string | Array<Object>} - Poster base url or array of poster candidates.
-   * @private
-   */
-  static _getPoster(pictures: Array<Object>): string | Array<Object> {
-    if (pictures && pictures.length > 0) {
-      const picObj = pictures[0];
-      const url = picObj.url;
-      // Search for thumbnail service
-      const regex = /.*\/thumbnail\/.*(?:width|height)\/\d+\/(?:height|width)\/\d+/;
-      if (regex.test(url)) {
-        return url;
-      }
-      return pictures.map(pic => ({url: pic.url, width: pic.width, height: pic.height}));
-    }
-    return '';
-  }
-
-  /**
-   * Gets the media type (LIVE/VOD)
-   * @param {Object} mediaAssetData - The media asset data.
-   * @param {string} mediaType - The asset media type.
-   * @param {string} contextType - The asset context type.
-   * @returns {Object} - The type data object.
-   * @private
-   */
-  static _getMediaType(mediaAssetData: Object, mediaType: string, contextType: string): Object {
-    let typeData = {type: MediaEntry.Type.UNKNOWN};
-    if (MediaTypeCombinations[mediaType] && MediaTypeCombinations[mediaType][contextType]) {
-      typeData = MediaTypeCombinations[mediaType][contextType](mediaAssetData);
-    }
-    return typeData;
-  }
-
-  /**
-   * Filtered the kalturaSources array by device type.
-   * @param {Array<KalturaPlaybackSource>} kalturaSources - The kaltura sources.
-   * @param {Array<string>} formats - Partner device formats.
-   * @returns {Array<KalturaPlaybackSource>} - Filtered kalturaSources array.
-   * @private
-   */
-  static _filterSourcesByFormats(kalturaSources: Array<KalturaPlaybackSource>, formats: Array<string>): Array<KalturaPlaybackSource> {
-    if (formats.length > 0) {
-      kalturaSources = kalturaSources.filter(source => formats.includes(source.type));
-    }
-    return kalturaSources;
-  }
-
-  /**
-   * Returns the parsed sources
-   * @function _getParsedSources
-   * @param {Array<KalturaPlaybackSource>} kalturaSources - The kaltura sources
-   * @param {Object} playbackContext - The playback context
-   * @return {MediaSources} - A media sources
-   * @static
-   * @private
-   */
-  static _getParsedSources(kalturaSources: Array<KalturaPlaybackSource>): MediaSources {
-    const sources = new MediaSources();
-    const addAdaptiveSource = (source: KalturaPlaybackSource) => {
-      const parsedSource = OTTProviderParser._parseAdaptiveSource(source);
-      if (parsedSource) {
-        const sourceFormat = SupportedStreamFormat.get(source.format);
-        sources.map(parsedSource, sourceFormat);
-      }
-    };
-    const parseAdaptiveSources = () => {
-      kalturaSources.filter(source => !isProgressiveSource(source.format)).forEach(addAdaptiveSource);
-    };
-    const parseProgressiveSources = () => {
-      kalturaSources.filter(source => isProgressiveSource(source.format)).forEach(addAdaptiveSource);
-    };
-    if (kalturaSources && kalturaSources.length > 0) {
-      parseAdaptiveSources();
-      parseProgressiveSources();
-    }
-    return sources;
-  }
-
-  /**
-   * Returns a parsed adaptive source
-   * @function _parseAdaptiveSource
-   * @param {KalturaPlaybackSource} kalturaSource - A kaltura source
-   * @returns {?MediaSource} - The parsed adaptive kalturaSource
-   * @static
-   * @private
-   */
-  static _parseAdaptiveSource(kalturaSource: ?KalturaPlaybackSource): ?MediaSource {
-    const mediaSource = new MediaSource();
-    if (kalturaSource) {
-      const playUrl = kalturaSource.url;
-      const mediaFormat = SupportedStreamFormat.get(kalturaSource.format);
-      if (mediaFormat) {
-        mediaSource.mimetype = mediaFormat.mimeType;
-      }
-      if (!playUrl) {
-        OTTProviderParser._logger.error(
-          `failed to create play url from source, discarding source: (${kalturaSource.fileId}), ${kalturaSource.format}.`
-        );
-        return null;
-      }
-      mediaSource.url = playUrl;
-      mediaSource.id = kalturaSource.fileId + ',' + kalturaSource.format;
-      if (kalturaSource.hasDrmData()) {
-        const drmParams: Array<Drm> = [];
-        kalturaSource.drm.forEach(drm => {
-          drmParams.push(new Drm(drm.licenseURL, KalturaDrmPlaybackPluginData.Scheme[drm.scheme], drm.certificate));
-        });
-        mediaSource.drmData = drmParams;
-      }
-    }
-    return mediaSource;
-  }
-
-  static hasBlockAction(response: OTTAssetLoaderResponse): boolean {
-    return response.playBackContextResult.hasBlockAction();
-  }
-
-  static getBlockAction(response: OTTAssetLoaderResponse): ?KalturaRuleAction {
-    return response.playBackContextResult.getBlockAction();
-  }
-
-  static getErrorMessages(response: OTTAssetLoaderResponse): Array<KalturaAccessControlMessage> {
-    return response.playBackContextResult.getErrorMessages();
-  }
-}

package/src/k-provider/ott/provider.js

@@ -1,242 +0,0 @@
-// @flow
-import BaseProvider from '../common/base-provider';
-import getLogger from '../../util/logger';
-import OTTConfiguration from './config';
-import OTTDataLoaderManager from './loaders/data-loader-manager';
-import OTTSessionLoader from './loaders/session-loader';
-import OTTAssetLoader from './loaders/asset-loader';
-import OTTAssetListLoader from './loaders/asset-list-loader';
-import OTTProviderParser from './provider-parser';
-import KalturaAsset from './response-types/kaltura-asset';
-import KalturaPlaybackContext from './response-types/kaltura-playback-context';
-import MediaEntry from '../../entities/media-entry';
-import Error from '../../util/error/error';
-
-export default class OTTProvider extends BaseProvider<OTTProviderMediaInfoObject> {
-  /**
-   * @constructor
-   * @param {ProviderOptionsObject} options - provider options
-   * @param {string} playerVersion - player version
-   */
-  constructor(options: ProviderOptionsObject, playerVersion: string) {
-    super(options, playerVersion);
-    this._logger = getLogger('OTTProvider');
-    OTTConfiguration.set(options.env);
-    this._networkRetryConfig = Object.assign(this._networkRetryConfig, options.networkRetryParameters);
-  }
-
-  get env() {
-    return OTTConfiguration.get();
-  }
-
-  /**
-   * Gets the backend media config.
-   * @param {OTTProviderMediaInfoObject} mediaInfo - ott media info
-   * @returns {Promise<ProviderMediaConfigObject>} - The provider media config
-   */
-  getMediaConfig(mediaInfo: OTTProviderMediaInfoObject): Promise<ProviderMediaConfigObject> {
-    if (mediaInfo.ks) {
-      this.ks = mediaInfo.ks;
-      this._isAnonymous = false;
-    }
-    this._dataLoader = new OTTDataLoaderManager(this.partnerId, this.ks, this._networkRetryConfig);
-    return new Promise((resolve, reject) => {
-      const entryId = mediaInfo.entryId;
-      if (entryId) {
-        let ks: string = this.ks;
-        if (!ks) {
-          ks = '{1:result:ks}';
-          this._dataLoader.add(OTTSessionLoader, {partnerId: this.partnerId});
-        }
-        const contextType = mediaInfo.contextType || KalturaPlaybackContext.Type.PLAYBACK;
-        const mediaType = mediaInfo.mediaType || KalturaAsset.Type.MEDIA;
-        const assetReferenceType = mediaInfo.assetReferenceType || KalturaAsset.AssetReferenceType.MEDIA;
-        const playbackContext: ProviderPlaybackContextOptions = {
-          mediaProtocol: mediaInfo.protocol,
-          assetFileIds: mediaInfo.fileIds,
-          context: contextType
-        };
-        if (mediaInfo.streamerType) {
-          playbackContext.streamerType = mediaInfo.streamerType;
-        }
-        if (mediaInfo.urlType) {
-          playbackContext.urlType = mediaInfo.urlType;
-        }
-        if (mediaInfo.adapterData) {
-          playbackContext.adapterData = mediaInfo.adapterData;
-        }
-        this._dataLoader.add(OTTAssetLoader, {
-          entryId: entryId,
-          ks: ks,
-          type: mediaType,
-          playbackContext: playbackContext,
-          assetReferenceType: assetReferenceType
-        });
-        const requestData = {
-          contextType: contextType,
-          mediaType: mediaType,
-          formats: mediaInfo.formats || []
-        };
-        return this._dataLoader.fetchData().then(
-          response => {
-            try {
-              resolve(this._parseDataFromResponse(response, requestData));
-            } 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'}));
-      }
-    });
-  }
-
-  _parseDataFromResponse(data: Map<string, Function>, requestData: Object): ProviderMediaConfigObject {
-    this._logger.debug('Data parsing started');
-    const mediaConfig: ProviderMediaConfigObject = {
-      session: {
-        isAnonymous: this._isAnonymous,
-        partnerId: this.partnerId
-      },
-      sources: this._getDefaultSourcesObject(),
-      plugins: {}
-    };
-    if (this.uiConfId) {
-      mediaConfig.session.uiConfId = this.uiConfId;
-    }
-    if (data) {
-      if (data.has(OTTSessionLoader.id)) {
-        const sessionLoader = data.get(OTTSessionLoader.id);
-        if (sessionLoader && sessionLoader.response) {
-          mediaConfig.session.ks = sessionLoader.response;
-        }
-      } else {
-        mediaConfig.session.ks = this.ks;
-      }
-      if (data.has(OTTAssetLoader.id)) {
-        const assetLoader = data.get(OTTAssetLoader.id);
-        if (assetLoader && assetLoader.response && Object.keys(assetLoader.response).length) {
-          const response = (assetLoader: OTTAssetLoader).response;
-          if (OTTProviderParser.hasBlockAction(response)) {
-            throw new Error(Error.Severity.CRITICAL, Error.Category.SERVICE, Error.Code.BLOCK_ACTION, {
-              action: OTTProviderParser.getBlockAction(response),
-              messages: OTTProviderParser.getErrorMessages(response)
-            });
-          }
-          const mediaEntry = OTTProviderParser.getMediaEntry(response, requestData);
-          Object.assign(mediaConfig.sources, this._getSourcesObject(mediaEntry));
-          this._verifyHasSources(mediaConfig.sources);
-          const bumper = OTTProviderParser.getBumper(response);
-          if (bumper) {
-            Object.assign(mediaConfig.plugins, {bumper});
-          }
-        }
-      }
-    }
-    this._logger.debug('Data parsing finished', mediaConfig);
-    return mediaConfig;
-  }
-
-  /**
-   * Gets playlist config from entry list.
-   * @param {ProviderEntryListObject} entryListInfo - ott entry list info
-   * @returns {Promise<ProviderPlaylistObject>} - The provider playlist config
-   */
-  getEntryListConfig(entryListInfo: ProviderEntryListObject): Promise<ProviderPlaylistObject> {
-    if (entryListInfo.ks) {
-      this.ks = entryListInfo.ks;
-      this._isAnonymous = false;
-    }
-    this._dataLoader = new OTTDataLoaderManager(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(OTTSessionLoader, {partnerId: this.partnerId});
-        }
-        this._dataLoader.add(OTTAssetListLoader, {entries, ks});
-        this._dataLoader.fetchData(false).then(
-          response => {
-            resolve(this._parseEntryListDataFromResponse(response, entries));
-          },
-          err => {
-            reject(err);
-          }
-        );
-      } else {
-        reject({success: false, data: 'Missing mandatory parameter'});
-      }
-    });
-  }
-
-  _parseEntryListDataFromResponse(data: Map<string, Function>, requestEntries: Array<ProviderMediaInfoObject>): ProviderPlaylistObject {
-    this._logger.debug('Data parsing started');
-    const playlistConfig: ProviderPlaylistObject = {
-      id: '',
-      metadata: {
-        name: '',
-        description: ''
-      },
-      poster: '',
-      items: []
-    };
-    if (data && data.has(OTTAssetListLoader.id)) {
-      const playlistLoader = data.get(OTTAssetListLoader.id);
-      if (playlistLoader && playlistLoader.response) {
-        const entryList = OTTProviderParser.getEntryList(playlistLoader.response, requestEntries);
-        entryList.items.forEach(i => playlistConfig.items.push({sources: this._getSourcesObject(i)}));
-      }
-    }
-    this._logger.debug('Data parsing finished', playlistConfig);
-    return playlistConfig;
-  }
-
-  _getDefaultSourcesObject(): ProviderMediaConfigSourcesObject {
-    return {
-      hls: [],
-      dash: [],
-      progressive: [],
-      image: [],
-      id: '',
-      duration: 0,
-      type: MediaEntry.Type.UNKNOWN,
-      poster: '',
-      dvr: false,
-      vr: null,
-      metadata: {
-        name: '',
-        description: '',
-        tags: ''
-      }
-    };
-  }
-
-  _getSourcesObject(mediaEntry: MediaEntry) {
-    const sourcesObject: ProviderMediaConfigSourcesObject = this._getDefaultSourcesObject();
-    const mediaSources = mediaEntry.sources.toJSON();
-    sourcesObject.hls = mediaSources.hls;
-    sourcesObject.dash = mediaSources.dash;
-    sourcesObject.progressive = mediaSources.progressive;
-    sourcesObject.id = mediaEntry.id;
-    sourcesObject.duration = mediaEntry.duration;
-    sourcesObject.type = mediaEntry.type;
-    sourcesObject.dvr = !!mediaEntry.dvrStatus;
-    sourcesObject.poster = mediaEntry.poster;
-    if (
-      mediaEntry.metadata &&
-      mediaEntry.metadata.metas &&
-      typeof mediaEntry.metadata.metas.tags === 'string' &&
-      mediaEntry.metadata.metas.tags.indexOf('360') > -1
-    ) {
-      sourcesObject.vr = {};
-    }
-    Object.assign(sourcesObject.metadata, mediaEntry.metadata);
-    return sourcesObject;
-  }
-}

package/src/k-provider/ott/response-types/kaltura-asset.js

@@ -1,79 +0,0 @@
-//@flow
-import ServiceResult from '../../common/base-service-result';
-
-export default class KalturaAsset extends ServiceResult {
-  static Type: {[type: string]: string} = {
-    MEDIA: 'media',
-    RECORDING: 'recording',
-    EPG: 'epg'
-  };
-
-  static AssetReferenceType: {[type: string]: string} = {
-    MEDIA: 'media',
-    EPG_INTERNAL: 'epg_internal',
-    EPG_EXTERNAL: 'epg_external',
-    NPVR: 'nPVR'
-  };
-  /**
-   * @member - The asset id
-   * @type {number}
-   */
-  id: number;
-  /**
-   * @member - The asset name
-   * @type {string}
-   */
-  name: string = '';
-  /**
-   * @member - The asset name description
-   * @type {string}
-   */
-  description: string = '';
-  /**
-   * @member - The asset tags
-   * @type {Array<Object>}
-   */
-  tags: Array<Object> = [];
-  /**
-   * @member - The asset metas
-   * @type {Array<Object>}
-   */
-  metas: Array<Object> = [];
-  /**
-   * @member - The asset images
-   * @type {Array<any>}
-   */
-  pictures: Array<any> = [];
-
-  /**
-   * @constructor
-   * @param {Object} response The response
-   */
-  constructor(response: Object) {
-    super(response);
-    if (!this.hasError) {
-      this.id = response.id;
-      this.name = response.name;
-      this.description = response.description;
-      this.metas = this._formatTagsMetas(response.metas);
-      this.tags = this._formatTagsMetas(response.tags);
-      this.pictures = response.images;
-    }
-  }
-
-  _formatTagsMetas(objectToParse: any): Array<Object> {
-    const parsed = [];
-    Object.keys(objectToParse).forEach(function (key) {
-      if (objectToParse[key].objects) {
-        let value = '';
-        objectToParse[key].objects.forEach(function (object) {
-          value += object.value + '|';
-        });
-        parsed.push({key: key, value: value});
-      } else {
-        parsed.push({key: key, value: objectToParse[key].value});
-      }
-    });
-    return parsed;
-  }
-}

package/src/k-provider/ott/response-types/kaltura-bumper-playback-plugin-data.js

@@ -1,28 +0,0 @@
-//@flow
-export default class KalturaBumpersPlaybackPluginData {
-  static StreamerType: {[type: string]: string} = {
-    HLS: 'hls',
-    DASH: 'dash',
-    PROGRESSIVE: 'progressive'
-  };
-
-  /**
-   * @member - The streamer type
-   * @type {string}
-   */
-  streamertype: string;
-  /**
-   * @member - The url
-   * @type {string}
-   */
-  url: string;
-
-  /**
-   * @constructor
-   * @param {Object} data - The response
-   */
-  constructor(data: Object) {
-    this.streamertype = data.streamertype;
-    this.url = data.url;
-  }
-}