@aws-sdk/client-medialive 3.34.0 → 3.37.0

package/dist-es/MediaLiveClient.js

@@ -0,0 +1,37 @@
+import { __extends } from "tslib";
+import { resolveEndpointsConfig, resolveRegionConfig, } from "@aws-sdk/config-resolver";
+import { getContentLengthPlugin } from "@aws-sdk/middleware-content-length";
+import { getHostHeaderPlugin, resolveHostHeaderConfig, } from "@aws-sdk/middleware-host-header";
+import { getLoggerPlugin } from "@aws-sdk/middleware-logger";
+import { getRetryPlugin, resolveRetryConfig } from "@aws-sdk/middleware-retry";
+import { getAwsAuthPlugin, resolveAwsAuthConfig, } from "@aws-sdk/middleware-signing";
+import { getUserAgentPlugin, resolveUserAgentConfig, } from "@aws-sdk/middleware-user-agent";
+import { Client as __Client, } from "@aws-sdk/smithy-client";
+import { getRuntimeConfig as __getRuntimeConfig } from "./runtimeConfig";
+var MediaLiveClient = (function (_super) {
+    __extends(MediaLiveClient, _super);
+    function MediaLiveClient(configuration) {
+        var _this = this;
+        var _config_0 = __getRuntimeConfig(configuration);
+        var _config_1 = resolveRegionConfig(_config_0);
+        var _config_2 = resolveEndpointsConfig(_config_1);
+        var _config_3 = resolveRetryConfig(_config_2);
+        var _config_4 = resolveHostHeaderConfig(_config_3);
+        var _config_5 = resolveAwsAuthConfig(_config_4);
+        var _config_6 = resolveUserAgentConfig(_config_5);
+        _this = _super.call(this, _config_6) || this;
+        _this.config = _config_6;
+        _this.middlewareStack.use(getRetryPlugin(_this.config));
+        _this.middlewareStack.use(getContentLengthPlugin(_this.config));
+        _this.middlewareStack.use(getHostHeaderPlugin(_this.config));
+        _this.middlewareStack.use(getLoggerPlugin(_this.config));
+        _this.middlewareStack.use(getAwsAuthPlugin(_this.config));
+        _this.middlewareStack.use(getUserAgentPlugin(_this.config));
+        return _this;
+    }
+    MediaLiveClient.prototype.destroy = function () {
+        _super.prototype.destroy.call(this);
+    };
+    return MediaLiveClient;
+}(__Client));
+export { MediaLiveClient };

package/dist-es/commands/AcceptInputDeviceTransferCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { AcceptInputDeviceTransferRequest, AcceptInputDeviceTransferResponse } from "../models/models_1";
+import { deserializeAws_restJson1AcceptInputDeviceTransferCommand, serializeAws_restJson1AcceptInputDeviceTransferCommand, } from "../protocols/Aws_restJson1";
+var AcceptInputDeviceTransferCommand = (function (_super) {
+    __extends(AcceptInputDeviceTransferCommand, _super);
+    function AcceptInputDeviceTransferCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    AcceptInputDeviceTransferCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "MediaLiveClient";
+        var commandName = "AcceptInputDeviceTransferCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: AcceptInputDeviceTransferRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: AcceptInputDeviceTransferResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    AcceptInputDeviceTransferCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1AcceptInputDeviceTransferCommand(input, context);
+    };
+    AcceptInputDeviceTransferCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1AcceptInputDeviceTransferCommand(output, context);
+    };
+    return AcceptInputDeviceTransferCommand;
+}($Command));
+export { AcceptInputDeviceTransferCommand };

