@aws-sdk/client-medialive 3.183.0 → 3.185.0

package/dist-es/commands/StopMultiplexCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { StopMultiplexRequestFilterSensitiveLog, StopMultiplexResponseFilterSensitiveLog, } from "../models/models_1";
 import { deserializeAws_restJson1StopMultiplexCommand, serializeAws_restJson1StopMultiplexCommand, } from "../protocols/Aws_restJson1";
-export class StopMultiplexCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var StopMultiplexCommand = (function (_super) {
+    __extends(StopMultiplexCommand, _super);
+    function StopMultiplexCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    StopMultiplexCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "MediaLiveClient";
-        const commandName = "StopMultiplexCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "MediaLiveClient";
+        var commandName = "StopMultiplexCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: StopMultiplexRequestFilterSensitiveLog,
             outputFilterSensitiveLog: StopMultiplexResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    StopMultiplexCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1StopMultiplexCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    StopMultiplexCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1StopMultiplexCommand(output, context);
-    }
-}
+    };
+    return StopMultiplexCommand;
+}($Command));
+export { StopMultiplexCommand };

package/dist-es/commands/TransferInputDeviceCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { TransferInputDeviceRequestFilterSensitiveLog, TransferInputDeviceResponseFilterSensitiveLog, } from "../models/models_1";
 import { deserializeAws_restJson1TransferInputDeviceCommand, serializeAws_restJson1TransferInputDeviceCommand, } from "../protocols/Aws_restJson1";
-export class TransferInputDeviceCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var TransferInputDeviceCommand = (function (_super) {
+    __extends(TransferInputDeviceCommand, _super);
+    function TransferInputDeviceCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    TransferInputDeviceCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "MediaLiveClient";
-        const commandName = "TransferInputDeviceCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "MediaLiveClient";
+        var commandName = "TransferInputDeviceCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: TransferInputDeviceRequestFilterSensitiveLog,
             outputFilterSensitiveLog: TransferInputDeviceResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    TransferInputDeviceCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1TransferInputDeviceCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    TransferInputDeviceCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1TransferInputDeviceCommand(output, context);
-    }
-}
+    };
+    return TransferInputDeviceCommand;
+}($Command));
+export { TransferInputDeviceCommand };

package/dist-es/commands/UpdateChannelClassCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { UpdateChannelClassRequestFilterSensitiveLog, UpdateChannelClassResponseFilterSensitiveLog, } from "../models/models_2";
 import { deserializeAws_restJson1UpdateChannelClassCommand, serializeAws_restJson1UpdateChannelClassCommand, } from "../protocols/Aws_restJson1";
-export class UpdateChannelClassCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var UpdateChannelClassCommand = (function (_super) {
+    __extends(UpdateChannelClassCommand, _super);
+    function UpdateChannelClassCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    UpdateChannelClassCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "MediaLiveClient";
-        const commandName = "UpdateChannelClassCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "MediaLiveClient";
+        var commandName = "UpdateChannelClassCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: UpdateChannelClassRequestFilterSensitiveLog,
             outputFilterSensitiveLog: UpdateChannelClassResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    UpdateChannelClassCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1UpdateChannelClassCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    UpdateChannelClassCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1UpdateChannelClassCommand(output, context);
-    }
-}
+    };
+    return UpdateChannelClassCommand;
+}($Command));
+export { UpdateChannelClassCommand };

package/dist-es/commands/UpdateChannelCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { UpdateChannelRequestFilterSensitiveLog, UpdateChannelResponseFilterSensitiveLog, } from "../models/models_2";
 import { deserializeAws_restJson1UpdateChannelCommand, serializeAws_restJson1UpdateChannelCommand, } from "../protocols/Aws_restJson1";
-export class UpdateChannelCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var UpdateChannelCommand = (function (_super) {
+    __extends(UpdateChannelCommand, _super);
+    function UpdateChannelCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    UpdateChannelCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "MediaLiveClient";
-        const commandName = "UpdateChannelCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "MediaLiveClient";
+        var commandName = "UpdateChannelCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: UpdateChannelRequestFilterSensitiveLog,
             outputFilterSensitiveLog: UpdateChannelResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    UpdateChannelCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1UpdateChannelCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    UpdateChannelCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1UpdateChannelCommand(output, context);
-    }
-}
+    };
+    return UpdateChannelCommand;
+}($Command));
+export { UpdateChannelCommand };

package/dist-es/commands/UpdateInputCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { UpdateInputRequestFilterSensitiveLog, UpdateInputResponseFilterSensitiveLog, } from "../models/models_2";
 import { deserializeAws_restJson1UpdateInputCommand, serializeAws_restJson1UpdateInputCommand, } from "../protocols/Aws_restJson1";
-export class UpdateInputCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var UpdateInputCommand = (function (_super) {
+    __extends(UpdateInputCommand, _super);
+    function UpdateInputCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    UpdateInputCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "MediaLiveClient";
-        const commandName = "UpdateInputCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "MediaLiveClient";
+        var commandName = "UpdateInputCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: UpdateInputRequestFilterSensitiveLog,
             outputFilterSensitiveLog: UpdateInputResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    UpdateInputCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1UpdateInputCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    UpdateInputCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1UpdateInputCommand(output, context);
-    }
-}
+    };
+    return UpdateInputCommand;
+}($Command));
+export { UpdateInputCommand };

package/dist-es/commands/UpdateInputDeviceCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { UpdateInputDeviceRequestFilterSensitiveLog, UpdateInputDeviceResponseFilterSensitiveLog, } from "../models/models_2";
 import { deserializeAws_restJson1UpdateInputDeviceCommand, serializeAws_restJson1UpdateInputDeviceCommand, } from "../protocols/Aws_restJson1";
