@aws-sdk/client-docdb 3.183.0 → 3.185.0

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

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

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

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

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

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

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

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

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

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