@aws-sdk/client-redshift 3.183.0 → 3.186.0

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

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

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

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

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

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

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

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

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

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