-export class UpdateInputDeviceCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var UpdateInputDeviceCommand = (function (_super) {
+    __extends(UpdateInputDeviceCommand, _super);
+    function UpdateInputDeviceCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    UpdateInputDeviceCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "MediaLiveClient";
-        const commandName = "UpdateInputDeviceCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "MediaLiveClient";
+        var commandName = "UpdateInputDeviceCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: UpdateInputDeviceRequestFilterSensitiveLog,
             outputFilterSensitiveLog: UpdateInputDeviceResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    UpdateInputDeviceCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1UpdateInputDeviceCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    UpdateInputDeviceCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1UpdateInputDeviceCommand(output, context);
-    }
-}
+    };
+    return UpdateInputDeviceCommand;
+}($Command));
+export { UpdateInputDeviceCommand };

package/dist-es/commands/UpdateInputSecurityGroupCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { UpdateInputSecurityGroupRequestFilterSensitiveLog, UpdateInputSecurityGroupResponseFilterSensitiveLog, } from "../models/models_2";
 import { deserializeAws_restJson1UpdateInputSecurityGroupCommand, serializeAws_restJson1UpdateInputSecurityGroupCommand, } from "../protocols/Aws_restJson1";
-export class UpdateInputSecurityGroupCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var UpdateInputSecurityGroupCommand = (function (_super) {
+    __extends(UpdateInputSecurityGroupCommand, _super);
+    function UpdateInputSecurityGroupCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    UpdateInputSecurityGroupCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "MediaLiveClient";
-        const commandName = "UpdateInputSecurityGroupCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "MediaLiveClient";
+        var commandName = "UpdateInputSecurityGroupCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: UpdateInputSecurityGroupRequestFilterSensitiveLog,
             outputFilterSensitiveLog: UpdateInputSecurityGroupResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    UpdateInputSecurityGroupCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1UpdateInputSecurityGroupCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    UpdateInputSecurityGroupCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1UpdateInputSecurityGroupCommand(output, context);
-    }
-}
+    };
+    return UpdateInputSecurityGroupCommand;
+}($Command));
+export { UpdateInputSecurityGroupCommand };

package/dist-es/commands/UpdateMultiplexCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { UpdateMultiplexRequestFilterSensitiveLog, UpdateMultiplexResponseFilterSensitiveLog, } from "../models/models_2";
 import { deserializeAws_restJson1UpdateMultiplexCommand, serializeAws_restJson1UpdateMultiplexCommand, } from "../protocols/Aws_restJson1";
-export class UpdateMultiplexCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var UpdateMultiplexCommand = (function (_super) {
+    __extends(UpdateMultiplexCommand, _super);
+    function UpdateMultiplexCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    UpdateMultiplexCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "MediaLiveClient";
-        const commandName = "UpdateMultiplexCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "MediaLiveClient";
+        var commandName = "UpdateMultiplexCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: UpdateMultiplexRequestFilterSensitiveLog,
             outputFilterSensitiveLog: UpdateMultiplexResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    UpdateMultiplexCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1UpdateMultiplexCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    UpdateMultiplexCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1UpdateMultiplexCommand(output, context);
-    }
-}
+    };
+    return UpdateMultiplexCommand;
+}($Command));
+export { UpdateMultiplexCommand };

package/dist-es/commands/UpdateMultiplexProgramCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { UpdateMultiplexProgramRequestFilterSensitiveLog, UpdateMultiplexProgramResponseFilterSensitiveLog, } from "../models/models_2";
 import { deserializeAws_restJson1UpdateMultiplexProgramCommand, serializeAws_restJson1UpdateMultiplexProgramCommand, } from "../protocols/Aws_restJson1";
-export class UpdateMultiplexProgramCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var UpdateMultiplexProgramCommand = (function (_super) {
+    __extends(UpdateMultiplexProgramCommand, _super);
+    function UpdateMultiplexProgramCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    UpdateMultiplexProgramCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "MediaLiveClient";
-        const commandName = "UpdateMultiplexProgramCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "MediaLiveClient";
+        var commandName = "UpdateMultiplexProgramCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: UpdateMultiplexProgramRequestFilterSensitiveLog,
             outputFilterSensitiveLog: UpdateMultiplexProgramResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    UpdateMultiplexProgramCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1UpdateMultiplexProgramCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    UpdateMultiplexProgramCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1UpdateMultiplexProgramCommand(output, context);
-    }
-}
+    };
+    return UpdateMultiplexProgramCommand;
+}($Command));
+export { UpdateMultiplexProgramCommand };

package/dist-es/commands/UpdateReservationCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { UpdateReservationRequestFilterSensitiveLog, UpdateReservationResponseFilterSensitiveLog, } from "../models/models_2";
 import { deserializeAws_restJson1UpdateReservationCommand, serializeAws_restJson1UpdateReservationCommand, } from "../protocols/Aws_restJson1";
-export class UpdateReservationCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var UpdateReservationCommand = (function (_super) {
+    __extends(UpdateReservationCommand, _super);
+    function UpdateReservationCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    UpdateReservationCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "MediaLiveClient";
-        const commandName = "UpdateReservationCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "MediaLiveClient";
+        var commandName = "UpdateReservationCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: UpdateReservationRequestFilterSensitiveLog,
             outputFilterSensitiveLog: UpdateReservationResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    UpdateReservationCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1UpdateReservationCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    UpdateReservationCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1UpdateReservationCommand(output, context);
-    }
-}
+    };
+    return UpdateReservationCommand;
+}($Command));
+export { UpdateReservationCommand };