@aws-sdk/client-rds 3.183.0 → 3.185.0

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

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

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_1";
 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 = "RDSClient";
-        const commandName = "DescribeEventCategoriesCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "RDSClient";
+        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_1";
 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 = "RDSClient";
-        const commandName = "DescribeEventSubscriptionsCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "RDSClient";
+        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_1";
 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 = "RDSClient";
-        const commandName = "DescribeEventsCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "RDSClient";
+        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/DescribeExportTasksCommand.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 { DescribeExportTasksMessageFilterSensitiveLog, ExportTasksMessageFilterSensitiveLog, } from "../models/models_1";
 import { deserializeAws_queryDescribeExportTasksCommand, serializeAws_queryDescribeExportTasksCommand, } from "../protocols/Aws_query";
-export class DescribeExportTasksCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var DescribeExportTasksCommand = (function (_super) {
+    __extends(DescribeExportTasksCommand, _super);
+    function DescribeExportTasksCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    DescribeExportTasksCommand.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 = "RDSClient";
-        const commandName = "DescribeExportTasksCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "RDSClient";
+        var commandName = "DescribeExportTasksCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: DescribeExportTasksMessageFilterSensitiveLog,
             outputFilterSensitiveLog: ExportTasksMessageFilterSensitiveLog,
         };
-        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);
+    };
+    DescribeExportTasksCommand.prototype.serialize = function (input, context) {
         return serializeAws_queryDescribeExportTasksCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    DescribeExportTasksCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_queryDescribeExportTasksCommand(output, context);
-    }
-}
+    };
+    return DescribeExportTasksCommand;
+}($Command));
+export { DescribeExportTasksCommand };

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

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

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

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