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

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

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

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

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

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

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

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

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

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

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