@aws-sdk/client-elastic-load-balancing-v2 3.183.0 → 3.185.0

package/dist-es/commands/DescribeTargetGroupAttributesCommand.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 { DescribeTargetGroupAttributesInputFilterSensitiveLog, DescribeTargetGroupAttributesOutputFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_queryDescribeTargetGroupAttributesCommand, serializeAws_queryDescribeTargetGroupAttributesCommand, } from "../protocols/Aws_query";
-export class DescribeTargetGroupAttributesCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var DescribeTargetGroupAttributesCommand = (function (_super) {
+    __extends(DescribeTargetGroupAttributesCommand, _super);
+    function DescribeTargetGroupAttributesCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    DescribeTargetGroupAttributesCommand.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 = "ElasticLoadBalancingV2Client";
-        const commandName = "DescribeTargetGroupAttributesCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ElasticLoadBalancingV2Client";
+        var commandName = "DescribeTargetGroupAttributesCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: DescribeTargetGroupAttributesInputFilterSensitiveLog,
             outputFilterSensitiveLog: DescribeTargetGroupAttributesOutputFilterSensitiveLog,
         };
-        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);
+    };
+    DescribeTargetGroupAttributesCommand.prototype.serialize = function (input, context) {
         return serializeAws_queryDescribeTargetGroupAttributesCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    DescribeTargetGroupAttributesCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_queryDescribeTargetGroupAttributesCommand(output, context);
-    }
-}
+    };
+    return DescribeTargetGroupAttributesCommand;
+}($Command));
+export { DescribeTargetGroupAttributesCommand };

package/dist-es/commands/DescribeTargetGroupsCommand.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 { DescribeTargetGroupsInputFilterSensitiveLog, DescribeTargetGroupsOutputFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_queryDescribeTargetGroupsCommand, serializeAws_queryDescribeTargetGroupsCommand, } from "../protocols/Aws_query";
-export class DescribeTargetGroupsCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var DescribeTargetGroupsCommand = (function (_super) {
+    __extends(DescribeTargetGroupsCommand, _super);
+    function DescribeTargetGroupsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    DescribeTargetGroupsCommand.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 = "ElasticLoadBalancingV2Client";
-        const commandName = "DescribeTargetGroupsCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ElasticLoadBalancingV2Client";
+        var commandName = "DescribeTargetGroupsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: DescribeTargetGroupsInputFilterSensitiveLog,
             outputFilterSensitiveLog: DescribeTargetGroupsOutputFilterSensitiveLog,
         };
-        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);
+    };
+    DescribeTargetGroupsCommand.prototype.serialize = function (input, context) {
         return serializeAws_queryDescribeTargetGroupsCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    DescribeTargetGroupsCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_queryDescribeTargetGroupsCommand(output, context);
-    }
-}
+    };
+    return DescribeTargetGroupsCommand;
+}($Command));
+export { DescribeTargetGroupsCommand };

package/dist-es/commands/DescribeTargetHealthCommand.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 { DescribeTargetHealthInputFilterSensitiveLog, DescribeTargetHealthOutputFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_queryDescribeTargetHealthCommand, serializeAws_queryDescribeTargetHealthCommand, } from "../protocols/Aws_query";
-export class DescribeTargetHealthCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var DescribeTargetHealthCommand = (function (_super) {
+    __extends(DescribeTargetHealthCommand, _super);
+    function DescribeTargetHealthCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    DescribeTargetHealthCommand.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 = "ElasticLoadBalancingV2Client";
-        const commandName = "DescribeTargetHealthCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ElasticLoadBalancingV2Client";
+        var commandName = "DescribeTargetHealthCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: DescribeTargetHealthInputFilterSensitiveLog,
             outputFilterSensitiveLog: DescribeTargetHealthOutputFilterSensitiveLog,
         };
-        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);
+    };
+    DescribeTargetHealthCommand.prototype.serialize = function (input, context) {
         return serializeAws_queryDescribeTargetHealthCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    DescribeTargetHealthCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_queryDescribeTargetHealthCommand(output, context);
-    }
-}
+    };
+    return DescribeTargetHealthCommand;
+}($Command));
+export { DescribeTargetHealthCommand };

