@aws-sdk/client-elasticache 3.183.0 → 3.185.0

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

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

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

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

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

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

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

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

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

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