@aws-sdk/client-redshift 3.183.0 → 3.185.0

package/dist-es/commands/ResetClusterParameterGroupCommand.js

@@ -1,33 +1,40 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { ClusterParameterGroupNameMessageFilterSensitiveLog, } from "../models/models_0";
 import { ResetClusterParameterGroupMessageFilterSensitiveLog, } from "../models/models_1";
 import { deserializeAws_queryResetClusterParameterGroupCommand, serializeAws_queryResetClusterParameterGroupCommand, } from "../protocols/Aws_query";
-export class ResetClusterParameterGroupCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var ResetClusterParameterGroupCommand = (function (_super) {
+    __extends(ResetClusterParameterGroupCommand, _super);
+    function ResetClusterParameterGroupCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    ResetClusterParameterGroupCommand.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 = "RedshiftClient";
-        const commandName = "ResetClusterParameterGroupCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "RedshiftClient";
+        var commandName = "ResetClusterParameterGroupCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: ResetClusterParameterGroupMessageFilterSensitiveLog,
             outputFilterSensitiveLog: ClusterParameterGroupNameMessageFilterSensitiveLog,
         };
-        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);
+    };
+    ResetClusterParameterGroupCommand.prototype.serialize = function (input, context) {
         return serializeAws_queryResetClusterParameterGroupCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    ResetClusterParameterGroupCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_queryResetClusterParameterGroupCommand(output, context);
-    }
-}
+    };
+    return ResetClusterParameterGroupCommand;
+}($Command));
+export { ResetClusterParameterGroupCommand };

package/dist-es/commands/ResizeClusterCommand.js

@@ -1,33 +1,40 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { ResizeClusterMessageFilterSensitiveLog } from "../models/models_0";
 import { ResizeClusterResultFilterSensitiveLog } from "../models/models_1";
 import { deserializeAws_queryResizeClusterCommand, serializeAws_queryResizeClusterCommand, } from "../protocols/Aws_query";
-export class ResizeClusterCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var ResizeClusterCommand = (function (_super) {
+    __extends(ResizeClusterCommand, _super);
+    function ResizeClusterCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    ResizeClusterCommand.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 = "RedshiftClient";
-        const commandName = "ResizeClusterCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "RedshiftClient";
+        var commandName = "ResizeClusterCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: ResizeClusterMessageFilterSensitiveLog,
             outputFilterSensitiveLog: ResizeClusterResultFilterSensitiveLog,
         };
-        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);
+    };
+    ResizeClusterCommand.prototype.serialize = function (input, context) {
         return serializeAws_queryResizeClusterCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    ResizeClusterCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_queryResizeClusterCommand(output, context);
-    }
-}
+    };
+    return ResizeClusterCommand;
+}($Command));
+export { ResizeClusterCommand };

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

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

package/dist-es/commands/ResumeClusterCommand.js

@@ -1,33 +1,40 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { ResumeClusterMessageFilterSensitiveLog } from "../models/models_0";
 import { ResumeClusterResultFilterSensitiveLog } from "../models/models_1";
 import { deserializeAws_queryResumeClusterCommand, serializeAws_queryResumeClusterCommand, } from "../protocols/Aws_query";
-export class ResumeClusterCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var ResumeClusterCommand = (function (_super) {
+    __extends(ResumeClusterCommand, _super);
+    function ResumeClusterCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    ResumeClusterCommand.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 = "RedshiftClient";
-        const commandName = "ResumeClusterCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "RedshiftClient";
+        var commandName = "ResumeClusterCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: ResumeClusterMessageFilterSensitiveLog,
             outputFilterSensitiveLog: ResumeClusterResultFilterSensitiveLog,
         };
-        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);
+    };
+    ResumeClusterCommand.prototype.serialize = function (input, context) {
         return serializeAws_queryResumeClusterCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    ResumeClusterCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_queryResumeClusterCommand(output, context);
-    }
-}
+    };
+    return ResumeClusterCommand;
+}($Command));
+export { ResumeClusterCommand };

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

package/dist-es/commands/RevokeEndpointAccessCommand.js

@@ -1,33 +1,40 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { EndpointAuthorizationFilterSensitiveLog } from "../models/models_0";
 import { RevokeEndpointAccessMessageFilterSensitiveLog } from "../models/models_1";
 import { deserializeAws_queryRevokeEndpointAccessCommand, serializeAws_queryRevokeEndpointAccessCommand, } from "../protocols/Aws_query";
-export class RevokeEndpointAccessCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var RevokeEndpointAccessCommand = (function (_super) {
+    __extends(RevokeEndpointAccessCommand, _super);
+    function RevokeEndpointAccessCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    RevokeEndpointAccessCommand.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 = "RedshiftClient";
-        const commandName = "RevokeEndpointAccessCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "RedshiftClient";
+        var commandName = "RevokeEndpointAccessCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: RevokeEndpointAccessMessageFilterSensitiveLog,
             outputFilterSensitiveLog: EndpointAuthorizationFilterSensitiveLog,
         };
-        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);
+    };
+    RevokeEndpointAccessCommand.prototype.serialize = function (input, context) {
         return serializeAws_queryRevokeEndpointAccessCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    RevokeEndpointAccessCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_queryRevokeEndpointAccessCommand(output, context);
-    }
-}
+    };
+    return RevokeEndpointAccessCommand;
+}($Command));
+export { RevokeEndpointAccessCommand };

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

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

package/dist-es/commands/UpdatePartnerStatusCommand.js

@@ -1,33 +1,40 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { PartnerIntegrationOutputMessageFilterSensitiveLog } from "../models/models_0";
 import { UpdatePartnerStatusInputMessageFilterSensitiveLog } from "../models/models_1";
 import { deserializeAws_queryUpdatePartnerStatusCommand, serializeAws_queryUpdatePartnerStatusCommand, } from "../protocols/Aws_query";
-export class UpdatePartnerStatusCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var UpdatePartnerStatusCommand = (function (_super) {
+    __extends(UpdatePartnerStatusCommand, _super);
+    function UpdatePartnerStatusCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    UpdatePartnerStatusCommand.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 = "RedshiftClient";
-        const commandName = "UpdatePartnerStatusCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "RedshiftClient";
+        var commandName = "UpdatePartnerStatusCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: UpdatePartnerStatusInputMessageFilterSensitiveLog,
             outputFilterSensitiveLog: PartnerIntegrationOutputMessageFilterSensitiveLog,
         };
-        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);
+    };
+    UpdatePartnerStatusCommand.prototype.serialize = function (input, context) {
         return serializeAws_queryUpdatePartnerStatusCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    UpdatePartnerStatusCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_queryUpdatePartnerStatusCommand(output, context);
-    }
-}
+    };
+    return UpdatePartnerStatusCommand;
+}($Command));
+export { UpdatePartnerStatusCommand };