package/dist-es/commands/ModifyListenerCommand.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 { ModifyListenerInputFilterSensitiveLog, ModifyListenerOutputFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_queryModifyListenerCommand, serializeAws_queryModifyListenerCommand, } from "../protocols/Aws_query";
-export class ModifyListenerCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var ModifyListenerCommand = (function (_super) {
+    __extends(ModifyListenerCommand, _super);
+    function ModifyListenerCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    ModifyListenerCommand.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 = "ElasticLoadBalancingV2Client";
-        const commandName = "ModifyListenerCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ElasticLoadBalancingV2Client";
+        var commandName = "ModifyListenerCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: ModifyListenerInputFilterSensitiveLog,
             outputFilterSensitiveLog: ModifyListenerOutputFilterSensitiveLog,
         };
-        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);
+    };
+    ModifyListenerCommand.prototype.serialize = function (input, context) {
         return serializeAws_queryModifyListenerCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    ModifyListenerCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_queryModifyListenerCommand(output, context);
-    }
-}
+    };
+    return ModifyListenerCommand;
+}($Command));
+export { ModifyListenerCommand };

package/dist-es/commands/ModifyLoadBalancerAttributesCommand.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 { ModifyLoadBalancerAttributesInputFilterSensitiveLog, ModifyLoadBalancerAttributesOutputFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_queryModifyLoadBalancerAttributesCommand, serializeAws_queryModifyLoadBalancerAttributesCommand, } from "../protocols/Aws_query";
-export class ModifyLoadBalancerAttributesCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var ModifyLoadBalancerAttributesCommand = (function (_super) {
+    __extends(ModifyLoadBalancerAttributesCommand, _super);
+    function ModifyLoadBalancerAttributesCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    ModifyLoadBalancerAttributesCommand.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 = "ElasticLoadBalancingV2Client";
-        const commandName = "ModifyLoadBalancerAttributesCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ElasticLoadBalancingV2Client";
+        var commandName = "ModifyLoadBalancerAttributesCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: ModifyLoadBalancerAttributesInputFilterSensitiveLog,
             outputFilterSensitiveLog: ModifyLoadBalancerAttributesOutputFilterSensitiveLog,
         };
-        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);
+    };
+    ModifyLoadBalancerAttributesCommand.prototype.serialize = function (input, context) {
         return serializeAws_queryModifyLoadBalancerAttributesCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    ModifyLoadBalancerAttributesCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_queryModifyLoadBalancerAttributesCommand(output, context);
-    }
-}
+    };
+    return ModifyLoadBalancerAttributesCommand;
+}($Command));
+export { ModifyLoadBalancerAttributesCommand };

package/dist-es/commands/ModifyRuleCommand.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 { ModifyRuleInputFilterSensitiveLog, ModifyRuleOutputFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_queryModifyRuleCommand, serializeAws_queryModifyRuleCommand } from "../protocols/Aws_query";
-export class ModifyRuleCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var ModifyRuleCommand = (function (_super) {
+    __extends(ModifyRuleCommand, _super);
+    function ModifyRuleCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    ModifyRuleCommand.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 = "ElasticLoadBalancingV2Client";
-        const commandName = "ModifyRuleCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ElasticLoadBalancingV2Client";
+        var commandName = "ModifyRuleCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: ModifyRuleInputFilterSensitiveLog,
             outputFilterSensitiveLog: ModifyRuleOutputFilterSensitiveLog,
         };
-        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);
+    };
+    ModifyRuleCommand.prototype.serialize = function (input, context) {
         return serializeAws_queryModifyRuleCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    ModifyRuleCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_queryModifyRuleCommand(output, context);
-    }
-}
+    };
+    return ModifyRuleCommand;
+}($Command));
+export { ModifyRuleCommand };

package/dist-es/commands/ModifyTargetGroupAttributesCommand.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 { ModifyTargetGroupAttributesInputFilterSensitiveLog, ModifyTargetGroupAttributesOutputFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_queryModifyTargetGroupAttributesCommand, serializeAws_queryModifyTargetGroupAttributesCommand, } from "../protocols/Aws_query";
-export class ModifyTargetGroupAttributesCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var ModifyTargetGroupAttributesCommand = (function (_super) {
+    __extends(ModifyTargetGroupAttributesCommand, _super);
+    function ModifyTargetGroupAttributesCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    ModifyTargetGroupAttributesCommand.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 = "ElasticLoadBalancingV2Client";
-        const commandName = "ModifyTargetGroupAttributesCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ElasticLoadBalancingV2Client";
+        var commandName = "ModifyTargetGroupAttributesCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: ModifyTargetGroupAttributesInputFilterSensitiveLog,
             outputFilterSensitiveLog: ModifyTargetGroupAttributesOutputFilterSensitiveLog,
         };
-        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);
+    };
+    ModifyTargetGroupAttributesCommand.prototype.serialize = function (input, context) {
         return serializeAws_queryModifyTargetGroupAttributesCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    ModifyTargetGroupAttributesCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_queryModifyTargetGroupAttributesCommand(output, context);
-    }
-}
+    };
+    return ModifyTargetGroupAttributesCommand;
+}($Command));
+export { ModifyTargetGroupAttributesCommand };

