@aws-sdk/client-redshift 3.183.0 → 3.185.0

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

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

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

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

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

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

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

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

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

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