@bitmovin/api-sdk 1.210.0 → 1.212.0

package/dist/encoding/live/standbyPools/actions/ActionsApi.d.ts

@@ -0,0 +1,26 @@
+import { BaseAPI } from '../../../../common/BaseAPI';
+import Configuration from '../../../../common/Configuration';
+import LiveStandbyPoolEncoding from '../../../../models/LiveStandbyPoolEncoding';
+/**
+ * ActionsApi - object-oriented interface
+ * @export
+ * @class ActionsApi
+ * @extends {BaseAPI}
+ */
+export default class ActionsApi extends BaseAPI {
+    constructor(configuration: Configuration);
+    /**
+     * @summary Acquire an encoding from a standby pool
+     * @param {string} poolId Id of the standby pool
+     * @throws {BitmovinError}
+     * @memberof ActionsApi
+     */
+    acquireEncoding(poolId: string): Promise<LiveStandbyPoolEncoding>;
+    /**
+     * @summary Delete error encodings from the standby pool
+     * @param {string} poolId Id of the standby pool
+     * @throws {BitmovinError}
+     * @memberof ActionsApi
+     */
+    deleteErrorEncodings(poolId: string): Promise<LiveStandbyPoolEncoding>;
+}

package/dist/encoding/live/standbyPools/actions/ActionsApi.js

@@ -0,0 +1,62 @@
+"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 LiveStandbyPoolEncoding_1 = require("../../../../models/LiveStandbyPoolEncoding");
+/**
+ * ActionsApi - object-oriented interface
+ * @export
+ * @class ActionsApi
+ * @extends {BaseAPI}
+ */
+var ActionsApi = /** @class */ (function (_super) {
+    __extends(ActionsApi, _super);
+    function ActionsApi(configuration) {
+        return _super.call(this, configuration) || this;
+    }
+    /**
+     * @summary Acquire an encoding from a standby pool
+     * @param {string} poolId Id of the standby pool
+     * @throws {BitmovinError}
+     * @memberof ActionsApi
+     */
+    ActionsApi.prototype.acquireEncoding = function (poolId) {
+        var pathParamMap = {
+            pool_id: poolId
+        };
+        return this.restClient.post('/encoding/live/standby-pools/{pool_id}/actions/acquire-encoding', pathParamMap).then(function (response) {
+            return (0, Mapper_1.map)(response, LiveStandbyPoolEncoding_1.default);
+        });
+    };
+    /**
+     * @summary Delete error encodings from the standby pool
+     * @param {string} poolId Id of the standby pool
+     * @throws {BitmovinError}
+     * @memberof ActionsApi
+     */
+    ActionsApi.prototype.deleteErrorEncodings = function (poolId) {
+        var pathParamMap = {
+            pool_id: poolId
+        };
+        return this.restClient.post('/encoding/live/standby-pools/{pool_id}/actions/delete-error-encodings', pathParamMap).then(function (response) {
+            return (0, Mapper_1.map)(response, LiveStandbyPoolEncoding_1.default);
+        });
+    };
+    return ActionsApi;
+}(BaseAPI_1.BaseAPI));
+exports.default = ActionsApi;

package/dist/encoding/live/standbyPools/encodings/EncodingsApi.d.ts

@@ -0,0 +1,31 @@
+import { BaseAPI } from '../../../../common/BaseAPI';
+import Configuration from '../../../../common/Configuration';
+import BitmovinResponse from '../../../../models/BitmovinResponse';
+import LiveStandbyPoolEncoding from '../../../../models/LiveStandbyPoolEncoding';
+import PaginationResponse from '../../../../models/PaginationResponse';
+import { LiveStandbyPoolEncodingListQueryParams, LiveStandbyPoolEncodingListQueryParamsBuilder } from './LiveStandbyPoolEncodingListQueryParams';
+/**
+ * EncodingsApi - object-oriented interface
+ * @export
+ * @class EncodingsApi
+ * @extends {BaseAPI}
+ */
+export default class EncodingsApi extends BaseAPI {
+    constructor(configuration: Configuration);
+    /**
+     * @summary Delete encoding from pool by id
+     * @param {string} poolId Id of the standby pool
+     * @param {string} id Id of the standby pool encoding
+     * @throws {BitmovinError}
+     * @memberof EncodingsApi
+     */
+    delete(poolId: string, id: string): Promise<BitmovinResponse>;
+    /**
+     * @summary List encodings from a standby pool
+     * @param {string} poolId Id of the standby pool
+     * @param {*} [queryParameters] query parameters for filtering, sorting and pagination
+     * @throws {BitmovinError}
+     * @memberof EncodingsApi
+     */
+    list(poolId: string, queryParameters?: LiveStandbyPoolEncodingListQueryParams | ((q: LiveStandbyPoolEncodingListQueryParamsBuilder) => LiveStandbyPoolEncodingListQueryParamsBuilder)): Promise<PaginationResponse<LiveStandbyPoolEncoding>>;
+}

