@aws-sdk/client-elasticache 3.186.0 → 3.190.0

package/dist-es/ElastiCacheClient.js

@@ -1,4 +1,3 @@
-import { __extends } from "tslib";
 import { resolveEndpointsConfig, resolveRegionConfig, } from "@aws-sdk/config-resolver";
 import { getContentLengthPlugin } from "@aws-sdk/middleware-content-length";
 import { getHostHeaderPlugin, resolveHostHeaderConfig, } from "@aws-sdk/middleware-host-header";
@@ -9,31 +8,26 @@ import { getAwsAuthPlugin, resolveAwsAuthConfig, } from "@aws-sdk/middleware-sig
 import { getUserAgentPlugin, resolveUserAgentConfig, } from "@aws-sdk/middleware-user-agent";
 import { Client as __Client, } from "@aws-sdk/smithy-client";
 import { getRuntimeConfig as __getRuntimeConfig } from "./runtimeConfig";
-var ElastiCacheClient = (function (_super) {
-    __extends(ElastiCacheClient, _super);
-    function ElastiCacheClient(configuration) {
-        var _this = this;
-        var _config_0 = __getRuntimeConfig(configuration);
-        var _config_1 = resolveRegionConfig(_config_0);
-        var _config_2 = resolveEndpointsConfig(_config_1);
-        var _config_3 = resolveRetryConfig(_config_2);
-        var _config_4 = resolveHostHeaderConfig(_config_3);
-        var _config_5 = resolveAwsAuthConfig(_config_4);
-        var _config_6 = resolveUserAgentConfig(_config_5);
-        _this = _super.call(this, _config_6) || this;
-        _this.config = _config_6;
-        _this.middlewareStack.use(getRetryPlugin(_this.config));
-        _this.middlewareStack.use(getContentLengthPlugin(_this.config));
-        _this.middlewareStack.use(getHostHeaderPlugin(_this.config));
-        _this.middlewareStack.use(getLoggerPlugin(_this.config));
-        _this.middlewareStack.use(getRecursionDetectionPlugin(_this.config));
-        _this.middlewareStack.use(getAwsAuthPlugin(_this.config));
-        _this.middlewareStack.use(getUserAgentPlugin(_this.config));
-        return _this;
+export class ElastiCacheClient extends __Client {
+    constructor(configuration) {
+        const _config_0 = __getRuntimeConfig(configuration);
+        const _config_1 = resolveRegionConfig(_config_0);
+        const _config_2 = resolveEndpointsConfig(_config_1);
+        const _config_3 = resolveRetryConfig(_config_2);
+        const _config_4 = resolveHostHeaderConfig(_config_3);
+        const _config_5 = resolveAwsAuthConfig(_config_4);
+        const _config_6 = resolveUserAgentConfig(_config_5);
+        super(_config_6);
+        this.config = _config_6;
+        this.middlewareStack.use(getRetryPlugin(this.config));
+        this.middlewareStack.use(getContentLengthPlugin(this.config));
+        this.middlewareStack.use(getHostHeaderPlugin(this.config));
+        this.middlewareStack.use(getLoggerPlugin(this.config));
+        this.middlewareStack.use(getRecursionDetectionPlugin(this.config));
+        this.middlewareStack.use(getAwsAuthPlugin(this.config));
+        this.middlewareStack.use(getUserAgentPlugin(this.config));
     }
-    ElastiCacheClient.prototype.destroy = function () {
-        _super.prototype.destroy.call(this);
-    };
-    return ElastiCacheClient;
-}(__Client));
-export { ElastiCacheClient };
+    destroy() {
+        super.destroy();
+    }
+}

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

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

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

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

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

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

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

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

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