@bitmovin/api-sdk 1.183.2 → 1.184.1

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.183.2',
+            'X-Api-Client-Version': '1.184.1',
             'Content-Type': 'application/json'
         };
         if (tenantOrgId) {

package/dist/encoding/EncodingApi.d.ts

@@ -5,6 +5,7 @@ import OutputsApi from './outputs/OutputsApi';
 import ConfigurationsApi from './configurations/ConfigurationsApi';
 import FiltersApi from './filters/FiltersApi';
 import EncodingsApi from './encodings/EncodingsApi';
+import LiveApi from './live/LiveApi';
 import ManifestsApi from './manifests/ManifestsApi';
 import InfrastructureApi from './infrastructure/InfrastructureApi';
 import StatisticsApi from './statistics/StatisticsApi';
@@ -24,6 +25,7 @@ export default class EncodingApi extends BaseAPI {
     configurations: ConfigurationsApi;
     filters: FiltersApi;
     encodings: EncodingsApi;
+    live: LiveApi;
     manifests: ManifestsApi;
     infrastructure: InfrastructureApi;
     statistics: StatisticsApi;

package/dist/encoding/EncodingApi.js

@@ -21,6 +21,7 @@ var OutputsApi_1 = require("./outputs/OutputsApi");
 var ConfigurationsApi_1 = require("./configurations/ConfigurationsApi");
 var FiltersApi_1 = require("./filters/FiltersApi");
 var EncodingsApi_1 = require("./encodings/EncodingsApi");
+var LiveApi_1 = require("./live/LiveApi");
 var ManifestsApi_1 = require("./manifests/ManifestsApi");
 var InfrastructureApi_1 = require("./infrastructure/InfrastructureApi");
 var StatisticsApi_1 = require("./statistics/StatisticsApi");
@@ -43,6 +44,7 @@ var EncodingApi = /** @class */ (function (_super) {
         _this.configurations = new ConfigurationsApi_1.default(configuration);
         _this.filters = new FiltersApi_1.default(configuration);
         _this.encodings = new EncodingsApi_1.default(configuration);
+        _this.live = new LiveApi_1.default(configuration);
         _this.manifests = new ManifestsApi_1.default(configuration);
         _this.infrastructure = new InfrastructureApi_1.default(configuration);
         _this.statistics = new StatisticsApi_1.default(configuration);

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

@@ -0,0 +1,13 @@
+import { BaseAPI } from '../../common/BaseAPI';
+import Configuration from '../../common/Configuration';
+import StreamKeysApi from './streamKeys/StreamKeysApi';
+/**
+ * LiveApi - object-oriented interface
+ * @export
+ * @class LiveApi
+ * @extends {BaseAPI}
+ */
+export default class LiveApi extends BaseAPI {
+    streamKeys: StreamKeysApi;
+    constructor(configuration: Configuration);
+}

package/dist/encoding/live/LiveApi.js

@@ -0,0 +1,35 @@
+"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 StreamKeysApi_1 = require("./streamKeys/StreamKeysApi");
+/**
+ * LiveApi - object-oriented interface
+ * @export
+ * @class LiveApi
+ * @extends {BaseAPI}
+ */
+var LiveApi = /** @class */ (function (_super) {
+    __extends(LiveApi, _super);
+    function LiveApi(configuration) {
+        var _this = _super.call(this, configuration) || this;
+        _this.streamKeys = new StreamKeysApi_1.default(configuration);
+        return _this;
+    }
+    return LiveApi;
+}(BaseAPI_1.BaseAPI));
+exports.default = LiveApi;

package/dist/encoding/live/streamKeys/StreamKeyListQueryParams.d.ts

@@ -0,0 +1,83 @@
+export interface StreamKeyListQueryParams {
+    /**
+     * Index of the first item to return, starting at 0. Default is 0
+     * @type {number}
+     * @memberof StreamKeyListQueryParams
+     */
+    offset?: number | undefined;
+    /**
+     * Maximum number of items to return. Default is 25, maximum is 100
+     * @type {number}
+     * @memberof StreamKeyListQueryParams
+     */
+    limit?: number | undefined;
+    /**
+     * Order list result according a stream key attribute.  The fields that can be used for sorting are: + `createdAt` + `name`
+     * @type {string}
+     * @memberof StreamKeyListQueryParams
+     */
+    sort?: string | undefined;
+    /**
+     * Filter stream keys by type
+     * @type {string}
+     * @memberof StreamKeyListQueryParams
+     */
+    type?: string | undefined;
+    /**
+     * Filter stream keys by status
+     * @type {string}
+     * @memberof StreamKeyListQueryParams
+     */
+    status?: string | undefined;
+    /**
+     * Filter stream keys by assigned ingest point id
+     * @type {string}
+     * @memberof StreamKeyListQueryParams
+     */
+    assignedIngestPointId?: string | undefined;
+    /**
+     * Filter stream keys by assigned encoding id
+     * @type {string}
+     * @memberof StreamKeyListQueryParams
+     */
+    assignedEncodingId?: string | undefined;
+}
+export declare class StreamKeyListQueryParamsBuilder {
+    private internalParams;
+    /**
+     *
+     * @param offset Index of the first item to return, starting at 0. Default is 0
+     */
+    offset(offset: number): this;
+    /**
+     *
+     * @param limit Maximum number of items to return. Default is 25, maximum is 100
+     */
+    limit(limit: number): this;
+    /**
+     *
+     * @param sort Order list result according a stream key attribute.  The fields that can be used for sorting are: + `createdAt` + `name`
+     */
+    sort(sort: string): this;
+    /**
+     *
+     * @param type Filter stream keys by type
+     */
+    type(type: string): this;
+    /**
+     *
+     * @param status Filter stream keys by status
+     */
+    status(status: string): this;
+    /**
+     *
+     * @param assignedIngestPointId Filter stream keys by assigned ingest point id
+     */
+    assignedIngestPointId(assignedIngestPointId: string): this;
+    /**
+     *
+     * @param assignedEncodingId Filter stream keys by assigned encoding id
+     */
+    assignedEncodingId(assignedEncodingId: string): this;
+    buildQueryParams(): StreamKeyListQueryParams;
+}

package/dist/encoding/live/streamKeys/StreamKeyListQueryParams.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StreamKeyListQueryParamsBuilder = void 0;
+var StreamKeyListQueryParamsBuilder = /** @class */ (function () {
+    function StreamKeyListQueryParamsBuilder() {
+        this.internalParams = {};
+    }
+    /**
+     *
+     * @param offset Index of the first item to return, starting at 0. Default is 0
+     */
+    StreamKeyListQueryParamsBuilder.prototype.offset = function (offset) {
+        this.internalParams.offset = offset;
+        return this;
+    };
+    /**
+     *
+     * @param limit Maximum number of items to return. Default is 25, maximum is 100
+     */
+    StreamKeyListQueryParamsBuilder.prototype.limit = function (limit) {
+        this.internalParams.limit = limit;
+        return this;
+    };
+    /**
+     *
+     * @param sort Order list result according a stream key attribute.  The fields that can be used for sorting are: + `createdAt` + `name`
+     */
+    StreamKeyListQueryParamsBuilder.prototype.sort = function (sort) {
+        this.internalParams.sort = sort;
+        return this;
+    };
+    /**
+     *
+     * @param type Filter stream keys by type
+     */
+    StreamKeyListQueryParamsBuilder.prototype.type = function (type) {
+        this.internalParams.type = type;
+        return this;
+    };
+    /**
+     *
+     * @param status Filter stream keys by status
+     */
+    StreamKeyListQueryParamsBuilder.prototype.status = function (status) {
+        this.internalParams.status = status;
+        return this;
+    };
+    /**
+     *
+     * @param assignedIngestPointId Filter stream keys by assigned ingest point id
+     */
+    StreamKeyListQueryParamsBuilder.prototype.assignedIngestPointId = function (assignedIngestPointId) {
+        this.internalParams.assignedIngestPointId = assignedIngestPointId;
+        return this;
+    };
+    /**
+     *
+     * @param assignedEncodingId Filter stream keys by assigned encoding id
+     */
+    StreamKeyListQueryParamsBuilder.prototype.assignedEncodingId = function (assignedEncodingId) {
+        this.internalParams.assignedEncodingId = assignedEncodingId;
+        return this;
+    };
+    StreamKeyListQueryParamsBuilder.prototype.buildQueryParams = function () {
+        return this.internalParams;
+    };
+    return StreamKeyListQueryParamsBuilder;
+}());
+exports.StreamKeyListQueryParamsBuilder = StreamKeyListQueryParamsBuilder;

package/dist/encoding/live/streamKeys/StreamKeysApi.d.ts

@@ -0,0 +1,43 @@
+import { BaseAPI } from '../../../common/BaseAPI';
+import Configuration from '../../../common/Configuration';
+import BitmovinResponse from '../../../models/BitmovinResponse';
+import StreamKey from '../../../models/StreamKey';
+import PaginationResponse from '../../../models/PaginationResponse';
+import { StreamKeyListQueryParams, StreamKeyListQueryParamsBuilder } from './StreamKeyListQueryParams';
+/**
+ * StreamKeysApi - object-oriented interface
+ * @export
+ * @class StreamKeysApi
+ * @extends {BaseAPI}
+ */
+export default class StreamKeysApi extends BaseAPI {
+    constructor(configuration: Configuration);
+    /**
+     * @summary Create new stream key
+     * @param {StreamKey} streamKey The stream key to be created
+     * @throws {BitmovinError}
+     * @memberof StreamKeysApi
+     */
+    create(streamKey?: StreamKey): Promise<StreamKey>;
+    /**
+     * @summary Delete Stream Key
+     * @param {string} streamKeyId Id of the stream key
+     * @throws {BitmovinError}
+     * @memberof StreamKeysApi
+     */
+    delete(streamKeyId: string): Promise<BitmovinResponse>;
+    /**
+     * @summary Stream Key details
+     * @param {string} streamKeyId Id of the stream key
+     * @throws {BitmovinError}
+     * @memberof StreamKeysApi
+     */
+    get(streamKeyId: string): Promise<StreamKey>;
+    /**
+     * @summary List Stream Keys
+     * @param {*} [queryParameters] query parameters for filtering, sorting and pagination
+     * @throws {BitmovinError}
+     * @memberof StreamKeysApi
+     */
+    list(queryParameters?: StreamKeyListQueryParams | ((q: StreamKeyListQueryParamsBuilder) => StreamKeyListQueryParamsBuilder)): Promise<PaginationResponse<StreamKey>>;
+}

package/dist/encoding/live/streamKeys/StreamKeysApi.js

@@ -0,0 +1,94 @@
+"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 BitmovinResponse_1 = require("../../../models/BitmovinResponse");
+var StreamKey_1 = require("../../../models/StreamKey");
+var PaginationResponse_1 = require("../../../models/PaginationResponse");
+var StreamKeyListQueryParams_1 = require("./StreamKeyListQueryParams");
+/**
+ * StreamKeysApi - object-oriented interface
+ * @export
+ * @class StreamKeysApi
+ * @extends {BaseAPI}
+ */
+var StreamKeysApi = /** @class */ (function (_super) {
+    __extends(StreamKeysApi, _super);
+    function StreamKeysApi(configuration) {
+        return _super.call(this, configuration) || this;
+    }
+    /**
+     * @summary Create new stream key
+     * @param {StreamKey} streamKey The stream key to be created
+     * @throws {BitmovinError}
+     * @memberof StreamKeysApi
+     */
+    StreamKeysApi.prototype.create = function (streamKey) {
+        return this.restClient.post('/encoding/live/stream-keys', {}, streamKey).then(function (response) {
+            return (0, Mapper_1.map)(response, StreamKey_1.default);
+        });
+    };
+    /**
+     * @summary Delete Stream Key
+     * @param {string} streamKeyId Id of the stream key
+     * @throws {BitmovinError}
+     * @memberof StreamKeysApi
+     */
+    StreamKeysApi.prototype.delete = function (streamKeyId) {
+        var pathParamMap = {
+            stream_key_id: streamKeyId
+        };
+        return this.restClient.delete('/encoding/live/stream-keys/{stream_key_id}', pathParamMap).then(function (response) {
+            return (0, Mapper_1.map)(response, BitmovinResponse_1.default);
+        });
+    };
+    /**
+     * @summary Stream Key details
+     * @param {string} streamKeyId Id of the stream key
+     * @throws {BitmovinError}
+     * @memberof StreamKeysApi
+     */
+    StreamKeysApi.prototype.get = function (streamKeyId) {
+        var pathParamMap = {
+            stream_key_id: streamKeyId
+        };
+        return this.restClient.get('/encoding/live/stream-keys/{stream_key_id}', pathParamMap).then(function (response) {
+            return (0, Mapper_1.map)(response, StreamKey_1.default);
+        });
+    };
+    /**
+     * @summary List Stream Keys
+     * @param {*} [queryParameters] query parameters for filtering, sorting and pagination
+     * @throws {BitmovinError}
+     * @memberof StreamKeysApi
+     */
+    StreamKeysApi.prototype.list = function (queryParameters) {
+        var queryParams = {};
+        if (typeof queryParameters === 'function') {
+            queryParams = queryParameters(new StreamKeyListQueryParams_1.StreamKeyListQueryParamsBuilder()).buildQueryParams();
+        }
+        else if (queryParameters) {
+            queryParams = queryParameters;
+        }
+        return this.restClient.get('/encoding/live/stream-keys', {}, queryParams).then(function (response) {
+            return new PaginationResponse_1.default(response, StreamKey_1.default);
+        });
+    };
+    return StreamKeysApi;
+}(BaseAPI_1.BaseAPI));
+exports.default = StreamKeysApi;

package/dist/models/RedundantRtmpInput.d.ts

@@ -1,6 +1,7 @@
 import Input from './Input';
 import InputType from './InputType';
 import RtmpIngestPoint from './RtmpIngestPoint';
+import StaticRtmpIngestPoint from './StaticRtmpIngestPoint';
 /**
  * @export
  * @class RedundantRtmpInput
@@ -19,10 +20,17 @@ export declare class RedundantRtmpInput extends Input {
      */
     delayThreshold?: number;
     /**
+     * Configuration for ingest points that use a dynamic IP based endpoint to stream to e.g.: rtmp://41.167.11.21/live Either ingestPoints **or** staticIngestPoints can be set
      * @type {RtmpIngestPoint[]}
      * @memberof RedundantRtmpInput
      */
     ingestPoints?: RtmpIngestPoint[];
+    /**
+     * Configuration for static ingest points. These ingest points use a consistent endpoint to stream to e.g.: rtmps://live-ingest.bitmovin.com/live Either ingestPoints **or** staticIngestPoints can be set
+     * @type {StaticRtmpIngestPoint[]}
+     * @memberof RedundantRtmpInput
+     */
+    staticIngestPoints?: StaticRtmpIngestPoint[];
     constructor(obj?: Partial<RedundantRtmpInput>);
 }
 export default RedundantRtmpInput;

package/dist/models/RedundantRtmpInput.js

@@ -20,6 +20,7 @@ var Mapper_1 = require("../common/Mapper");
 var Input_1 = require("./Input");
 var InputType_1 = require("./InputType");
 var RtmpIngestPoint_1 = require("./RtmpIngestPoint");
+var StaticRtmpIngestPoint_1 = require("./StaticRtmpIngestPoint");
 /**
  * @export
  * @class RedundantRtmpInput
@@ -39,6 +40,7 @@ var RedundantRtmpInput = /** @class */ (function (_super) {
         }
         _this.delayThreshold = (0, Mapper_1.map)(obj.delayThreshold);
         _this.ingestPoints = (0, Mapper_1.mapArray)(obj.ingestPoints, RtmpIngestPoint_1.default);
+        _this.staticIngestPoints = (0, Mapper_1.mapArray)(obj.staticIngestPoints, StaticRtmpIngestPoint_1.default);
         return _this;
     }
     return RedundantRtmpInput;

package/dist/models/StaticRtmpIngestPoint.d.ts

@@ -0,0 +1,26 @@
+import StreamKeyConfiguration from './StreamKeyConfiguration';
+/**
+ * @export
+ * @class StaticRtmpIngestPoint
+ */
+export declare class StaticRtmpIngestPoint {
+    /**
+     * The ID of the created static rtmp ingest point
+     * @type {string}
+     * @memberof StaticRtmpIngestPoint
+     */
+    id?: string;
+    /**
+     * Name of the ingest point. This can be helpful for easier identifying your ingest points
+     * @type {string}
+     * @memberof StaticRtmpIngestPoint
+     */
+    name?: string;
+    /**
+     * @type {StreamKeyConfiguration}
+     * @memberof StaticRtmpIngestPoint
+     */
+    streamKeyConfiguration?: StreamKeyConfiguration;
+    constructor(obj?: Partial<StaticRtmpIngestPoint>);
+}
+export default StaticRtmpIngestPoint;

package/dist/models/StaticRtmpIngestPoint.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StaticRtmpIngestPoint = void 0;
+var Mapper_1 = require("../common/Mapper");
+var StreamKeyConfiguration_1 = require("./StreamKeyConfiguration");
+/**
+ * @export
+ * @class StaticRtmpIngestPoint
+ */
+var StaticRtmpIngestPoint = /** @class */ (function () {
+    function StaticRtmpIngestPoint(obj) {
+        if (!obj) {
+            return;
+        }
+        this.id = (0, Mapper_1.map)(obj.id);
+        this.name = (0, Mapper_1.map)(obj.name);
+        this.streamKeyConfiguration = (0, Mapper_1.map)(obj.streamKeyConfiguration, StreamKeyConfiguration_1.default);
+    }
+    return StaticRtmpIngestPoint;
+}());
+exports.StaticRtmpIngestPoint = StaticRtmpIngestPoint;
+exports.default = StaticRtmpIngestPoint;

package/dist/models/StreamKey.d.ts

@@ -0,0 +1,41 @@
+import BitmovinResource from './BitmovinResource';
+import StreamKeyStatus from './StreamKeyStatus';
+import StreamKeyType from './StreamKeyType';
+/**
+ * @export
+ * @class StreamKey
+ */
+export declare class StreamKey extends BitmovinResource {
+    /**
+     * Stream key used for live streaming. This stream key is reserved and can be re-used with different live encodings. If this value is not provided, a unique random stream key will be generated. **Important:** This value has to be globally unique. If it is set manually, be sure to use a secure value. If the stream key value is guessed by others your live encoding can be compromised.
+     * @type {string}
+     * @memberof StreamKey
+     */
+    value?: string;
+    /**
+     * Status of the stream key
+     * @type {StreamKeyStatus}
+     * @memberof StreamKey
+     */
+    status?: StreamKeyStatus;
+    /**
+     * Type of the stream key
+     * @type {StreamKeyType}
+     * @memberof StreamKey
+     */
+    type?: StreamKeyType;
+    /**
+     * ID of the encoding that is assigned to this stream key. Not set if status is UNASSIGNED
+     * @type {string}
+     * @memberof StreamKey
+     */
+    assignedEncodingId?: string;
+    /**
+     * ID of the ingest point that is assigned to this stream key. Not set if status is UNASSIGNED
+     * @type {string}
+     * @memberof StreamKey
+     */
+    assignedIngestPointId?: string;
+    constructor(obj?: Partial<StreamKey>);
+}
+export default StreamKey;

package/dist/models/StreamKey.js

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

package/dist/models/StreamKeyConfiguration.d.ts

@@ -0,0 +1,20 @@
+import StreamKeyConfigurationType from './StreamKeyConfigurationType';
+/**
+ * @export
+ * @class StreamKeyConfiguration
+ */
+export declare class StreamKeyConfiguration {
+    /**
+     * @type {StreamKeyConfigurationType}
+     * @memberof StreamKeyConfiguration
+     */
+    type?: StreamKeyConfigurationType;
+    /**
+     * Id of the previously generated stream key.  Only needed when the type is `ASSIGN`.
+     * @type {string}
+     * @memberof StreamKeyConfiguration
+     */
+    streamKeyId?: string;
+    constructor(obj?: Partial<StreamKeyConfiguration>);
+}
+export default StreamKeyConfiguration;

package/dist/models/StreamKeyConfiguration.js

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

package/dist/models/StreamKeyConfigurationType.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @export
+ * @enum {string}
+ */
+export declare enum StreamKeyConfigurationType {
+    GENERATE = "GENERATE",
+    ASSIGN = "ASSIGN"
+}
+export default StreamKeyConfigurationType;

package/dist/models/StreamKeyConfigurationType.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StreamKeyConfigurationType = void 0;
+/**
+ * @export
+ * @enum {string}
+ */
+var StreamKeyConfigurationType;
+(function (StreamKeyConfigurationType) {
+    StreamKeyConfigurationType["GENERATE"] = "GENERATE";
+    StreamKeyConfigurationType["ASSIGN"] = "ASSIGN";
+})(StreamKeyConfigurationType || (exports.StreamKeyConfigurationType = StreamKeyConfigurationType = {}));
+exports.default = StreamKeyConfigurationType;

package/dist/models/StreamKeyStatus.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Status of the stream key
+ * @export
+ * @enum {string}
+ */
+export declare enum StreamKeyStatus {
+    ASSIGNED = "ASSIGNED",
+    UNASSIGNED = "UNASSIGNED"
+}
+export default StreamKeyStatus;

package/dist/models/StreamKeyStatus.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StreamKeyStatus = void 0;
+/**
+ * Status of the stream key
+ * @export
+ * @enum {string}
+ */
+var StreamKeyStatus;
+(function (StreamKeyStatus) {
+    StreamKeyStatus["ASSIGNED"] = "ASSIGNED";
+    StreamKeyStatus["UNASSIGNED"] = "UNASSIGNED";
+})(StreamKeyStatus || (exports.StreamKeyStatus = StreamKeyStatus = {}));
+exports.default = StreamKeyStatus;

package/dist/models/StreamKeyType.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Type of the stream key
+ * @export
+ * @enum {string}
+ */
+export declare enum StreamKeyType {
+    RESERVED = "RESERVED",
+    TEMPORARY = "TEMPORARY"
+}
+export default StreamKeyType;