@aws-sdk/client-medialive 3.180.0 → 3.183.0

package/dist-es/commands/StopMultiplexCommand.js

@@ -1,39 +1,32 @@
-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";
-var StopMultiplexCommand = (function (_super) {
-    __extends(StopMultiplexCommand, _super);
-    function StopMultiplexCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class StopMultiplexCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    StopMultiplexCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+    resolveMiddleware(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 = "StopMultiplexCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "MediaLiveClient";
+        const commandName = "StopMultiplexCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: StopMultiplexRequestFilterSensitiveLog,
             outputFilterSensitiveLog: StopMultiplexResponseFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    StopMultiplexCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_restJson1StopMultiplexCommand(input, context);
-    };
-    StopMultiplexCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_restJson1StopMultiplexCommand(output, context);
-    };
-    return StopMultiplexCommand;
-}($Command));
-export { StopMultiplexCommand };
+    }
+}

package/dist-es/commands/TransferInputDeviceCommand.js

@@ -1,39 +1,32 @@
-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";
-var TransferInputDeviceCommand = (function (_super) {
-    __extends(TransferInputDeviceCommand, _super);
-    function TransferInputDeviceCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class TransferInputDeviceCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    TransferInputDeviceCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+    resolveMiddleware(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 = "TransferInputDeviceCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "MediaLiveClient";
+        const commandName = "TransferInputDeviceCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: TransferInputDeviceRequestFilterSensitiveLog,
             outputFilterSensitiveLog: TransferInputDeviceResponseFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    TransferInputDeviceCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_restJson1TransferInputDeviceCommand(input, context);
-    };
-    TransferInputDeviceCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_restJson1TransferInputDeviceCommand(output, context);
-    };
-    return TransferInputDeviceCommand;
-}($Command));
-export { TransferInputDeviceCommand };
+    }
+}

package/dist-es/commands/UpdateChannelClassCommand.js

@@ -1,39 +1,32 @@
-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";
-var UpdateChannelClassCommand = (function (_super) {
-    __extends(UpdateChannelClassCommand, _super);
-    function UpdateChannelClassCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class UpdateChannelClassCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    UpdateChannelClassCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+    resolveMiddleware(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 = "UpdateChannelClassCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "MediaLiveClient";
+        const commandName = "UpdateChannelClassCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: UpdateChannelClassRequestFilterSensitiveLog,
             outputFilterSensitiveLog: UpdateChannelClassResponseFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    UpdateChannelClassCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_restJson1UpdateChannelClassCommand(input, context);
-    };
-    UpdateChannelClassCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_restJson1UpdateChannelClassCommand(output, context);
-    };
-    return UpdateChannelClassCommand;
-}($Command));
-export { UpdateChannelClassCommand };
+    }
+}

package/dist-es/commands/UpdateChannelCommand.js

@@ -1,39 +1,32 @@
-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";
-var UpdateChannelCommand = (function (_super) {
-    __extends(UpdateChannelCommand, _super);
-    function UpdateChannelCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class UpdateChannelCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    UpdateChannelCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+    resolveMiddleware(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 = "UpdateChannelCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "MediaLiveClient";
+        const commandName = "UpdateChannelCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: UpdateChannelRequestFilterSensitiveLog,
             outputFilterSensitiveLog: UpdateChannelResponseFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    UpdateChannelCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_restJson1UpdateChannelCommand(input, context);
-    };
-    UpdateChannelCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_restJson1UpdateChannelCommand(output, context);
-    };
-    return UpdateChannelCommand;
-}($Command));
-export { UpdateChannelCommand };
+    }
+}

package/dist-es/commands/UpdateInputCommand.js

@@ -1,39 +1,32 @@
-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";
-var UpdateInputCommand = (function (_super) {
-    __extends(UpdateInputCommand, _super);
-    function UpdateInputCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class UpdateInputCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    UpdateInputCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+    resolveMiddleware(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 = "UpdateInputCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "MediaLiveClient";
+        const commandName = "UpdateInputCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: UpdateInputRequestFilterSensitiveLog,
             outputFilterSensitiveLog: UpdateInputResponseFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    UpdateInputCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_restJson1UpdateInputCommand(input, context);
-    };
-    UpdateInputCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_restJson1UpdateInputCommand(output, context);
-    };
-    return UpdateInputCommand;
-}($Command));
-export { UpdateInputCommand };
+    }
+}

package/dist-es/commands/UpdateInputDeviceCommand.js

