@aws-sdk/client-elasticache 3.185.0 → 3.188.0

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

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

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

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

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

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

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

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

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

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