@bitmovin/api-sdk 1.211.0 → 1.212.0

package/dist/encoding/live/standbyPools/logs/LogsApi.js

@@ -0,0 +1,57 @@
+"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 LiveStandbyPoolEventLog_1 = require("../../../../models/LiveStandbyPoolEventLog");
+var PaginationResponse_1 = require("../../../../models/PaginationResponse");
+var LiveStandbyPoolEventLogListQueryParams_1 = require("./LiveStandbyPoolEventLogListQueryParams");
+/**
+ * LogsApi - object-oriented interface
+ * @export
+ * @class LogsApi
+ * @extends {BaseAPI}
+ */
+var LogsApi = /** @class */ (function (_super) {
+    __extends(LogsApi, _super);
+    function LogsApi(configuration) {
+        return _super.call(this, configuration) || this;
+    }
+    /**
+     * @summary List event logs for a standby pool
+     * @param {string} poolId Id of the standby pool
+     * @param {*} [queryParameters] query parameters for filtering, sorting and pagination
+     * @throws {BitmovinError}
+     * @memberof LogsApi
+     */
+    LogsApi.prototype.list = function (poolId, queryParameters) {
+        var pathParamMap = {
+            pool_id: poolId
+        };
+        var queryParams = {};
+        if (typeof queryParameters === 'function') {
+            queryParams = queryParameters(new LiveStandbyPoolEventLogListQueryParams_1.LiveStandbyPoolEventLogListQueryParamsBuilder()).buildQueryParams();
+        }
+        else if (queryParameters) {
+            queryParams = queryParameters;
+        }
+        return this.restClient.get('/encoding/live/standby-pools/{pool_id}/logs', pathParamMap, queryParams).then(function (response) {
+            return new PaginationResponse_1.default(response, LiveStandbyPoolEventLog_1.default);
+        });
+    };
+    return LogsApi;
+}(BaseAPI_1.BaseAPI));
+exports.default = LogsApi;

package/dist/models/LiveStandbyPoolDetails.d.ts

@@ -0,0 +1,15 @@
+import LiveStandbyPoolResponse from './LiveStandbyPoolResponse';
+/**
+ * @export
+ * @class LiveStandbyPoolDetails
+ */
+export declare class LiveStandbyPoolDetails extends LiveStandbyPoolResponse {
+    /**
+     * Base64 encoded template used to start the encodings in the pool
+     * @type {string}
+     * @memberof LiveStandbyPoolDetails
+     */
+    encodingTemplate?: string;
+    constructor(obj?: Partial<LiveStandbyPoolDetails>);
+}
+export default LiveStandbyPoolDetails;

package/dist/models/LiveStandbyPoolDetails.js

@@ -0,0 +1,38 @@
+"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 });
+exports.LiveStandbyPoolDetails = void 0;
+var Mapper_1 = require("../common/Mapper");
+var LiveStandbyPoolResponse_1 = require("./LiveStandbyPoolResponse");
+/**
+ * @export
+ * @class LiveStandbyPoolDetails
+ */
+var LiveStandbyPoolDetails = /** @class */ (function (_super) {
+    __extends(LiveStandbyPoolDetails, _super);
+    function LiveStandbyPoolDetails(obj) {
+        var _this = _super.call(this, obj) || this;
+        if (!obj) {
+            return _this;
+        }
+        _this.encodingTemplate = (0, Mapper_1.map)(obj.encodingTemplate);
+        return _this;
+    }
+    return LiveStandbyPoolDetails;
+}(LiveStandbyPoolResponse_1.default));
+exports.LiveStandbyPoolDetails = LiveStandbyPoolDetails;
+exports.default = LiveStandbyPoolDetails;

package/dist/models/LiveStandbyPoolEncoding.d.ts

