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

package/dist-es/ElasticLoadBalancingV2.js

@@ -1,3 +1,4 @@
+import { __extends } from "tslib";
 import { AddListenerCertificatesCommand, } from "./commands/AddListenerCertificatesCommand";
 import { AddTagsCommand } from "./commands/AddTagsCommand";
 import { CreateListenerCommand, } from "./commands/CreateListenerCommand";
@@ -33,481 +34,487 @@ import { SetRulePrioritiesCommand, } from "./commands/SetRulePrioritiesCommand";
 import { SetSecurityGroupsCommand, } from "./commands/SetSecurityGroupsCommand";
 import { SetSubnetsCommand } from "./commands/SetSubnetsCommand";
 import { ElasticLoadBalancingV2Client } from "./ElasticLoadBalancingV2Client";
-export class ElasticLoadBalancingV2 extends ElasticLoadBalancingV2Client {
-    addListenerCertificates(args, optionsOrCb, cb) {
-        const command = new AddListenerCertificatesCommand(args);
+var ElasticLoadBalancingV2 = (function (_super) {
+    __extends(ElasticLoadBalancingV2, _super);
+    function ElasticLoadBalancingV2() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    ElasticLoadBalancingV2.prototype.addListenerCertificates = function (args, optionsOrCb, cb) {
+        var command = new AddListenerCertificatesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    addTags(args, optionsOrCb, cb) {
-        const command = new AddTagsCommand(args);
+    };
+    ElasticLoadBalancingV2.prototype.addTags = function (args, optionsOrCb, cb) {
+        var command = new AddTagsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createListener(args, optionsOrCb, cb) {
-        const command = new CreateListenerCommand(args);
+    };
+    ElasticLoadBalancingV2.prototype.createListener = function (args, optionsOrCb, cb) {
+        var command = new CreateListenerCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createLoadBalancer(args, optionsOrCb, cb) {
-        const command = new CreateLoadBalancerCommand(args);
+    };
+    ElasticLoadBalancingV2.prototype.createLoadBalancer = function (args, optionsOrCb, cb) {
+        var command = new CreateLoadBalancerCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createRule(args, optionsOrCb, cb) {
-        const command = new CreateRuleCommand(args);
+    };
+    ElasticLoadBalancingV2.prototype.createRule = function (args, optionsOrCb, cb) {
+        var command = new CreateRuleCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createTargetGroup(args, optionsOrCb, cb) {
-        const command = new CreateTargetGroupCommand(args);
+    };
+    ElasticLoadBalancingV2.prototype.createTargetGroup = function (args, optionsOrCb, cb) {
+        var command = new CreateTargetGroupCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteListener(args, optionsOrCb, cb) {
-        const command = new DeleteListenerCommand(args);
+    };
+    ElasticLoadBalancingV2.prototype.deleteListener = function (args, optionsOrCb, cb) {
+        var command = new DeleteListenerCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteLoadBalancer(args, optionsOrCb, cb) {
-        const command = new DeleteLoadBalancerCommand(args);
+    };
+    ElasticLoadBalancingV2.prototype.deleteLoadBalancer = function (args, optionsOrCb, cb) {
+        var command = new DeleteLoadBalancerCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteRule(args, optionsOrCb, cb) {
-        const command = new DeleteRuleCommand(args);
+    };
+    ElasticLoadBalancingV2.prototype.deleteRule = function (args, optionsOrCb, cb) {
+        var command = new DeleteRuleCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteTargetGroup(args, optionsOrCb, cb) {
-        const command = new DeleteTargetGroupCommand(args);
+    };
+    ElasticLoadBalancingV2.prototype.deleteTargetGroup = function (args, optionsOrCb, cb) {
+        var command = new DeleteTargetGroupCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deregisterTargets(args, optionsOrCb, cb) {
-        const command = new DeregisterTargetsCommand(args);
+    };
+    ElasticLoadBalancingV2.prototype.deregisterTargets = function (args, optionsOrCb, cb) {
+        var command = new DeregisterTargetsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeAccountLimits(args, optionsOrCb, cb) {
-        const command = new DescribeAccountLimitsCommand(args);
+    };
+    ElasticLoadBalancingV2.prototype.describeAccountLimits = function (args, optionsOrCb, cb) {
+        var command = new DescribeAccountLimitsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeListenerCertificates(args, optionsOrCb, cb) {
-        const command = new DescribeListenerCertificatesCommand(args);
+    };
+    ElasticLoadBalancingV2.prototype.describeListenerCertificates = function (args, optionsOrCb, cb) {
+        var command = new DescribeListenerCertificatesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeListeners(args, optionsOrCb, cb) {
-        const command = new DescribeListenersCommand(args);
+    };
+    ElasticLoadBalancingV2.prototype.describeListeners = function (args, optionsOrCb, cb) {
+        var command = new DescribeListenersCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeLoadBalancerAttributes(args, optionsOrCb, cb) {
-        const command = new DescribeLoadBalancerAttributesCommand(args);
+    };
+    ElasticLoadBalancingV2.prototype.describeLoadBalancerAttributes = function (args, optionsOrCb, cb) {
+        var command = new DescribeLoadBalancerAttributesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeLoadBalancers(args, optionsOrCb, cb) {
-        const command = new DescribeLoadBalancersCommand(args);
+    };
+    ElasticLoadBalancingV2.prototype.describeLoadBalancers = function (args, optionsOrCb, cb) {
+        var command = new DescribeLoadBalancersCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeRules(args, optionsOrCb, cb) {
-        const command = new DescribeRulesCommand(args);
+    };
+    ElasticLoadBalancingV2.prototype.describeRules = function (args, optionsOrCb, cb) {
+        var command = new DescribeRulesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeSSLPolicies(args, optionsOrCb, cb) {
-        const command = new DescribeSSLPoliciesCommand(args);
+    };
+    ElasticLoadBalancingV2.prototype.describeSSLPolicies = function (args, optionsOrCb, cb) {
+        var command = new DescribeSSLPoliciesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeTags(args, optionsOrCb, cb) {
-        const command = new DescribeTagsCommand(args);
+    };
+    ElasticLoadBalancingV2.prototype.describeTags = function (args, optionsOrCb, cb) {
+        var command = new DescribeTagsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeTargetGroupAttributes(args, optionsOrCb, cb) {
-        const command = new DescribeTargetGroupAttributesCommand(args);
+    };
+    ElasticLoadBalancingV2.prototype.describeTargetGroupAttributes = function (args, optionsOrCb, cb) {
+        var command = new DescribeTargetGroupAttributesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeTargetGroups(args, optionsOrCb, cb) {
-        const command = new DescribeTargetGroupsCommand(args);
+    };
+    ElasticLoadBalancingV2.prototype.describeTargetGroups = function (args, optionsOrCb, cb) {
+        var command = new DescribeTargetGroupsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeTargetHealth(args, optionsOrCb, cb) {
-        const command = new DescribeTargetHealthCommand(args);
+    };
+    ElasticLoadBalancingV2.prototype.describeTargetHealth = function (args, optionsOrCb, cb) {
+        var command = new DescribeTargetHealthCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    modifyListener(args, optionsOrCb, cb) {
-        const command = new ModifyListenerCommand(args);
+    };
+    ElasticLoadBalancingV2.prototype.modifyListener = function (args, optionsOrCb, cb) {
+        var command = new ModifyListenerCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    modifyLoadBalancerAttributes(args, optionsOrCb, cb) {
-        const command = new ModifyLoadBalancerAttributesCommand(args);
+    };
+    ElasticLoadBalancingV2.prototype.modifyLoadBalancerAttributes = function (args, optionsOrCb, cb) {
+        var command = new ModifyLoadBalancerAttributesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    modifyRule(args, optionsOrCb, cb) {
-        const command = new ModifyRuleCommand(args);
+    };
+    ElasticLoadBalancingV2.prototype.modifyRule = function (args, optionsOrCb, cb) {
+        var command = new ModifyRuleCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    modifyTargetGroup(args, optionsOrCb, cb) {
-        const command = new ModifyTargetGroupCommand(args);
+    };
+    ElasticLoadBalancingV2.prototype.modifyTargetGroup = function (args, optionsOrCb, cb) {
+        var command = new ModifyTargetGroupCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    modifyTargetGroupAttributes(args, optionsOrCb, cb) {
-        const command = new ModifyTargetGroupAttributesCommand(args);
+    };
+    ElasticLoadBalancingV2.prototype.modifyTargetGroupAttributes = function (args, optionsOrCb, cb) {
+        var command = new ModifyTargetGroupAttributesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    registerTargets(args, optionsOrCb, cb) {
-        const command = new RegisterTargetsCommand(args);
+    };
+    ElasticLoadBalancingV2.prototype.registerTargets = function (args, optionsOrCb, cb) {
+        var command = new RegisterTargetsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    removeListenerCertificates(args, optionsOrCb, cb) {
-        const command = new RemoveListenerCertificatesCommand(args);
+    };
+    ElasticLoadBalancingV2.prototype.removeListenerCertificates = function (args, optionsOrCb, cb) {
+        var command = new RemoveListenerCertificatesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    removeTags(args, optionsOrCb, cb) {
-        const command = new RemoveTagsCommand(args);
+    };
+    ElasticLoadBalancingV2.prototype.removeTags = function (args, optionsOrCb, cb) {
+        var command = new RemoveTagsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    setIpAddressType(args, optionsOrCb, cb) {
-        const command = new SetIpAddressTypeCommand(args);
+    };
+    ElasticLoadBalancingV2.prototype.setIpAddressType = function (args, optionsOrCb, cb) {
+        var command = new SetIpAddressTypeCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    setRulePriorities(args, optionsOrCb, cb) {
-        const command = new SetRulePrioritiesCommand(args);
+    };
+    ElasticLoadBalancingV2.prototype.setRulePriorities = function (args, optionsOrCb, cb) {
+        var command = new SetRulePrioritiesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    setSecurityGroups(args, optionsOrCb, cb) {
-        const command = new SetSecurityGroupsCommand(args);
+    };
+    ElasticLoadBalancingV2.prototype.setSecurityGroups = function (args, optionsOrCb, cb) {
+        var command = new SetSecurityGroupsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    setSubnets(args, optionsOrCb, cb) {
-        const command = new SetSubnetsCommand(args);
+    };
+    ElasticLoadBalancingV2.prototype.setSubnets = function (args, optionsOrCb, cb) {
+        var command = new SetSubnetsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-}
+    };
+    return ElasticLoadBalancingV2;
+}(ElasticLoadBalancingV2Client));
+export { ElasticLoadBalancingV2 };