package/dist-es/commands/BatchDeleteCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { BatchDeleteRequest, BatchDeleteResponse } from "../models/models_1";
+import { deserializeAws_restJson1BatchDeleteCommand, serializeAws_restJson1BatchDeleteCommand, } from "../protocols/Aws_restJson1";
+var BatchDeleteCommand = (function (_super) {
+    __extends(BatchDeleteCommand, _super);
+    function BatchDeleteCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    BatchDeleteCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "MediaLiveClient";
+        var commandName = "BatchDeleteCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: BatchDeleteRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: BatchDeleteResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    BatchDeleteCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1BatchDeleteCommand(input, context);
+    };
+    BatchDeleteCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1BatchDeleteCommand(output, context);
+    };
+    return BatchDeleteCommand;
+}($Command));
+export { BatchDeleteCommand };

package/dist-es/commands/BatchStartCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { BatchStartRequest, BatchStartResponse } from "../models/models_1";
+import { deserializeAws_restJson1BatchStartCommand, serializeAws_restJson1BatchStartCommand, } from "../protocols/Aws_restJson1";
+var BatchStartCommand = (function (_super) {
+    __extends(BatchStartCommand, _super);
+    function BatchStartCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    BatchStartCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "MediaLiveClient";
+        var commandName = "BatchStartCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: BatchStartRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: BatchStartResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    BatchStartCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1BatchStartCommand(input, context);
+    };
+    BatchStartCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1BatchStartCommand(output, context);
+    };
+    return BatchStartCommand;
+}($Command));
+export { BatchStartCommand };

package/dist-es/commands/BatchStopCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { BatchStopRequest, BatchStopResponse } from "../models/models_1";
+import { deserializeAws_restJson1BatchStopCommand, serializeAws_restJson1BatchStopCommand, } from "../protocols/Aws_restJson1";
+var BatchStopCommand = (function (_super) {
+    __extends(BatchStopCommand, _super);
+    function BatchStopCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    BatchStopCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "MediaLiveClient";
+        var commandName = "BatchStopCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: BatchStopRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: BatchStopResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    BatchStopCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1BatchStopCommand(input, context);
+    };
+    BatchStopCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1BatchStopCommand(output, context);
+    };
+    return BatchStopCommand;
+}($Command));
+export { BatchStopCommand };

package/dist-es/commands/BatchUpdateScheduleCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { BatchUpdateScheduleRequest, BatchUpdateScheduleResponse } from "../models/models_1";
+import { deserializeAws_restJson1BatchUpdateScheduleCommand, serializeAws_restJson1BatchUpdateScheduleCommand, } from "../protocols/Aws_restJson1";
+var BatchUpdateScheduleCommand = (function (_super) {
+    __extends(BatchUpdateScheduleCommand, _super);
+    function BatchUpdateScheduleCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    BatchUpdateScheduleCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "MediaLiveClient";
+        var commandName = "BatchUpdateScheduleCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: BatchUpdateScheduleRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: BatchUpdateScheduleResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    BatchUpdateScheduleCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1BatchUpdateScheduleCommand(input, context);
+    };
+    BatchUpdateScheduleCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1BatchUpdateScheduleCommand(output, context);
+    };
+    return BatchUpdateScheduleCommand;
+}($Command));
+export { BatchUpdateScheduleCommand };

package/dist-es/commands/CancelInputDeviceTransferCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { CancelInputDeviceTransferRequest, CancelInputDeviceTransferResponse } from "../models/models_1";
+import { deserializeAws_restJson1CancelInputDeviceTransferCommand, serializeAws_restJson1CancelInputDeviceTransferCommand, } from "../protocols/Aws_restJson1";
+var CancelInputDeviceTransferCommand = (function (_super) {
+    __extends(CancelInputDeviceTransferCommand, _super);
+    function CancelInputDeviceTransferCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    CancelInputDeviceTransferCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "MediaLiveClient";
+        var commandName = "CancelInputDeviceTransferCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: CancelInputDeviceTransferRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: CancelInputDeviceTransferResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CancelInputDeviceTransferCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1CancelInputDeviceTransferCommand(input, context);
+    };
+    CancelInputDeviceTransferCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1CancelInputDeviceTransferCommand(output, context);
+    };
+    return CancelInputDeviceTransferCommand;
+}($Command));
+export { CancelInputDeviceTransferCommand };