@@ -0,0 +1,47 @@
+import LiveStandbyPoolEncodingIngestPoint from './LiveStandbyPoolEncodingIngestPoint';
+import LiveStandbyPoolEncodingManifest from './LiveStandbyPoolEncodingManifest';
+import LiveStandbyPoolEncodingStatus from './LiveStandbyPoolEncodingStatus';
+/**
+ * @export
+ * @class LiveStandbyPoolEncoding
+ */
+export declare class LiveStandbyPoolEncoding {
+    /**
+     * @type {string}
+     * @memberof LiveStandbyPoolEncoding
+     */
+    id?: string;
+    /**
+     * @type {string}
+     * @memberof LiveStandbyPoolEncoding
+     */
+    createdAt?: string;
+    /**
+     * @type {string}
+     * @memberof LiveStandbyPoolEncoding
+     */
+    modifiedAt?: string;
+    /**
+     * ID of the encoding that ready for ingest in the standby pool
+     * @type {string}
+     * @memberof LiveStandbyPoolEncoding
+     */
+    encodingId?: string;
+    /**
+     * @type {LiveStandbyPoolEncodingManifest[]}
+     * @memberof LiveStandbyPoolEncoding
+     */
+    manifests?: LiveStandbyPoolEncodingManifest[];
+    /**
+     * @type {LiveStandbyPoolEncodingIngestPoint[]}
+     * @memberof LiveStandbyPoolEncoding
+     */
+    ingestPoints?: LiveStandbyPoolEncodingIngestPoint[];
+    /**
+     * @type {LiveStandbyPoolEncodingStatus}
+     * @memberof LiveStandbyPoolEncoding
+     */
+    status?: LiveStandbyPoolEncodingStatus;
+    constructor(obj?: Partial<LiveStandbyPoolEncoding>);
+}
+export default LiveStandbyPoolEncoding;

package/dist/models/LiveStandbyPoolEncoding.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LiveStandbyPoolEncoding = void 0;
+var Mapper_1 = require("../common/Mapper");
+var LiveStandbyPoolEncodingIngestPoint_1 = require("./LiveStandbyPoolEncodingIngestPoint");
+var LiveStandbyPoolEncodingManifest_1 = require("./LiveStandbyPoolEncodingManifest");
+/**
+ * @export
+ * @class LiveStandbyPoolEncoding
+ */
+var LiveStandbyPoolEncoding = /** @class */ (function () {
+    function LiveStandbyPoolEncoding(obj) {
+        if (!obj) {
+            return;
+        }
+        this.id = (0, Mapper_1.map)(obj.id);
+        this.createdAt = (0, Mapper_1.map)(obj.createdAt);
+        this.modifiedAt = (0, Mapper_1.map)(obj.modifiedAt);
+        this.encodingId = (0, Mapper_1.map)(obj.encodingId);
+        this.manifests = (0, Mapper_1.mapArray)(obj.manifests, LiveStandbyPoolEncodingManifest_1.default);
+        this.ingestPoints = (0, Mapper_1.mapArray)(obj.ingestPoints, LiveStandbyPoolEncodingIngestPoint_1.default);
+        this.status = (0, Mapper_1.map)(obj.status);
+    }
+    return LiveStandbyPoolEncoding;
+}());
+exports.LiveStandbyPoolEncoding = LiveStandbyPoolEncoding;
+exports.default = LiveStandbyPoolEncoding;

package/dist/models/LiveStandbyPoolEncodingIngestPoint.d.ts

@@ -0,0 +1,20 @@
+/**
+ * @export
+ * @class LiveStandbyPoolEncodingIngestPoint
+ */
+export declare class LiveStandbyPoolEncodingIngestPoint {
+    /**
+     * URL to the RTMP/RTMPS endpoint for this live encoding
+     * @type {string}
+     * @memberof LiveStandbyPoolEncodingIngestPoint
+     */
+    streamBaseUrl?: string;
+    /**
+     * Stream key value of this live encoding
+     * @type {string}
+     * @memberof LiveStandbyPoolEncodingIngestPoint
+     */
+    streamKey?: string;
+    constructor(obj?: Partial<LiveStandbyPoolEncodingIngestPoint>);
+}
+export default LiveStandbyPoolEncodingIngestPoint;

package/dist/models/LiveStandbyPoolEncodingIngestPoint.js

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

package/dist/models/LiveStandbyPoolEncodingManifest.d.ts

@@ -0,0 +1,26 @@
+import LiveStandbyPoolEncodingManifestType from './LiveStandbyPoolEncodingManifestType';
+/**
+ * @export
+ * @class LiveStandbyPoolEncodingManifest
+ */
+export declare class LiveStandbyPoolEncodingManifest {
+    /**
+     * URL to the manifest
+     * @type {string}
+     * @memberof LiveStandbyPoolEncodingManifest
+     */
+    url?: string;
+    /**
+     * ID of the manifest that was created for the encoding
+     * @type {string}
+     * @memberof LiveStandbyPoolEncodingManifest
+     */
+    manifestId?: string;
+    /**
+     * @type {LiveStandbyPoolEncodingManifestType}
+     * @memberof LiveStandbyPoolEncodingManifest
+     */
+    type?: LiveStandbyPoolEncodingManifestType;
+    constructor(obj?: Partial<LiveStandbyPoolEncodingManifest>);
+}
+export default LiveStandbyPoolEncodingManifest;

