@aws-sdk/client-elastic-beanstalk 3.183.0 → 3.186.0

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

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

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

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

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

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

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

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

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

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