@aws-sdk/client-elasticache 3.180.0 → 3.183.0

package/dist-es/commands/ModifyCacheClusterCommand.js

@@ -1,39 +1,32 @@
-import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { ModifyCacheClusterMessageFilterSensitiveLog, ModifyCacheClusterResultFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_queryModifyCacheClusterCommand, serializeAws_queryModifyCacheClusterCommand, } from "../protocols/Aws_query";
-var ModifyCacheClusterCommand = (function (_super) {
-    __extends(ModifyCacheClusterCommand, _super);
-    function ModifyCacheClusterCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class ModifyCacheClusterCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    ModifyCacheClusterCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+    resolveMiddleware(clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        var stack = clientStack.concat(this.middlewareStack);
-        var logger = configuration.logger;
-        var clientName = "ElastiCacheClient";
-        var commandName = "ModifyCacheClusterCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "ElastiCacheClient";
+        const commandName = "ModifyCacheClusterCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: ModifyCacheClusterMessageFilterSensitiveLog,
             outputFilterSensitiveLog: ModifyCacheClusterResultFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    ModifyCacheClusterCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_queryModifyCacheClusterCommand(input, context);
-    };
-    ModifyCacheClusterCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_queryModifyCacheClusterCommand(output, context);
-    };
-    return ModifyCacheClusterCommand;
-}($Command));
-export { ModifyCacheClusterCommand };
+    }
+}

package/dist-es/commands/ModifyCacheParameterGroupCommand.js

@@ -1,39 +1,32 @@
-import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { CacheParameterGroupNameMessageFilterSensitiveLog, ModifyCacheParameterGroupMessageFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_queryModifyCacheParameterGroupCommand, serializeAws_queryModifyCacheParameterGroupCommand, } from "../protocols/Aws_query";
-var ModifyCacheParameterGroupCommand = (function (_super) {
-    __extends(ModifyCacheParameterGroupCommand, _super);
-    function ModifyCacheParameterGroupCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class ModifyCacheParameterGroupCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    ModifyCacheParameterGroupCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+    resolveMiddleware(clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        var stack = clientStack.concat(this.middlewareStack);
-        var logger = configuration.logger;
-        var clientName = "ElastiCacheClient";
-        var commandName = "ModifyCacheParameterGroupCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "ElastiCacheClient";
+        const commandName = "ModifyCacheParameterGroupCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: ModifyCacheParameterGroupMessageFilterSensitiveLog,
             outputFilterSensitiveLog: CacheParameterGroupNameMessageFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    ModifyCacheParameterGroupCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_queryModifyCacheParameterGroupCommand(input, context);
-    };
-    ModifyCacheParameterGroupCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_queryModifyCacheParameterGroupCommand(output, context);
-    };
-    return ModifyCacheParameterGroupCommand;
-}($Command));
-export { ModifyCacheParameterGroupCommand };
+    }
+}

package/dist-es/commands/ModifyCacheSubnetGroupCommand.js

@@ -1,39 +1,32 @@
-import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { ModifyCacheSubnetGroupMessageFilterSensitiveLog, ModifyCacheSubnetGroupResultFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_queryModifyCacheSubnetGroupCommand, serializeAws_queryModifyCacheSubnetGroupCommand, } from "../protocols/Aws_query";
-var ModifyCacheSubnetGroupCommand = (function (_super) {
-    __extends(ModifyCacheSubnetGroupCommand, _super);
-    function ModifyCacheSubnetGroupCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class ModifyCacheSubnetGroupCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    ModifyCacheSubnetGroupCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+    resolveMiddleware(clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        var stack = clientStack.concat(this.middlewareStack);
-        var logger = configuration.logger;
-        var clientName = "ElastiCacheClient";
-        var commandName = "ModifyCacheSubnetGroupCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "ElastiCacheClient";
+        const commandName = "ModifyCacheSubnetGroupCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: ModifyCacheSubnetGroupMessageFilterSensitiveLog,
             outputFilterSensitiveLog: ModifyCacheSubnetGroupResultFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    ModifyCacheSubnetGroupCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_queryModifyCacheSubnetGroupCommand(input, context);
-    };
-    ModifyCacheSubnetGroupCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_queryModifyCacheSubnetGroupCommand(output, context);
-    };
-    return ModifyCacheSubnetGroupCommand;
-}($Command));
-export { ModifyCacheSubnetGroupCommand };
+    }
+}

package/dist-es/commands/ModifyGlobalReplicationGroupCommand.js