package/dist/encoding/live/standbyPools/encodings/EncodingsApi.js

@@ -0,0 +1,75 @@
+"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 LiveStandbyPoolEncoding_1 = require("../../../../models/LiveStandbyPoolEncoding");
+var PaginationResponse_1 = require("../../../../models/PaginationResponse");
+var LiveStandbyPoolEncodingListQueryParams_1 = require("./LiveStandbyPoolEncodingListQueryParams");
+/**
+ * EncodingsApi - object-oriented interface
+ * @export
+ * @class EncodingsApi
+ * @extends {BaseAPI}
+ */
+var EncodingsApi = /** @class */ (function (_super) {
+    __extends(EncodingsApi, _super);
+    function EncodingsApi(configuration) {
+        return _super.call(this, configuration) || this;
+    }
+    /**
+     * @summary Delete encoding from pool by id
+     * @param {string} poolId Id of the standby pool
+     * @param {string} id Id of the standby pool encoding
+     * @throws {BitmovinError}
+     * @memberof EncodingsApi
+     */
+    EncodingsApi.prototype.delete = function (poolId, id) {
+        var pathParamMap = {
+            pool_id: poolId,
+            id: id
+        };
+        return this.restClient.delete('/encoding/live/standby-pools/{pool_id}/encodings/{id}', pathParamMap).then(function (response) {
+            return (0, Mapper_1.map)(response, BitmovinResponse_1.default);
+        });
+    };
+    /**
+     * @summary List encodings from a standby pool
+     * @param {string} poolId Id of the standby pool
+     * @param {*} [queryParameters] query parameters for filtering, sorting and pagination
+     * @throws {BitmovinError}
+     * @memberof EncodingsApi
+     */
+    EncodingsApi.prototype.list = function (poolId, queryParameters) {
+        var pathParamMap = {
+            pool_id: poolId
+        };
+        var queryParams = {};
+        if (typeof queryParameters === 'function') {
+            queryParams = queryParameters(new LiveStandbyPoolEncodingListQueryParams_1.LiveStandbyPoolEncodingListQueryParamsBuilder()).buildQueryParams();
+        }
+        else if (queryParameters) {
+            queryParams = queryParameters;
+        }
+        return this.restClient.get('/encoding/live/standby-pools/{pool_id}/encodings', pathParamMap, queryParams).then(function (response) {
+            return new PaginationResponse_1.default(response, LiveStandbyPoolEncoding_1.default);
+        });
+    };
+    return EncodingsApi;
+}(BaseAPI_1.BaseAPI));
+exports.default = EncodingsApi;

package/dist/encoding/live/standbyPools/encodings/LiveStandbyPoolEncodingListQueryParams.d.ts

