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

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

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

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

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

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

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

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

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

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

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