@@ -1,39 +1,32 @@
-import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { ModifyGlobalReplicationGroupMessageFilterSensitiveLog, ModifyGlobalReplicationGroupResultFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_queryModifyGlobalReplicationGroupCommand, serializeAws_queryModifyGlobalReplicationGroupCommand, } from "../protocols/Aws_query";
-var ModifyGlobalReplicationGroupCommand = (function (_super) {
-    __extends(ModifyGlobalReplicationGroupCommand, _super);
-    function ModifyGlobalReplicationGroupCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class ModifyGlobalReplicationGroupCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    ModifyGlobalReplicationGroupCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+    resolveMiddleware(clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        var stack = clientStack.concat(this.middlewareStack);
-        var logger = configuration.logger;
-        var clientName = "ElastiCacheClient";
-        var commandName = "ModifyGlobalReplicationGroupCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "ElastiCacheClient";
+        const commandName = "ModifyGlobalReplicationGroupCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: ModifyGlobalReplicationGroupMessageFilterSensitiveLog,
             outputFilterSensitiveLog: ModifyGlobalReplicationGroupResultFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    ModifyGlobalReplicationGroupCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_queryModifyGlobalReplicationGroupCommand(input, context);
-    };
-    ModifyGlobalReplicationGroupCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_queryModifyGlobalReplicationGroupCommand(output, context);
-    };
-    return ModifyGlobalReplicationGroupCommand;
-}($Command));
-export { ModifyGlobalReplicationGroupCommand };
+    }
+}

package/dist-es/commands/ModifyReplicationGroupCommand.js

@@ -1,39 +1,32 @@
-import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { ModifyReplicationGroupMessageFilterSensitiveLog, ModifyReplicationGroupResultFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_queryModifyReplicationGroupCommand, serializeAws_queryModifyReplicationGroupCommand, } from "../protocols/Aws_query";
-var ModifyReplicationGroupCommand = (function (_super) {
-    __extends(ModifyReplicationGroupCommand, _super);
-    function ModifyReplicationGroupCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class ModifyReplicationGroupCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    ModifyReplicationGroupCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+    resolveMiddleware(clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        var stack = clientStack.concat(this.middlewareStack);
-        var logger = configuration.logger;
-        var clientName = "ElastiCacheClient";
-        var commandName = "ModifyReplicationGroupCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "ElastiCacheClient";
+        const commandName = "ModifyReplicationGroupCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: ModifyReplicationGroupMessageFilterSensitiveLog,
             outputFilterSensitiveLog: ModifyReplicationGroupResultFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    ModifyReplicationGroupCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_queryModifyReplicationGroupCommand(input, context);
-    };
-    ModifyReplicationGroupCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_queryModifyReplicationGroupCommand(output, context);
-    };
-    return ModifyReplicationGroupCommand;
-}($Command));
-export { ModifyReplicationGroupCommand };
+    }
+}

package/dist-es/commands/ModifyReplicationGroupShardConfigurationCommand.js

@@ -1,39 +1,32 @@
-import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { ModifyReplicationGroupShardConfigurationMessageFilterSensitiveLog, ModifyReplicationGroupShardConfigurationResultFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_queryModifyReplicationGroupShardConfigurationCommand, serializeAws_queryModifyReplicationGroupShardConfigurationCommand, } from "../protocols/Aws_query";
-var ModifyReplicationGroupShardConfigurationCommand = (function (_super) {
-    __extends(ModifyReplicationGroupShardConfigurationCommand, _super);
-    function ModifyReplicationGroupShardConfigurationCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class ModifyReplicationGroupShardConfigurationCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    ModifyReplicationGroupShardConfigurationCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+    resolveMiddleware(clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        var stack = clientStack.concat(this.middlewareStack);
-        var logger = configuration.logger;
-        var clientName = "ElastiCacheClient";
-        var commandName = "ModifyReplicationGroupShardConfigurationCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "ElastiCacheClient";
+        const commandName = "ModifyReplicationGroupShardConfigurationCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: ModifyReplicationGroupShardConfigurationMessageFilterSensitiveLog,
             outputFilterSensitiveLog: ModifyReplicationGroupShardConfigurationResultFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    ModifyReplicationGroupShardConfigurationCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_queryModifyReplicationGroupShardConfigurationCommand(input, context);
-    };
-    ModifyReplicationGroupShardConfigurationCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_queryModifyReplicationGroupShardConfigurationCommand(output, context);
-    };
-    return ModifyReplicationGroupShardConfigurationCommand;
-}($Command));
-export { ModifyReplicationGroupShardConfigurationCommand };
+    }
+}

package/dist-es/commands/ModifyUserCommand.js

@@ -1,39 +1,32 @@
-import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { ModifyUserMessageFilterSensitiveLog, UserFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_queryModifyUserCommand, serializeAws_queryModifyUserCommand } from "../protocols/Aws_query";
-var ModifyUserCommand = (function (_super) {
-    __extends(ModifyUserCommand, _super);
-    function ModifyUserCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class ModifyUserCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    ModifyUserCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+    resolveMiddleware(clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        var stack = clientStack.concat(this.middlewareStack);
-        var logger = configuration.logger;
-        var clientName = "ElastiCacheClient";
-        var commandName = "ModifyUserCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "ElastiCacheClient";
+        const commandName = "ModifyUserCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: ModifyUserMessageFilterSensitiveLog,
             outputFilterSensitiveLog: UserFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    ModifyUserCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_queryModifyUserCommand(input, context);
-    };
-    ModifyUserCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_queryModifyUserCommand(output, context);
-    };
-    return ModifyUserCommand;
-}($Command));
-export { ModifyUserCommand };
+    }
+}