@@ -0,0 +1,50 @@
+export interface LiveStandbyPoolEncodingListQueryParams {
+    /**
+     * Index of the first item to return, starting at 0. Default is 0
+     * @type {number}
+     * @memberof LiveStandbyPoolEncodingListQueryParams
+     */
+    offset?: number | undefined;
+    /**
+     * Maximum number of items to return. Default is 25, maximum is 100
+     * @type {number}
+     * @memberof LiveStandbyPoolEncodingListQueryParams
+     */
+    limit?: number | undefined;
+    /**
+     * Order list result according a stream key attribute.  The fields that can be used for sorting are: + `createdAt` + `name` + `status`
+     * @type {string}
+     * @memberof LiveStandbyPoolEncodingListQueryParams
+     */
+    sort?: string | undefined;
+    /**
+     * Filter standby encodings by status
+     * @type {string}
+     * @memberof LiveStandbyPoolEncodingListQueryParams
+     */
+    status?: string | undefined;
+}
+export declare class LiveStandbyPoolEncodingListQueryParamsBuilder {
+    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` + `status`
+     */
+    sort(sort: string): this;
+    /**
+     *
+     * @param status Filter standby encodings by status
+     */
+    status(status: string): this;
+    buildQueryParams(): LiveStandbyPoolEncodingListQueryParams;
+}

package/dist/encoding/live/standbyPools/encodings/LiveStandbyPoolEncodingListQueryParams.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LiveStandbyPoolEncodingListQueryParamsBuilder = void 0;
+var LiveStandbyPoolEncodingListQueryParamsBuilder = /** @class */ (function () {
+    function LiveStandbyPoolEncodingListQueryParamsBuilder() {
+        this.internalParams = {};
+    }
+    /**
+     *
+     * @param offset Index of the first item to return, starting at 0. Default is 0
+     */
+    LiveStandbyPoolEncodingListQueryParamsBuilder.prototype.offset = function (offset) {
+        this.internalParams.offset = offset;
+        return this;
+    };
+    /**
+     *
+     * @param limit Maximum number of items to return. Default is 25, maximum is 100
+     */
+    LiveStandbyPoolEncodingListQueryParamsBuilder.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` + `status`
+     */
+    LiveStandbyPoolEncodingListQueryParamsBuilder.prototype.sort = function (sort) {
+        this.internalParams.sort = sort;
+        return this;
+    };
+    /**
+     *
+     * @param status Filter standby encodings by status
+     */
+    LiveStandbyPoolEncodingListQueryParamsBuilder.prototype.status = function (status) {
+        this.internalParams.status = status;
+        return this;
+    };
+    LiveStandbyPoolEncodingListQueryParamsBuilder.prototype.buildQueryParams = function () {
+        return this.internalParams;
+    };
+    return LiveStandbyPoolEncodingListQueryParamsBuilder;
+}());
+exports.LiveStandbyPoolEncodingListQueryParamsBuilder = LiveStandbyPoolEncodingListQueryParamsBuilder;

package/dist/encoding/live/standbyPools/logs/LiveStandbyPoolEventLogListQueryParams.d.ts

