@aws-sdk/client-elasticache 3.183.0 → 3.185.0

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

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

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

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

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

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

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

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

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

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