@aws-sdk/client-elasticache 3.183.0 → 3.185.0

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

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

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

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

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

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

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

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

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

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