@@ -0,0 +1,50 @@
+export interface LiveStandbyPoolEventLogListQueryParams {
+    /**
+     * Index of the first item to return, starting at 0. Default is 0
+     * @type {number}
+     * @memberof LiveStandbyPoolEventLogListQueryParams
+     */
+    offset?: number | undefined;
+    /**
+     * Maximum number of items to return. Default is 25, maximum is 100
+     * @type {number}
+     * @memberof LiveStandbyPoolEventLogListQueryParams
+     */
+    limit?: number | undefined;
+    /**
+     * Order list result according a event log attribute.  The fields that can be used for sorting are: + `createdAt` + `eventType` + `standByPoolId`
+     * @type {string}
+     * @memberof LiveStandbyPoolEventLogListQueryParams
+     */
+    sort?: string | undefined;
+    /**
+     * Filter event logs by log type. Allowed values are: + `INFO` + `WARN` + `ERROR`
+     * @type {string}
+     * @memberof LiveStandbyPoolEventLogListQueryParams
+     */
+    eventType?: string | undefined;
+}
+export declare class LiveStandbyPoolEventLogListQueryParamsBuilder {
+    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 event log attribute.  The fields that can be used for sorting are: + `createdAt` + `eventType` + `standByPoolId`
+     */
+    sort(sort: string): this;
+    /**
+     *
+     * @param eventType Filter event logs by log type. Allowed values are: + `INFO` + `WARN` + `ERROR`
+     */
+    eventType(eventType: string): this;
+    buildQueryParams(): LiveStandbyPoolEventLogListQueryParams;
+}

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

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LiveStandbyPoolEventLogListQueryParamsBuilder = void 0;
+var LiveStandbyPoolEventLogListQueryParamsBuilder = /** @class */ (function () {
+    function LiveStandbyPoolEventLogListQueryParamsBuilder() {
+        this.internalParams = {};
+    }
+    /**
+     *
+     * @param offset Index of the first item to return, starting at 0. Default is 0
+     */
+    LiveStandbyPoolEventLogListQueryParamsBuilder.prototype.offset = function (offset) {
+        this.internalParams.offset = offset;
+        return this;
+    };
+    /**
+     *
+     * @param limit Maximum number of items to return. Default is 25, maximum is 100
+     */
+    LiveStandbyPoolEventLogListQueryParamsBuilder.prototype.limit = function (limit) {
+        this.internalParams.limit = limit;
+        return this;
+    };
+    /**
+     *
+     * @param sort Order list result according a event log attribute.  The fields that can be used for sorting are: + `createdAt` + `eventType` + `standByPoolId`
+     */
+    LiveStandbyPoolEventLogListQueryParamsBuilder.prototype.sort = function (sort) {
+        this.internalParams.sort = sort;
+        return this;
+    };
+    /**
+     *
+     * @param eventType Filter event logs by log type. Allowed values are: + `INFO` + `WARN` + `ERROR`
+     */
+    LiveStandbyPoolEventLogListQueryParamsBuilder.prototype.eventType = function (eventType) {
+        this.internalParams.eventType = eventType;
+        return this;
+    };
+    LiveStandbyPoolEventLogListQueryParamsBuilder.prototype.buildQueryParams = function () {
+        return this.internalParams;
+    };
+    return LiveStandbyPoolEventLogListQueryParamsBuilder;
+}());
+exports.LiveStandbyPoolEventLogListQueryParamsBuilder = LiveStandbyPoolEventLogListQueryParamsBuilder;

package/dist/encoding/live/standbyPools/logs/LogsApi.d.ts

@@ -0,0 +1,22 @@
+import { BaseAPI } from '../../../../common/BaseAPI';
+import Configuration from '../../../../common/Configuration';
+import LiveStandbyPoolEventLog from '../../../../models/LiveStandbyPoolEventLog';
+import PaginationResponse from '../../../../models/PaginationResponse';
+import { LiveStandbyPoolEventLogListQueryParams, LiveStandbyPoolEventLogListQueryParamsBuilder } from './LiveStandbyPoolEventLogListQueryParams';
+/**
+ * LogsApi - object-oriented interface
+ * @export
+ * @class LogsApi
+ * @extends {BaseAPI}
+ */
+export default class LogsApi extends BaseAPI {
+    constructor(configuration: Configuration);
+    /**
+     * @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
+     */
+    list(poolId: string, queryParameters?: LiveStandbyPoolEventLogListQueryParams | ((q: LiveStandbyPoolEventLogListQueryParamsBuilder) => LiveStandbyPoolEventLogListQueryParamsBuilder)): Promise<PaginationResponse<LiveStandbyPoolEventLog>>;
+}

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/encoding/templates/EncodingTemplateResponseListQueryParams.d.ts

@@ -0,0 +1,40 @@
+import EncodingTemplateType from '../../models/EncodingTemplateType';
+export interface EncodingTemplateResponseListQueryParams {
+    /**
+     * Index of the first item to return, starting at 0. Default is 0
+     * @type {number}
+     * @memberof EncodingTemplateResponseListQueryParams
+     */
+    offset?: number | undefined;
+    /**
+     * Maximum number of items to return. Default is 25, maximum is 100
+     * @type {number}
+     * @memberof EncodingTemplateResponseListQueryParams
+     */
+    limit?: number | undefined;
+    /**
+     * Filter the stored templates by type
+     * @type {EncodingTemplateType}
+     * @memberof EncodingTemplateResponseListQueryParams
+     */
+    type?: EncodingTemplateType | undefined;
+}
+export declare class EncodingTemplateResponseListQueryParamsBuilder {
+    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 type Filter the stored templates by type
+     */
+    type(type: EncodingTemplateType): this;
+    buildQueryParams(): EncodingTemplateResponseListQueryParams;
+}