package/dist/models/LiveStandbyPoolEncodingManifest.js

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

package/dist/models/LiveStandbyPoolEncodingManifestType.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Type of the manifest
+ * @export
+ * @enum {string}
+ */
+export declare enum LiveStandbyPoolEncodingManifestType {
+    DASH = "DASH",
+    HLS = "HLS"
+}
+export default LiveStandbyPoolEncodingManifestType;

package/dist/models/LiveStandbyPoolEncodingManifestType.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LiveStandbyPoolEncodingManifestType = void 0;
+/**
+ * Type of the manifest
+ * @export
+ * @enum {string}
+ */
+var LiveStandbyPoolEncodingManifestType;
+(function (LiveStandbyPoolEncodingManifestType) {
+    LiveStandbyPoolEncodingManifestType["DASH"] = "DASH";
+    LiveStandbyPoolEncodingManifestType["HLS"] = "HLS";
+})(LiveStandbyPoolEncodingManifestType || (exports.LiveStandbyPoolEncodingManifestType = LiveStandbyPoolEncodingManifestType = {}));
+exports.default = LiveStandbyPoolEncodingManifestType;

package/dist/models/LiveStandbyPoolEncodingStatus.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Status of the standby pool encoding
+ * @export
+ * @enum {string}
+ */
+export declare enum LiveStandbyPoolEncodingStatus {
+    TO_BE_CREATED = "TO_BE_CREATED",
+    CREATING = "CREATING",
+    PREPARING = "PREPARING",
+    READY = "READY",
+    TO_BE_DELETED = "TO_BE_DELETED",
+    DELETING = "DELETING",
+    ACQUIRED = "ACQUIRED",
+    ERROR = "ERROR"
+}
+export default LiveStandbyPoolEncodingStatus;

package/dist/models/LiveStandbyPoolEncodingStatus.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LiveStandbyPoolEncodingStatus = void 0;
+/**
+ * Status of the standby pool encoding
+ * @export
+ * @enum {string}
+ */
+var LiveStandbyPoolEncodingStatus;
+(function (LiveStandbyPoolEncodingStatus) {
+    LiveStandbyPoolEncodingStatus["TO_BE_CREATED"] = "TO_BE_CREATED";
+    LiveStandbyPoolEncodingStatus["CREATING"] = "CREATING";
+    LiveStandbyPoolEncodingStatus["PREPARING"] = "PREPARING";
+    LiveStandbyPoolEncodingStatus["READY"] = "READY";
+    LiveStandbyPoolEncodingStatus["TO_BE_DELETED"] = "TO_BE_DELETED";
+    LiveStandbyPoolEncodingStatus["DELETING"] = "DELETING";
+    LiveStandbyPoolEncodingStatus["ACQUIRED"] = "ACQUIRED";
+    LiveStandbyPoolEncodingStatus["ERROR"] = "ERROR";
+})(LiveStandbyPoolEncodingStatus || (exports.LiveStandbyPoolEncodingStatus = LiveStandbyPoolEncodingStatus = {}));
+exports.default = LiveStandbyPoolEncodingStatus;

package/dist/models/LiveStandbyPoolEventLog.d.ts

@@ -0,0 +1,50 @@
+import LiveStandbyPoolEventLogType from './LiveStandbyPoolEventLogType';
+/**
+ * @export
+ * @class LiveStandbyPoolEventLog
+ */
+export declare class LiveStandbyPoolEventLog {
+    /**
+     * UUID of the entry
+     * @type {string}
+     * @memberof LiveStandbyPoolEventLog
+     */
+    id?: string;
+    /**
+     * Id of the standby_pool associated with the event log
+     * @type {string}
+     * @memberof LiveStandbyPoolEventLog
+     */
+    standbyPoolId?: string;
+    /**
+     * (Optional) Id of the standby pool encoding associated with the event
+     * @type {string}
+     * @memberof LiveStandbyPoolEventLog
+     */
+    standbyPoolEncodingId?: string;
+    /**
+     * Creation timestamp, returned as UTC expressed in ISO 8601 format: YYYY-MM-DDThh:mm:ssZ
+     * @type {string}
+     * @memberof LiveStandbyPoolEventLog
+     */
+    createdAt?: string;
+    /**
+     * Short description of the event
+     * @type {string}
+     * @memberof LiveStandbyPoolEventLog
+     */
+    message?: string;
+    /**
+     * Detailed description, payloads, hints on how to resolve errors, etc
+     * @type {string}
+     * @memberof LiveStandbyPoolEventLog
+     */
+    details?: string;
+    /**
+     * @type {LiveStandbyPoolEventLogType}
+     * @memberof LiveStandbyPoolEventLog
+     */
+    eventType?: LiveStandbyPoolEventLogType;
+    constructor(obj?: Partial<LiveStandbyPoolEventLog>);
+}
+export default LiveStandbyPoolEventLog;

