@aws-sdk/client-redshift 3.183.0 → 3.185.0

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

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

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

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

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

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

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

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

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

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