@@ -1,39 +1,32 @@
-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";
-var UpdateInputDeviceCommand = (function (_super) {
-    __extends(UpdateInputDeviceCommand, _super);
-    function UpdateInputDeviceCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class UpdateInputDeviceCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    UpdateInputDeviceCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+    resolveMiddleware(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 = "UpdateInputDeviceCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "MediaLiveClient";
+        const commandName = "UpdateInputDeviceCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: UpdateInputDeviceRequestFilterSensitiveLog,
             outputFilterSensitiveLog: UpdateInputDeviceResponseFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    UpdateInputDeviceCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_restJson1UpdateInputDeviceCommand(input, context);
-    };
-    UpdateInputDeviceCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_restJson1UpdateInputDeviceCommand(output, context);
-    };
-    return UpdateInputDeviceCommand;
-}($Command));
-export { UpdateInputDeviceCommand };
+    }
+}

package/dist-es/commands/UpdateInputSecurityGroupCommand.js

@@ -1,39 +1,32 @@
-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";
-var UpdateInputSecurityGroupCommand = (function (_super) {
-    __extends(UpdateInputSecurityGroupCommand, _super);
-    function UpdateInputSecurityGroupCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class UpdateInputSecurityGroupCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    UpdateInputSecurityGroupCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+    resolveMiddleware(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 = "UpdateInputSecurityGroupCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "MediaLiveClient";
+        const commandName = "UpdateInputSecurityGroupCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: UpdateInputSecurityGroupRequestFilterSensitiveLog,
             outputFilterSensitiveLog: UpdateInputSecurityGroupResponseFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    UpdateInputSecurityGroupCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_restJson1UpdateInputSecurityGroupCommand(input, context);
-    };
-    UpdateInputSecurityGroupCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_restJson1UpdateInputSecurityGroupCommand(output, context);
-    };
-    return UpdateInputSecurityGroupCommand;
-}($Command));
-export { UpdateInputSecurityGroupCommand };
+    }
+}

package/dist-es/commands/UpdateMultiplexCommand.js

@@ -1,39 +1,32 @@
-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";
-var UpdateMultiplexCommand = (function (_super) {
-    __extends(UpdateMultiplexCommand, _super);
-    function UpdateMultiplexCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class UpdateMultiplexCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    UpdateMultiplexCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+    resolveMiddleware(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 = "UpdateMultiplexCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "MediaLiveClient";
+        const commandName = "UpdateMultiplexCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: UpdateMultiplexRequestFilterSensitiveLog,
             outputFilterSensitiveLog: UpdateMultiplexResponseFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    UpdateMultiplexCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_restJson1UpdateMultiplexCommand(input, context);
-    };
-    UpdateMultiplexCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_restJson1UpdateMultiplexCommand(output, context);
-    };
-    return UpdateMultiplexCommand;
-}($Command));
-export { UpdateMultiplexCommand };
+    }
+}

package/dist-es/commands/UpdateMultiplexProgramCommand.js

@@ -1,39 +1,32 @@
-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";
-var UpdateMultiplexProgramCommand = (function (_super) {
-    __extends(UpdateMultiplexProgramCommand, _super);
-    function UpdateMultiplexProgramCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class UpdateMultiplexProgramCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    UpdateMultiplexProgramCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+    resolveMiddleware(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 = "UpdateMultiplexProgramCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "MediaLiveClient";
+        const commandName = "UpdateMultiplexProgramCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: UpdateMultiplexProgramRequestFilterSensitiveLog,
             outputFilterSensitiveLog: UpdateMultiplexProgramResponseFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    UpdateMultiplexProgramCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_restJson1UpdateMultiplexProgramCommand(input, context);
-    };
-    UpdateMultiplexProgramCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_restJson1UpdateMultiplexProgramCommand(output, context);
-    };
-    return UpdateMultiplexProgramCommand;
-}($Command));
-export { UpdateMultiplexProgramCommand };
+    }
+}

package/dist-es/commands/UpdateReservationCommand.js

@@ -1,39 +1,32 @@
-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";
-var UpdateReservationCommand = (function (_super) {
-    __extends(UpdateReservationCommand, _super);
-    function UpdateReservationCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class UpdateReservationCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    UpdateReservationCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+    resolveMiddleware(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 = "UpdateReservationCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "MediaLiveClient";
+        const commandName = "UpdateReservationCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: UpdateReservationRequestFilterSensitiveLog,
             outputFilterSensitiveLog: UpdateReservationResponseFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    UpdateReservationCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_restJson1UpdateReservationCommand(input, context);
-    };
-    UpdateReservationCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_restJson1UpdateReservationCommand(output, context);
-    };
-    return UpdateReservationCommand;
-}($Command));
-export { UpdateReservationCommand };
+    }
+}