package/dist-es/commands/ModifyTargetGroupCommand.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 { ModifyTargetGroupInputFilterSensitiveLog, ModifyTargetGroupOutputFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_queryModifyTargetGroupCommand, serializeAws_queryModifyTargetGroupCommand, } from "../protocols/Aws_query";
-export class ModifyTargetGroupCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var ModifyTargetGroupCommand = (function (_super) {
+    __extends(ModifyTargetGroupCommand, _super);
+    function ModifyTargetGroupCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    ModifyTargetGroupCommand.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 = "ElasticLoadBalancingV2Client";
-        const commandName = "ModifyTargetGroupCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ElasticLoadBalancingV2Client";
+        var commandName = "ModifyTargetGroupCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: ModifyTargetGroupInputFilterSensitiveLog,
             outputFilterSensitiveLog: ModifyTargetGroupOutputFilterSensitiveLog,
         };
-        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);
+    };
+    ModifyTargetGroupCommand.prototype.serialize = function (input, context) {
         return serializeAws_queryModifyTargetGroupCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    ModifyTargetGroupCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_queryModifyTargetGroupCommand(output, context);
-    }
-}
+    };
+    return ModifyTargetGroupCommand;
+}($Command));
+export { ModifyTargetGroupCommand };

package/dist-es/commands/RegisterTargetsCommand.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 { RegisterTargetsInputFilterSensitiveLog, RegisterTargetsOutputFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_queryRegisterTargetsCommand, serializeAws_queryRegisterTargetsCommand, } from "../protocols/Aws_query";
-export class RegisterTargetsCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var RegisterTargetsCommand = (function (_super) {
+    __extends(RegisterTargetsCommand, _super);
+    function RegisterTargetsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    RegisterTargetsCommand.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 = "ElasticLoadBalancingV2Client";
-        const commandName = "RegisterTargetsCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ElasticLoadBalancingV2Client";
+        var commandName = "RegisterTargetsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: RegisterTargetsInputFilterSensitiveLog,
             outputFilterSensitiveLog: RegisterTargetsOutputFilterSensitiveLog,
         };
-        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);
+    };
+    RegisterTargetsCommand.prototype.serialize = function (input, context) {
         return serializeAws_queryRegisterTargetsCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    RegisterTargetsCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_queryRegisterTargetsCommand(output, context);
-    }
-}
+    };
+    return RegisterTargetsCommand;
+}($Command));
+export { RegisterTargetsCommand };

package/dist-es/commands/RemoveListenerCertificatesCommand.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 { RemoveListenerCertificatesInputFilterSensitiveLog, RemoveListenerCertificatesOutputFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_queryRemoveListenerCertificatesCommand, serializeAws_queryRemoveListenerCertificatesCommand, } from "../protocols/Aws_query";
-export class RemoveListenerCertificatesCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var RemoveListenerCertificatesCommand = (function (_super) {
+    __extends(RemoveListenerCertificatesCommand, _super);
+    function RemoveListenerCertificatesCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    RemoveListenerCertificatesCommand.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 = "ElasticLoadBalancingV2Client";
-        const commandName = "RemoveListenerCertificatesCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ElasticLoadBalancingV2Client";
+        var commandName = "RemoveListenerCertificatesCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: RemoveListenerCertificatesInputFilterSensitiveLog,
             outputFilterSensitiveLog: RemoveListenerCertificatesOutputFilterSensitiveLog,
         };
-        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);
+    };
+    RemoveListenerCertificatesCommand.prototype.serialize = function (input, context) {
         return serializeAws_queryRemoveListenerCertificatesCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    RemoveListenerCertificatesCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_queryRemoveListenerCertificatesCommand(output, context);
-    }
-}
+    };
+    return RemoveListenerCertificatesCommand;
+}($Command));
+export { RemoveListenerCertificatesCommand };