package/dist-es/commands/ClaimDeviceCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { ClaimDeviceRequest, ClaimDeviceResponse } from "../models/models_1";
+import { deserializeAws_restJson1ClaimDeviceCommand, serializeAws_restJson1ClaimDeviceCommand, } from "../protocols/Aws_restJson1";
+var ClaimDeviceCommand = (function (_super) {
+    __extends(ClaimDeviceCommand, _super);
+    function ClaimDeviceCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    ClaimDeviceCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "MediaLiveClient";
+        var commandName = "ClaimDeviceCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: ClaimDeviceRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: ClaimDeviceResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    ClaimDeviceCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1ClaimDeviceCommand(input, context);
+    };
+    ClaimDeviceCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1ClaimDeviceCommand(output, context);
+    };
+    return ClaimDeviceCommand;
+}($Command));
+export { ClaimDeviceCommand };

package/dist-es/commands/CreateChannelCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { CreateChannelRequest, CreateChannelResponse } from "../models/models_1";
+import { deserializeAws_restJson1CreateChannelCommand, serializeAws_restJson1CreateChannelCommand, } from "../protocols/Aws_restJson1";
+var CreateChannelCommand = (function (_super) {
+    __extends(CreateChannelCommand, _super);
+    function CreateChannelCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    CreateChannelCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "MediaLiveClient";
+        var commandName = "CreateChannelCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: CreateChannelRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: CreateChannelResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CreateChannelCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1CreateChannelCommand(input, context);
+    };
+    CreateChannelCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1CreateChannelCommand(output, context);
+    };
+    return CreateChannelCommand;
+}($Command));
+export { CreateChannelCommand };

package/dist-es/commands/CreateInputCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { CreateInputRequest, CreateInputResponse } from "../models/models_1";
+import { deserializeAws_restJson1CreateInputCommand, serializeAws_restJson1CreateInputCommand, } from "../protocols/Aws_restJson1";
+var CreateInputCommand = (function (_super) {
+    __extends(CreateInputCommand, _super);
+    function CreateInputCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    CreateInputCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "MediaLiveClient";
+        var commandName = "CreateInputCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: CreateInputRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: CreateInputResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CreateInputCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1CreateInputCommand(input, context);
+    };
+    CreateInputCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1CreateInputCommand(output, context);
+    };
+    return CreateInputCommand;
+}($Command));
+export { CreateInputCommand };

package/dist-es/commands/CreateInputSecurityGroupCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { CreateInputSecurityGroupRequest, CreateInputSecurityGroupResponse } from "../models/models_1";
+import { deserializeAws_restJson1CreateInputSecurityGroupCommand, serializeAws_restJson1CreateInputSecurityGroupCommand, } from "../protocols/Aws_restJson1";
+var CreateInputSecurityGroupCommand = (function (_super) {
+    __extends(CreateInputSecurityGroupCommand, _super);
+    function CreateInputSecurityGroupCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    CreateInputSecurityGroupCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "MediaLiveClient";
+        var commandName = "CreateInputSecurityGroupCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: CreateInputSecurityGroupRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: CreateInputSecurityGroupResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CreateInputSecurityGroupCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1CreateInputSecurityGroupCommand(input, context);
+    };
+    CreateInputSecurityGroupCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1CreateInputSecurityGroupCommand(output, context);
+    };
+    return CreateInputSecurityGroupCommand;
+}($Command));
+export { CreateInputSecurityGroupCommand };

