@bitmovin/api-sdk 1.250.0 → 1.252.0

package/dist/common/RestClient.js

@@ -240,7 +240,7 @@ var HeaderHandler = /** @class */ (function (_super) {
         var headers = {
             'X-Api-Key': apiKey,
             'X-Api-Client': 'bitmovin-api-sdk-javascript',
-            'X-Api-Client-Version': '1.250.0',
+            'X-Api-Client-Version': '1.252.0',
             'Content-Type': 'application/json'
         };
         if (tenantOrgId) {

package/dist/encoding/encodings/live/LiveApi.d.ts

@@ -1,6 +1,7 @@
 import { BaseAPI } from '../../../common/BaseAPI';
 import Configuration from '../../../common/Configuration';
 import ResetLiveManifestTimeshiftApi from './resetLiveManifestTimeshift/ResetLiveManifestTimeshiftApi';
+import HeartbeatApi from './heartbeat/HeartbeatApi';
 import HdApi from './hd/HdApi';
 import InsertableContentApi from './insertableContent/InsertableContentApi';
 import Scte35CueApi from './scte35Cue/Scte35CueApi';
@@ -15,6 +16,7 @@ import StartLiveEncodingRequest from '../../../models/StartLiveEncodingRequest';
  */
 export default class LiveApi extends BaseAPI {
     resetLiveManifestTimeshift: ResetLiveManifestTimeshiftApi;
+    heartbeat: HeartbeatApi;
     hd: HdApi;
     insertableContent: InsertableContentApi;
     scte35Cue: Scte35CueApi;

package/dist/encoding/encodings/live/LiveApi.js

@@ -18,6 +18,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 var BaseAPI_1 = require("../../../common/BaseAPI");
 var Mapper_1 = require("../../../common/Mapper");
 var ResetLiveManifestTimeshiftApi_1 = require("./resetLiveManifestTimeshift/ResetLiveManifestTimeshiftApi");
+var HeartbeatApi_1 = require("./heartbeat/HeartbeatApi");
 var HdApi_1 = require("./hd/HdApi");
 var InsertableContentApi_1 = require("./insertableContent/InsertableContentApi");
 var Scte35CueApi_1 = require("./scte35Cue/Scte35CueApi");
@@ -35,6 +36,7 @@ var LiveApi = /** @class */ (function (_super) {
     function LiveApi(configuration) {
         var _this = _super.call(this, configuration) || this;
         _this.resetLiveManifestTimeshift = new ResetLiveManifestTimeshiftApi_1.default(configuration);
+        _this.heartbeat = new HeartbeatApi_1.default(configuration);
         _this.hd = new HdApi_1.default(configuration);
         _this.insertableContent = new InsertableContentApi_1.default(configuration);
         _this.scte35Cue = new Scte35CueApi_1.default(configuration);

package/dist/encoding/encodings/live/heartbeat/HeartbeatApi.d.ts

@@ -0,0 +1,19 @@
+import { BaseAPI } from '../../../../common/BaseAPI';
+import Configuration from '../../../../common/Configuration';
+import LiveEncodingHeartbeat from '../../../../models/LiveEncodingHeartbeat';
+/**
+ * HeartbeatApi - object-oriented interface
+ * @export
+ * @class HeartbeatApi
+ * @extends {BaseAPI}
+ */
+export default class HeartbeatApi extends BaseAPI {
+    constructor(configuration: Configuration);
+    /**
+     * @summary Live Encoding Heartbeat
+     * @param {string} encodingId Id of the encoding.
+     * @throws {BitmovinError}
+     * @memberof HeartbeatApi
+     */
+    get(encodingId: string): Promise<LiveEncodingHeartbeat>;
+}

package/dist/encoding/encodings/live/heartbeat/HeartbeatApi.js

@@ -0,0 +1,48 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+var BaseAPI_1 = require("../../../../common/BaseAPI");
+var Mapper_1 = require("../../../../common/Mapper");
+var LiveEncodingHeartbeat_1 = require("../../../../models/LiveEncodingHeartbeat");
+/**
+ * HeartbeatApi - object-oriented interface
+ * @export
+ * @class HeartbeatApi
+ * @extends {BaseAPI}
+ */
+var HeartbeatApi = /** @class */ (function (_super) {
+    __extends(HeartbeatApi, _super);
+    function HeartbeatApi(configuration) {
+        return _super.call(this, configuration) || this;
+    }
+    /**
+     * @summary Live Encoding Heartbeat
+     * @param {string} encodingId Id of the encoding.
+     * @throws {BitmovinError}
+     * @memberof HeartbeatApi
+     */
+    HeartbeatApi.prototype.get = function (encodingId) {
+        var pathParamMap = {
+            encoding_id: encodingId
+        };
+        return this.restClient.get('/encoding/encodings/{encoding_id}/live/heartbeat', pathParamMap).then(function (response) {
+            return (0, Mapper_1.map)(response, LiveEncodingHeartbeat_1.default);
+        });
+    };
+    return HeartbeatApi;
+}(BaseAPI_1.BaseAPI));
+exports.default = HeartbeatApi;

package/dist/models/AiSceneAnalysis.d.ts

@@ -1,16 +1,9 @@
 import AiSceneAnalysisFeatures from './AiSceneAnalysisFeatures';
-import AiService from './AiService';
 /**
  * @export
  * @class AiSceneAnalysis
  */
 export declare class AiSceneAnalysis {
-    /**
-     * AI service settings
-     * @type {AiService}
-     * @memberof AiSceneAnalysis
-     */
-    aiService?: AiService;
     /**
      * Features of the AI scene analysis
      * @type {AiSceneAnalysisFeatures}

package/dist/models/AiSceneAnalysis.js

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.AiSceneAnalysis = void 0;
 var Mapper_1 = require("../common/Mapper");
 var AiSceneAnalysisFeatures_1 = require("./AiSceneAnalysisFeatures");
-var AiService_1 = require("./AiService");
 /**
  * @export
  * @class AiSceneAnalysis
@@ -13,7 +12,6 @@ var AiSceneAnalysis = /** @class */ (function () {
         if (!obj) {
             return;
         }
-        this.aiService = (0, Mapper_1.map)(obj.aiService, AiService_1.default);
         this.features = (0, Mapper_1.map)(obj.features, AiSceneAnalysisFeatures_1.default);
     }
     return AiSceneAnalysis;

package/dist/models/DashManifest.d.ts

@@ -45,6 +45,12 @@ export declare class DashManifest extends Manifest {
      * @memberof DashManifest
      */
     iso8601TimestampFormat?: DashISO8601TimestampFormat;
+    /**
+     * The minimum buffer time in seconds that the client should maintain to ensure uninterrupted playback. Default is 2 seconds. Note: For VOD ON_DEMAND dash manifests, the default value may differ from 2.0 seconds if not explicitly set.
+     * @type {number}
+     * @memberof DashManifest
+     */
+    minBufferTime?: number;
     constructor(obj?: Partial<DashManifest>);
 }
 export default DashManifest;

package/dist/models/DashManifest.js

@@ -37,6 +37,7 @@ var DashManifest = /** @class */ (function (_super) {
         _this.utcTimings = (0, Mapper_1.mapArray)(obj.utcTimings, UtcTiming_1.default);
         _this.dashEditionCompatibility = (0, Mapper_1.map)(obj.dashEditionCompatibility);
         _this.iso8601TimestampFormat = (0, Mapper_1.map)(obj.iso8601TimestampFormat);
+        _this.minBufferTime = (0, Mapper_1.map)(obj.minBufferTime);
         return _this;
     }
     return DashManifest;

package/dist/models/LiveEncodingEventName.d.ts

@@ -8,6 +8,9 @@ export declare enum LiveEncodingEventName {
     RECONNECT = "RECONNECT",
     RESYNCING = "RESYNCING",
     IDLE = "IDLE",
-    ERROR = "ERROR"
+    ERROR = "ERROR",
+    WARNING = "WARNING",
+    PICTURE_TIMING = "PICTURE_TIMING",
+    INFO = "INFO"
 }
 export default LiveEncodingEventName;

package/dist/models/LiveEncodingEventName.js

@@ -13,5 +13,8 @@ var LiveEncodingEventName;
     LiveEncodingEventName["RESYNCING"] = "RESYNCING";
     LiveEncodingEventName["IDLE"] = "IDLE";
     LiveEncodingEventName["ERROR"] = "ERROR";
+    LiveEncodingEventName["WARNING"] = "WARNING";
+    LiveEncodingEventName["PICTURE_TIMING"] = "PICTURE_TIMING";
+    LiveEncodingEventName["INFO"] = "INFO";
 })(LiveEncodingEventName || (exports.LiveEncodingEventName = LiveEncodingEventName = {}));
 exports.default = LiveEncodingEventName;

package/dist/models/LiveEncodingHeartbeat.d.ts

@@ -0,0 +1,29 @@
+import LiveEncodingHeartbeatEvent from './LiveEncodingHeartbeatEvent';
+import LiveEncodingHeartbeatIngest from './LiveEncodingHeartbeatIngest';
+/**
+ * Heartbeat data for a Live Encoding.
+ * @export
+ * @class LiveEncodingHeartbeat
+ */
+export declare class LiveEncodingHeartbeat {
+    /**
+     * timestamp, returned as UTC expressed in ISO 8601 format: YYYY-MM-DDThh:mm:ssZ
+     * @type {Date}
+     * @memberof LiveEncodingHeartbeat
+     */
+    timestamp?: Date;
+    /**
+     * Information about the live ingestion status
+     * @type {LiveEncodingHeartbeatIngest}
+     * @memberof LiveEncodingHeartbeat
+     */
+    ingest?: LiveEncodingHeartbeatIngest;
+    /**
+     * Live encoding heartbeat events
+     * @type {LiveEncodingHeartbeatEvent[]}
+     * @memberof LiveEncodingHeartbeat
+     */
+    events?: LiveEncodingHeartbeatEvent[];
+    constructor(obj?: Partial<LiveEncodingHeartbeat>);
+}
+export default LiveEncodingHeartbeat;

package/dist/models/LiveEncodingHeartbeat.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LiveEncodingHeartbeat = void 0;
+var Mapper_1 = require("../common/Mapper");
+var LiveEncodingHeartbeatEvent_1 = require("./LiveEncodingHeartbeatEvent");
+var LiveEncodingHeartbeatIngest_1 = require("./LiveEncodingHeartbeatIngest");
+/**
+ * Heartbeat data for a Live Encoding.
+ * @export
+ * @class LiveEncodingHeartbeat
+ */
+var LiveEncodingHeartbeat = /** @class */ (function () {
+    function LiveEncodingHeartbeat(obj) {
+        if (!obj) {
+            return;
+        }
+        this.timestamp = (0, Mapper_1.map)(obj.timestamp, Date);
+        this.ingest = (0, Mapper_1.map)(obj.ingest, LiveEncodingHeartbeatIngest_1.default);
+        this.events = (0, Mapper_1.mapArray)(obj.events, LiveEncodingHeartbeatEvent_1.default);
+    }
+    return LiveEncodingHeartbeat;
+}());
+exports.LiveEncodingHeartbeat = LiveEncodingHeartbeat;
+exports.default = LiveEncodingHeartbeat;

package/dist/models/LiveEncodingHeartbeatEvent.d.ts

@@ -0,0 +1,20 @@
+import LiveEncodingHeartbeatEventDetails from './LiveEncodingHeartbeatEventDetails';
+/**
+ * @export
+ * @class LiveEncodingHeartbeatEvent
+ */
+export declare class LiveEncodingHeartbeatEvent {
+    /**
+     * Timestamp of the event, returned as UTC expressed in ISO 8601 format: YYYY-MM-DDThh:mm:ssZ (required)
+     * @type {Date}
+     * @memberof LiveEncodingHeartbeatEvent
+     */
+    time?: Date;
+    /**
+     * @type {LiveEncodingHeartbeatEventDetails}
+     * @memberof LiveEncodingHeartbeatEvent
+     */
+    details?: LiveEncodingHeartbeatEventDetails;
+    constructor(obj?: Partial<LiveEncodingHeartbeatEvent>);
+}
+export default LiveEncodingHeartbeatEvent;

package/dist/models/LiveEncodingHeartbeatEvent.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LiveEncodingHeartbeatEvent = void 0;
+var Mapper_1 = require("../common/Mapper");
+var LiveEncodingHeartbeatEventDetails_1 = require("./LiveEncodingHeartbeatEventDetails");
+/**
+ * @export
+ * @class LiveEncodingHeartbeatEvent
+ */
+var LiveEncodingHeartbeatEvent = /** @class */ (function () {
+    function LiveEncodingHeartbeatEvent(obj) {
+        if (!obj) {
+            return;
+        }
+        this.time = (0, Mapper_1.map)(obj.time, Date);
+        this.details = (0, Mapper_1.map)(obj.details, LiveEncodingHeartbeatEventDetails_1.default);
+    }
+    return LiveEncodingHeartbeatEvent;
+}());
+exports.LiveEncodingHeartbeatEvent = LiveEncodingHeartbeatEvent;
+exports.default = LiveEncodingHeartbeatEvent;

package/dist/models/LiveEncodingHeartbeatEventDetails.d.ts

@@ -0,0 +1,20 @@
+import LiveEncodingHeartbeatEventType from './LiveEncodingHeartbeatEventType';
+/**
+ * @export
+ * @class LiveEncodingHeartbeatEventDetails
+ */
+export declare class LiveEncodingHeartbeatEventDetails {
+    /**
+     * @type {LiveEncodingHeartbeatEventType}
+     * @memberof LiveEncodingHeartbeatEventDetails
+     */
+    eventType?: LiveEncodingHeartbeatEventType;
+    /**
+     * Short description of the event
+     * @type {string}
+     * @memberof LiveEncodingHeartbeatEventDetails
+     */
+    message?: string;
+    constructor(obj?: Partial<LiveEncodingHeartbeatEventDetails>);
+}
+export default LiveEncodingHeartbeatEventDetails;

package/dist/models/LiveEncodingHeartbeatEventDetails.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LiveEncodingHeartbeatEventDetails = void 0;
+var Mapper_1 = require("../common/Mapper");
+/**
+ * @export
+ * @class LiveEncodingHeartbeatEventDetails
+ */
+var LiveEncodingHeartbeatEventDetails = /** @class */ (function () {
+    function LiveEncodingHeartbeatEventDetails(obj) {
+        if (!obj) {
+            return;
+        }
+        this.eventType = (0, Mapper_1.map)(obj.eventType);
+        this.message = (0, Mapper_1.map)(obj.message);
+    }
+    return LiveEncodingHeartbeatEventDetails;
+}());
+exports.LiveEncodingHeartbeatEventDetails = LiveEncodingHeartbeatEventDetails;
+exports.default = LiveEncodingHeartbeatEventDetails;

package/dist/models/LiveEncodingHeartbeatEventType.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @export
+ * @enum {string}
+ */
+export declare enum LiveEncodingHeartbeatEventType {
+    FIRST_CONNECT = "FIRST_CONNECT",
+    DISCONNECT = "DISCONNECT",
+    RECONNECT = "RECONNECT",
+    WARNING = "WARNING",
+    ERROR = "ERROR"
+}
+export default LiveEncodingHeartbeatEventType;

package/dist/models/LiveEncodingHeartbeatEventType.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LiveEncodingHeartbeatEventType = void 0;
+/**
+ * @export
+ * @enum {string}
+ */
+var LiveEncodingHeartbeatEventType;
+(function (LiveEncodingHeartbeatEventType) {
+    LiveEncodingHeartbeatEventType["FIRST_CONNECT"] = "FIRST_CONNECT";
+    LiveEncodingHeartbeatEventType["DISCONNECT"] = "DISCONNECT";
+    LiveEncodingHeartbeatEventType["RECONNECT"] = "RECONNECT";
+    LiveEncodingHeartbeatEventType["WARNING"] = "WARNING";
+    LiveEncodingHeartbeatEventType["ERROR"] = "ERROR";
+})(LiveEncodingHeartbeatEventType || (exports.LiveEncodingHeartbeatEventType = LiveEncodingHeartbeatEventType = {}));
+exports.default = LiveEncodingHeartbeatEventType;

package/dist/models/LiveEncodingHeartbeatIngest.d.ts

@@ -0,0 +1,41 @@
+import LiveEncodingHeartbeatIngestPoint from './LiveEncodingHeartbeatIngestPoint';
+import LiveEncodingHeartbeatIngestStream from './LiveEncodingHeartbeatIngestStream';
+import LiveEncodingStatus from './LiveEncodingStatus';
+import RtmpUserIngestInfo from './RtmpUserIngestInfo';
+/**
+ * Information about the live ingestion status
+ * @export
+ * @class LiveEncodingHeartbeatIngest
+ */
+export declare class LiveEncodingHeartbeatIngest {
+    /**
+     * @type {LiveEncodingStatus}
+     * @memberof LiveEncodingHeartbeatIngest
+     */
+    status?: LiveEncodingStatus;
+    /**
+     * Indicates whether the ingest is healthy.
+     * @type {boolean}
+     * @memberof LiveEncodingHeartbeatIngest
+     */
+    healthy?: boolean;
+    /**
+     * Data about individual ingestPoints within the active live ingest.
+     * @type {LiveEncodingHeartbeatIngestPoint[]}
+     * @memberof LiveEncodingHeartbeatIngest
+     */
+    ingestPoints?: LiveEncodingHeartbeatIngestPoint[];
+    /**
+     * Data about individual streams within the active live ingest.
+     * @type {LiveEncodingHeartbeatIngestStream[]}
+     * @memberof LiveEncodingHeartbeatIngest
+     */
+    streams?: LiveEncodingHeartbeatIngestStream[];
+    /**
+     * @type {RtmpUserIngestInfo}
+     * @memberof LiveEncodingHeartbeatIngest
+     */
+    rtmpUserIngestInfo?: RtmpUserIngestInfo;
+    constructor(obj?: Partial<LiveEncodingHeartbeatIngest>);
+}
+export default LiveEncodingHeartbeatIngest;

package/dist/models/LiveEncodingHeartbeatIngest.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LiveEncodingHeartbeatIngest = void 0;
+var Mapper_1 = require("../common/Mapper");
+var LiveEncodingHeartbeatIngestPoint_1 = require("./LiveEncodingHeartbeatIngestPoint");
+var LiveEncodingHeartbeatIngestStream_1 = require("./LiveEncodingHeartbeatIngestStream");
+var RtmpUserIngestInfo_1 = require("./RtmpUserIngestInfo");
+/**
+ * Information about the live ingestion status
+ * @export
+ * @class LiveEncodingHeartbeatIngest
+ */
+var LiveEncodingHeartbeatIngest = /** @class */ (function () {
+    function LiveEncodingHeartbeatIngest(obj) {
+        if (!obj) {
+            return;
+        }
+        this.status = (0, Mapper_1.map)(obj.status);
+        this.healthy = (0, Mapper_1.map)(obj.healthy);
+        this.ingestPoints = (0, Mapper_1.mapArray)(obj.ingestPoints, LiveEncodingHeartbeatIngestPoint_1.default);
+        this.streams = (0, Mapper_1.mapArray)(obj.streams, LiveEncodingHeartbeatIngestStream_1.default);
+        this.rtmpUserIngestInfo = (0, Mapper_1.map)(obj.rtmpUserIngestInfo, RtmpUserIngestInfo_1.default);
+    }
+    return LiveEncodingHeartbeatIngest;
+}());
+exports.LiveEncodingHeartbeatIngest = LiveEncodingHeartbeatIngest;
+exports.default = LiveEncodingHeartbeatIngest;

package/dist/models/LiveEncodingHeartbeatIngestPoint.d.ts

@@ -0,0 +1,39 @@
+import InputType from './InputType';
+/**
+ * Details about an individual ingestPoint within the live ingest.
+ * @export
+ * @class LiveEncodingHeartbeatIngestPoint
+ */
+export declare class LiveEncodingHeartbeatIngestPoint {
+    /**
+     * The name of the ingestPoint of the original Input resource.
+     * @type {string}
+     * @memberof LiveEncodingHeartbeatIngestPoint
+     */
+    name?: string;
+    /**
+     * Id of the original Input resource. Note that multiple input points (main and backup) can be part of a single Input resource.
+     * @type {string}
+     * @memberof LiveEncodingHeartbeatIngestPoint
+     */
+    inputId?: string;
+    /**
+     * @type {InputType}
+     * @memberof LiveEncodingHeartbeatIngestPoint
+     */
+    inputType?: InputType;
+    /**
+     * Indicates whether this particular input is active.
+     * @type {boolean}
+     * @memberof LiveEncodingHeartbeatIngestPoint
+     */
+    isActive?: boolean;
+    /**
+     * Indicates whether this particular input is a backup input.
+     * @type {boolean}
+     * @memberof LiveEncodingHeartbeatIngestPoint
+     */
+    isBackup?: boolean;
+    constructor(obj?: Partial<LiveEncodingHeartbeatIngestPoint>);
+}
+export default LiveEncodingHeartbeatIngestPoint;

package/dist/models/LiveEncodingHeartbeatIngestPoint.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LiveEncodingHeartbeatIngestPoint = void 0;
+var Mapper_1 = require("../common/Mapper");
+/**
+ * Details about an individual ingestPoint within the live ingest.
+ * @export
+ * @class LiveEncodingHeartbeatIngestPoint
+ */
+var LiveEncodingHeartbeatIngestPoint = /** @class */ (function () {
+    function LiveEncodingHeartbeatIngestPoint(obj) {
+        if (!obj) {
+            return;
+        }
+        this.name = (0, Mapper_1.map)(obj.name);
+        this.inputId = (0, Mapper_1.map)(obj.inputId);
+        this.inputType = (0, Mapper_1.map)(obj.inputType);
+        this.isActive = (0, Mapper_1.map)(obj.isActive);
+        this.isBackup = (0, Mapper_1.map)(obj.isBackup);
+    }
+    return LiveEncodingHeartbeatIngestPoint;
+}());
+exports.LiveEncodingHeartbeatIngestPoint = LiveEncodingHeartbeatIngestPoint;
+exports.default = LiveEncodingHeartbeatIngestPoint;

package/dist/models/LiveEncodingHeartbeatIngestStream.d.ts

@@ -0,0 +1,117 @@
+/**
+ * Details about an individual stream within the live ingest.
+ * @export
+ * @class LiveEncodingHeartbeatIngestStream
+ */
+export declare class LiveEncodingHeartbeatIngestStream {
+    /**
+     * Unique identifier of the stream.
+     * @type {string}
+     * @memberof LiveEncodingHeartbeatIngestStream
+     */
+    streamId?: string;
+    /**
+     * Media type for the stream (e.g., \"video\" or \"audio\").
+     * @type {string}
+     * @memberof LiveEncodingHeartbeatIngestStream
+     */
+    mediaType?: string;
+    /**
+     * Width of the video stream in pixels.
+     * @type {number}
+     * @memberof LiveEncodingHeartbeatIngestStream
+     */
+    width?: number;
+    /**
+     * Height of the video stream in pixels.
+     * @type {number}
+     * @memberof LiveEncodingHeartbeatIngestStream
+     */
+    height?: number;
+    /**
+     * Frame rate of the video stream.
+     * @type {number}
+     * @memberof LiveEncodingHeartbeatIngestStream
+     */
+    rate?: number;
+    /**
+     * Codec of the stream.
+     * @type {string}
+     * @memberof LiveEncodingHeartbeatIngestStream
+     */
+    codec?: string;
+    /**
+     * Aspect ratio of the video.
+     * @type {string}
+     * @memberof LiveEncodingHeartbeatIngestStream
+     */
+    aspectRatio?: string;
+    /**
+     * Container format's bitrate of the stream, in bits per second.
+     * @type {number}
+     * @memberof LiveEncodingHeartbeatIngestStream
+     */
+    bitrate?: number;
+    /**
+     * Average number of samples/frames read per second.
+     * @type {number}
+     * @memberof LiveEncodingHeartbeatIngestStream
+     */
+    samplesReadPerSecondAvg?: number;
+    /**
+     * Incoming bitrate measured in bits per second.
+     * @type {number}
+     * @memberof LiveEncodingHeartbeatIngestStream
+     */
+    incomingBitrate?: number;
+    /**
+     * Largest encountered key-frame interval in milliseconds.
+     * @type {number}
+     * @memberof LiveEncodingHeartbeatIngestStream
+     */
+    keyFrameIntervalMax?: number;
+    /**
+     * Average key-frame interval in milliseconds.
+     * @type {number}
+     * @memberof LiveEncodingHeartbeatIngestStream
+     */
+    keyFrameIntervalAvg?: number;
+    /**
+     * Last presentation timestamp (PTS) of the stream.
+     * @type {number}
+     * @memberof LiveEncodingHeartbeatIngestStream
+     */
+    lastTimestamp?: number;
+    /**
+     * Timescale of lastTimestamp
+     * @type {number}
+     * @memberof LiveEncodingHeartbeatIngestStream
+     */
+    lastTimestampTimescale?: number;
+    /**
+     * Number of audio channels.
+     * @type {number}
+     * @memberof LiveEncodingHeartbeatIngestStream
+     */
+    numberOfAudioChannels?: number;
+    /**
+     * Format of the audio channel.
+     * @type {string}
+     * @memberof LiveEncodingHeartbeatIngestStream
+     */
+    audioChannelFormat?: string;
+    /**
+     * lastArrivalTime timestamp, returned as UTC expressed in ISO 8601 format: YYYY-MM-DDThh:mm:ssZ
+     * @type {Date}
+     * @memberof LiveEncodingHeartbeatIngestStream
+     */
+    lastArrivalTime?: Date;
+    /**
+     * Indicates whether this particular stream is healthy.
+     * @type {boolean}
+     * @memberof LiveEncodingHeartbeatIngestStream
+     */
+    healthy?: boolean;
+    constructor(obj?: Partial<LiveEncodingHeartbeatIngestStream>);
+}
+export default LiveEncodingHeartbeatIngestStream;

package/dist/models/LiveEncodingHeartbeatIngestStream.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LiveEncodingHeartbeatIngestStream = void 0;
+var Mapper_1 = require("../common/Mapper");
+/**
+ * Details about an individual stream within the live ingest.
+ * @export
+ * @class LiveEncodingHeartbeatIngestStream
+ */
+var LiveEncodingHeartbeatIngestStream = /** @class */ (function () {
+    function LiveEncodingHeartbeatIngestStream(obj) {
+        if (!obj) {
+            return;
+        }
+        this.streamId = (0, Mapper_1.map)(obj.streamId);
+        this.mediaType = (0, Mapper_1.map)(obj.mediaType);
+        this.width = (0, Mapper_1.map)(obj.width);
+        this.height = (0, Mapper_1.map)(obj.height);
+        this.rate = (0, Mapper_1.map)(obj.rate);
+        this.codec = (0, Mapper_1.map)(obj.codec);
+        this.aspectRatio = (0, Mapper_1.map)(obj.aspectRatio);
+        this.bitrate = (0, Mapper_1.map)(obj.bitrate);
+        this.samplesReadPerSecondAvg = (0, Mapper_1.map)(obj.samplesReadPerSecondAvg);
+        this.incomingBitrate = (0, Mapper_1.map)(obj.incomingBitrate);
+        this.keyFrameIntervalMax = (0, Mapper_1.map)(obj.keyFrameIntervalMax);
+        this.keyFrameIntervalAvg = (0, Mapper_1.map)(obj.keyFrameIntervalAvg);
+        this.lastTimestamp = (0, Mapper_1.map)(obj.lastTimestamp);
+        this.lastTimestampTimescale = (0, Mapper_1.map)(obj.lastTimestampTimescale);
+        this.numberOfAudioChannels = (0, Mapper_1.map)(obj.numberOfAudioChannels);
+        this.audioChannelFormat = (0, Mapper_1.map)(obj.audioChannelFormat);
+        this.lastArrivalTime = (0, Mapper_1.map)(obj.lastArrivalTime, Date);
+        this.healthy = (0, Mapper_1.map)(obj.healthy);
+    }
+    return LiveEncodingHeartbeatIngestStream;
+}());
+exports.LiveEncodingHeartbeatIngestStream = LiveEncodingHeartbeatIngestStream;
+exports.default = LiveEncodingHeartbeatIngestStream;