package/dist/encoding/templates/EncodingTemplateResponseListQueryParams.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EncodingTemplateResponseListQueryParamsBuilder = void 0;
+var EncodingTemplateResponseListQueryParamsBuilder = /** @class */ (function () {
+    function EncodingTemplateResponseListQueryParamsBuilder() {
+        this.internalParams = {};
+    }
+    /**
+     *
+     * @param offset Index of the first item to return, starting at 0. Default is 0
+     */
+    EncodingTemplateResponseListQueryParamsBuilder.prototype.offset = function (offset) {
+        this.internalParams.offset = offset;
+        return this;
+    };
+    /**
+     *
+     * @param limit Maximum number of items to return. Default is 25, maximum is 100
+     */
+    EncodingTemplateResponseListQueryParamsBuilder.prototype.limit = function (limit) {
+        this.internalParams.limit = limit;
+        return this;
+    };
+    /**
+     *
+     * @param type Filter the stored templates by type
+     */
+    EncodingTemplateResponseListQueryParamsBuilder.prototype.type = function (type) {
+        this.internalParams.type = type;
+        return this;
+    };
+    EncodingTemplateResponseListQueryParamsBuilder.prototype.buildQueryParams = function () {
+        return this.internalParams;
+    };
+    return EncodingTemplateResponseListQueryParamsBuilder;
+}());
+exports.EncodingTemplateResponseListQueryParamsBuilder = EncodingTemplateResponseListQueryParamsBuilder;

package/dist/encoding/templates/TemplatesApi.d.ts

@@ -1,6 +1,11 @@
 import { BaseAPI } from '../../common/BaseAPI';
 import Configuration from '../../common/Configuration';
+import BitmovinResponse from '../../models/BitmovinResponse';
+import EncodingTemplateDetails from '../../models/EncodingTemplateDetails';
+import EncodingTemplateResponse from '../../models/EncodingTemplateResponse';
 import EncodingTemplateStartResponse from '../../models/EncodingTemplateStartResponse';
+import PaginationResponse from '../../models/PaginationResponse';
+import { EncodingTemplateResponseListQueryParams, EncodingTemplateResponseListQueryParamsBuilder } from './EncodingTemplateResponseListQueryParams';
 /**
  * TemplatesApi - object-oriented interface
  * @export
@@ -9,6 +14,34 @@ import EncodingTemplateStartResponse from '../../models/EncodingTemplateStartRes
  */
 export default class TemplatesApi extends BaseAPI {
     constructor(configuration: Configuration);
+    /**
+     * @summary Store an Encoding Template
+     * @param {any} encodingTemplateRequest The Encoding Template to be stored
+     * @throws {BitmovinError}
+     * @memberof TemplatesApi
+     */
+    create(encodingTemplateRequest?: any): Promise<EncodingTemplateDetails>;
+    /**
+     * @summary Delete Encoding Template
+     * @param {string} encodingTemplateId Id of the encoding template to delete
+     * @throws {BitmovinError}
+     * @memberof TemplatesApi
+     */
+    delete(encodingTemplateId: string): Promise<BitmovinResponse>;
+    /**
+     * @summary Encoding Template details
+     * @param {string} encodingTemplateId Id of the Encoding Template
+     * @throws {BitmovinError}
+     * @memberof TemplatesApi
+     */
+    get(encodingTemplateId: string): Promise<EncodingTemplateDetails>;
+    /**
+     * @summary List stored Encoding Templates
+     * @param {*} [queryParameters] query parameters for filtering, sorting and pagination
+     * @throws {BitmovinError}
+     * @memberof TemplatesApi
+     */
+    list(queryParameters?: EncodingTemplateResponseListQueryParams | ((q: EncodingTemplateResponseListQueryParamsBuilder) => EncodingTemplateResponseListQueryParamsBuilder)): Promise<PaginationResponse<EncodingTemplateResponse>>;
     /**
      * @summary BETA: Start an Encoding defined with an Encoding Template
      * @param {any} encodingTemplateRequest The Encoding Template to start an Encoding from