package/dist-es/commands/CreateMultiplexCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { CreateMultiplexRequest, CreateMultiplexResponse } from "../models/models_1";
+import { deserializeAws_restJson1CreateMultiplexCommand, serializeAws_restJson1CreateMultiplexCommand, } from "../protocols/Aws_restJson1";
+var CreateMultiplexCommand = (function (_super) {
+    __extends(CreateMultiplexCommand, _super);
+    function CreateMultiplexCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    CreateMultiplexCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "MediaLiveClient";
+        var commandName = "CreateMultiplexCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: CreateMultiplexRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: CreateMultiplexResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CreateMultiplexCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1CreateMultiplexCommand(input, context);
+    };
+    CreateMultiplexCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1CreateMultiplexCommand(output, context);
+    };
+    return CreateMultiplexCommand;
+}($Command));
+export { CreateMultiplexCommand };

package/dist-es/commands/CreateMultiplexProgramCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { CreateMultiplexProgramRequest, CreateMultiplexProgramResponse } from "../models/models_1";
+import { deserializeAws_restJson1CreateMultiplexProgramCommand, serializeAws_restJson1CreateMultiplexProgramCommand, } from "../protocols/Aws_restJson1";
+var CreateMultiplexProgramCommand = (function (_super) {
+    __extends(CreateMultiplexProgramCommand, _super);
+    function CreateMultiplexProgramCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    CreateMultiplexProgramCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "MediaLiveClient";
+        var commandName = "CreateMultiplexProgramCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: CreateMultiplexProgramRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: CreateMultiplexProgramResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CreateMultiplexProgramCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1CreateMultiplexProgramCommand(input, context);
+    };
+    CreateMultiplexProgramCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1CreateMultiplexProgramCommand(output, context);
+    };
+    return CreateMultiplexProgramCommand;
+}($Command));
+export { CreateMultiplexProgramCommand };

package/dist-es/commands/CreatePartnerInputCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { CreatePartnerInputRequest, CreatePartnerInputResponse } from "../models/models_1";
+import { deserializeAws_restJson1CreatePartnerInputCommand, serializeAws_restJson1CreatePartnerInputCommand, } from "../protocols/Aws_restJson1";
+var CreatePartnerInputCommand = (function (_super) {
+    __extends(CreatePartnerInputCommand, _super);
+    function CreatePartnerInputCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    CreatePartnerInputCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "MediaLiveClient";
+        var commandName = "CreatePartnerInputCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: CreatePartnerInputRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: CreatePartnerInputResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CreatePartnerInputCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1CreatePartnerInputCommand(input, context);
+    };
+    CreatePartnerInputCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1CreatePartnerInputCommand(output, context);
+    };
+    return CreatePartnerInputCommand;
+}($Command));
+export { CreatePartnerInputCommand };

package/dist-es/commands/CreateTagsCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { CreateTagsRequest } from "../models/models_1";
+import { deserializeAws_restJson1CreateTagsCommand, serializeAws_restJson1CreateTagsCommand, } from "../protocols/Aws_restJson1";
+var CreateTagsCommand = (function (_super) {
+    __extends(CreateTagsCommand, _super);
+    function CreateTagsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    CreateTagsCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "MediaLiveClient";
+        var commandName = "CreateTagsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: CreateTagsRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: function (output) { return output; },
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CreateTagsCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1CreateTagsCommand(input, context);
+    };
+    CreateTagsCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1CreateTagsCommand(output, context);
+    };
+    return CreateTagsCommand;
+}($Command));
+export { CreateTagsCommand };

package/dist-es/commands/DeleteChannelCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { DeleteChannelRequest, DeleteChannelResponse } from "../models/models_1";
+import { deserializeAws_restJson1DeleteChannelCommand, serializeAws_restJson1DeleteChannelCommand, } from "../protocols/Aws_restJson1";
+var DeleteChannelCommand = (function (_super) {
+    __extends(DeleteChannelCommand, _super);
+    function DeleteChannelCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    DeleteChannelCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "MediaLiveClient";
+        var commandName = "DeleteChannelCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: DeleteChannelRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: DeleteChannelResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DeleteChannelCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1DeleteChannelCommand(input, context);
+    };
+    DeleteChannelCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1DeleteChannelCommand(output, context);
+    };
+    return DeleteChannelCommand;
+}($Command));
+export { DeleteChannelCommand };