package/dist-es/commands/ModifyUserGroupCommand.js

@@ -1,39 +1,32 @@
-import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { ModifyUserGroupMessageFilterSensitiveLog, UserGroupFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_queryModifyUserGroupCommand, serializeAws_queryModifyUserGroupCommand, } from "../protocols/Aws_query";
-var ModifyUserGroupCommand = (function (_super) {
-    __extends(ModifyUserGroupCommand, _super);
-    function ModifyUserGroupCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class ModifyUserGroupCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    ModifyUserGroupCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+    resolveMiddleware(clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        var stack = clientStack.concat(this.middlewareStack);
-        var logger = configuration.logger;
-        var clientName = "ElastiCacheClient";
-        var commandName = "ModifyUserGroupCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "ElastiCacheClient";
+        const commandName = "ModifyUserGroupCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: ModifyUserGroupMessageFilterSensitiveLog,
             outputFilterSensitiveLog: UserGroupFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    ModifyUserGroupCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_queryModifyUserGroupCommand(input, context);
-    };
-    ModifyUserGroupCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_queryModifyUserGroupCommand(output, context);
-    };
-    return ModifyUserGroupCommand;
-}($Command));
-export { ModifyUserGroupCommand };
+    }
+}

package/dist-es/commands/PurchaseReservedCacheNodesOfferingCommand.js

@@ -1,39 +1,32 @@
-import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { PurchaseReservedCacheNodesOfferingMessageFilterSensitiveLog, PurchaseReservedCacheNodesOfferingResultFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_queryPurchaseReservedCacheNodesOfferingCommand, serializeAws_queryPurchaseReservedCacheNodesOfferingCommand, } from "../protocols/Aws_query";
-var PurchaseReservedCacheNodesOfferingCommand = (function (_super) {
-    __extends(PurchaseReservedCacheNodesOfferingCommand, _super);
-    function PurchaseReservedCacheNodesOfferingCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class PurchaseReservedCacheNodesOfferingCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    PurchaseReservedCacheNodesOfferingCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+    resolveMiddleware(clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        var stack = clientStack.concat(this.middlewareStack);
-        var logger = configuration.logger;
-        var clientName = "ElastiCacheClient";
-        var commandName = "PurchaseReservedCacheNodesOfferingCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "ElastiCacheClient";
+        const commandName = "PurchaseReservedCacheNodesOfferingCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: PurchaseReservedCacheNodesOfferingMessageFilterSensitiveLog,
             outputFilterSensitiveLog: PurchaseReservedCacheNodesOfferingResultFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    PurchaseReservedCacheNodesOfferingCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_queryPurchaseReservedCacheNodesOfferingCommand(input, context);
-    };
-    PurchaseReservedCacheNodesOfferingCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_queryPurchaseReservedCacheNodesOfferingCommand(output, context);
-    };
-    return PurchaseReservedCacheNodesOfferingCommand;
-}($Command));
-export { PurchaseReservedCacheNodesOfferingCommand };
+    }
+}

package/dist-es/commands/RebalanceSlotsInGlobalReplicationGroupCommand.js

@@ -1,39 +1,32 @@
-import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { RebalanceSlotsInGlobalReplicationGroupMessageFilterSensitiveLog, RebalanceSlotsInGlobalReplicationGroupResultFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_queryRebalanceSlotsInGlobalReplicationGroupCommand, serializeAws_queryRebalanceSlotsInGlobalReplicationGroupCommand, } from "../protocols/Aws_query";
-var RebalanceSlotsInGlobalReplicationGroupCommand = (function (_super) {
-    __extends(RebalanceSlotsInGlobalReplicationGroupCommand, _super);
-    function RebalanceSlotsInGlobalReplicationGroupCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class RebalanceSlotsInGlobalReplicationGroupCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    RebalanceSlotsInGlobalReplicationGroupCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+    resolveMiddleware(clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        var stack = clientStack.concat(this.middlewareStack);
-        var logger = configuration.logger;
-        var clientName = "ElastiCacheClient";
-        var commandName = "RebalanceSlotsInGlobalReplicationGroupCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "ElastiCacheClient";
+        const commandName = "RebalanceSlotsInGlobalReplicationGroupCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: RebalanceSlotsInGlobalReplicationGroupMessageFilterSensitiveLog,
             outputFilterSensitiveLog: RebalanceSlotsInGlobalReplicationGroupResultFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    RebalanceSlotsInGlobalReplicationGroupCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_queryRebalanceSlotsInGlobalReplicationGroupCommand(input, context);
-    };
-    RebalanceSlotsInGlobalReplicationGroupCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_queryRebalanceSlotsInGlobalReplicationGroupCommand(output, context);
-    };
-    return RebalanceSlotsInGlobalReplicationGroupCommand;
-}($Command));
-export { RebalanceSlotsInGlobalReplicationGroupCommand };
+    }
+}