package/dist/models/LiveStandbyPoolEventLog.js

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

package/dist/models/LiveStandbyPoolEventLogType.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Event log type of the standby pool
+ * @export
+ * @enum {string}
+ */
+export declare enum LiveStandbyPoolEventLogType {
+    INFO = "INFO",
+    WARN = "WARN",
+    ERROR = "ERROR"
+}
+export default LiveStandbyPoolEventLogType;

package/dist/models/LiveStandbyPoolEventLogType.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LiveStandbyPoolEventLogType = void 0;
+/**
+ * Event log type of the standby pool
+ * @export
+ * @enum {string}
+ */
+var LiveStandbyPoolEventLogType;
+(function (LiveStandbyPoolEventLogType) {
+    LiveStandbyPoolEventLogType["INFO"] = "INFO";
+    LiveStandbyPoolEventLogType["WARN"] = "WARN";
+    LiveStandbyPoolEventLogType["ERROR"] = "ERROR";
+})(LiveStandbyPoolEventLogType || (exports.LiveStandbyPoolEventLogType = LiveStandbyPoolEventLogType = {}));
+exports.default = LiveStandbyPoolEventLogType;

package/dist/models/LiveStandbyPoolRequest.d.ts

@@ -0,0 +1,21 @@
+import BitmovinResource from './BitmovinResource';
+/**
+ * @export
+ * @class LiveStandbyPoolRequest
+ */
+export declare class LiveStandbyPoolRequest extends BitmovinResource {
+    /**
+     * Number of instances to keep ready for streaming while the pool is running (required)
+     * @type {number}
+     * @memberof LiveStandbyPoolRequest
+     */
+    targetPoolSize?: number;
+    /**
+     * Base64 encoded template used to start the encodings in the pool (required)
+     * @type {string}
+     * @memberof LiveStandbyPoolRequest
+     */
+    encodingTemplate?: string;
+    constructor(obj?: Partial<LiveStandbyPoolRequest>);
+}
+export default LiveStandbyPoolRequest;

package/dist/models/LiveStandbyPoolRequest.js

@@ -0,0 +1,39 @@
+"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 });
+exports.LiveStandbyPoolRequest = void 0;
+var Mapper_1 = require("../common/Mapper");
+var BitmovinResource_1 = require("./BitmovinResource");
+/**
+ * @export
+ * @class LiveStandbyPoolRequest
+ */
+var LiveStandbyPoolRequest = /** @class */ (function (_super) {
+    __extends(LiveStandbyPoolRequest, _super);
+    function LiveStandbyPoolRequest(obj) {
+        var _this = _super.call(this, obj) || this;
+        if (!obj) {
+            return _this;
+        }
+        _this.targetPoolSize = (0, Mapper_1.map)(obj.targetPoolSize);
+        _this.encodingTemplate = (0, Mapper_1.map)(obj.encodingTemplate);
+        return _this;
+    }
+    return LiveStandbyPoolRequest;
+}(BitmovinResource_1.default));
+exports.LiveStandbyPoolRequest = LiveStandbyPoolRequest;
+exports.default = LiveStandbyPoolRequest;

package/dist/models/LiveStandbyPoolResponse.d.ts

@@ -0,0 +1,45 @@
+import BitmovinResource from './BitmovinResource';
+import LiveStandbyPoolStatus from './LiveStandbyPoolStatus';
+/**
+ * @export
+ * @class LiveStandbyPoolResponse
+ */
+export declare class LiveStandbyPoolResponse extends BitmovinResource {
+    /**
+     * Number of instances to keep ready for streaming while the pool is running (required)
+     * @type {number}
+     * @memberof LiveStandbyPoolResponse
+     */
+    targetPoolSize?: number;
+    /**
+     * Number of instances currently in ready state in the pool
+     * @type {number}
+     * @memberof LiveStandbyPoolResponse
+     */
+    readyEncodings?: number;
+    /**
+     * Number of instances currently being prepared in the pool
+     * @type {number}
+     * @memberof LiveStandbyPoolResponse
+     */
+    preparingEncodings?: number;
+    /**
+     * Number of instances currently in error state in the pool
+     * @type {number}
+     * @memberof LiveStandbyPoolResponse
+     */
+    errorEncodings?: number;
+    /**
+     * The name of the encoding template used with this Standby Pool
+     * @type {string}
+     * @memberof LiveStandbyPoolResponse
+     */
+    encodingTemplateName?: string;
+    /**
+     * @type {LiveStandbyPoolStatus}
+     * @memberof LiveStandbyPoolResponse
+     */
+    poolStatus?: LiveStandbyPoolStatus;
+    constructor(obj?: Partial<LiveStandbyPoolResponse>);
+}
+export default LiveStandbyPoolResponse;

package/dist/models/LiveStandbyPoolResponse.js

@@ -0,0 +1,43 @@
+"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 });
+exports.LiveStandbyPoolResponse = void 0;
+var Mapper_1 = require("../common/Mapper");
+var BitmovinResource_1 = require("./BitmovinResource");
+/**
+ * @export
+ * @class LiveStandbyPoolResponse
+ */
+var LiveStandbyPoolResponse = /** @class */ (function (_super) {
+    __extends(LiveStandbyPoolResponse, _super);
+    function LiveStandbyPoolResponse(obj) {
+        var _this = _super.call(this, obj) || this;
+        if (!obj) {
+            return _this;
+        }
+        _this.targetPoolSize = (0, Mapper_1.map)(obj.targetPoolSize);
+        _this.readyEncodings = (0, Mapper_1.map)(obj.readyEncodings);
+        _this.preparingEncodings = (0, Mapper_1.map)(obj.preparingEncodings);
+        _this.errorEncodings = (0, Mapper_1.map)(obj.errorEncodings);
+        _this.encodingTemplateName = (0, Mapper_1.map)(obj.encodingTemplateName);
+        _this.poolStatus = (0, Mapper_1.map)(obj.poolStatus);
+        return _this;
+    }
+    return LiveStandbyPoolResponse;
+}(BitmovinResource_1.default));
+exports.LiveStandbyPoolResponse = LiveStandbyPoolResponse;
+exports.default = LiveStandbyPoolResponse;

package/dist/models/LiveStandbyPoolStatus.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Status of the live standby pool
+ * @export
+ * @enum {string}
+ */
+export declare enum LiveStandbyPoolStatus {
+    HEALTHY = "HEALTHY",
+    ERROR = "ERROR"
+}
+export default LiveStandbyPoolStatus;

package/dist/models/LiveStandbyPoolStatus.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LiveStandbyPoolStatus = void 0;
+/**
+ * Status of the live standby pool
+ * @export
+ * @enum {string}
+ */
+var LiveStandbyPoolStatus;
+(function (LiveStandbyPoolStatus) {
+    LiveStandbyPoolStatus["HEALTHY"] = "HEALTHY";
+    LiveStandbyPoolStatus["ERROR"] = "ERROR";
+})(LiveStandbyPoolStatus || (exports.LiveStandbyPoolStatus = LiveStandbyPoolStatus = {}));
+exports.default = LiveStandbyPoolStatus;

package/dist/models/LiveStandbyPoolUpdate.d.ts

@@ -0,0 +1,20 @@
+/**
+ * @export
+ * @class LiveStandbyPoolUpdate
+ */
+export declare class LiveStandbyPoolUpdate {
+    /**
+     * Number of instances to keep ready for streaming while the pool is running
+     * @type {number}
+     * @memberof LiveStandbyPoolUpdate
+     */
+    targetPoolSize?: number;
+    /**
+     * Base64 encoded template used to start the encodings in the pool
+     * @type {string}
+     * @memberof LiveStandbyPoolUpdate
+     */
+    encodingTemplate?: string;
+    constructor(obj?: Partial<LiveStandbyPoolUpdate>);
+}
+export default LiveStandbyPoolUpdate;