@aws-sdk/client-s3 3.183.0 → 3.185.0

package/dist-es/commands/DeleteBucketEncryptionCommand.js

@@ -1,34 +1,41 @@
+import { __extends } from "tslib";
 import { getBucketEndpointPlugin } from "@aws-sdk/middleware-bucket-endpoint";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { DeleteBucketEncryptionRequestFilterSensitiveLog } from "../models/models_0";
 import { deserializeAws_restXmlDeleteBucketEncryptionCommand, serializeAws_restXmlDeleteBucketEncryptionCommand, } from "../protocols/Aws_restXml";
-export class DeleteBucketEncryptionCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var DeleteBucketEncryptionCommand = (function (_super) {
+    __extends(DeleteBucketEncryptionCommand, _super);
+    function DeleteBucketEncryptionCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    DeleteBucketEncryptionCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
         this.middlewareStack.use(getBucketEndpointPlugin(configuration));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "S3Client";
-        const commandName = "DeleteBucketEncryptionCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "S3Client";
+        var commandName = "DeleteBucketEncryptionCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: DeleteBucketEncryptionRequestFilterSensitiveLog,
-            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);
+    };
+    DeleteBucketEncryptionCommand.prototype.serialize = function (input, context) {
         return serializeAws_restXmlDeleteBucketEncryptionCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    DeleteBucketEncryptionCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restXmlDeleteBucketEncryptionCommand(output, context);
-    }
-}
+    };
+    return DeleteBucketEncryptionCommand;
+}($Command));
+export { DeleteBucketEncryptionCommand };

package/dist-es/commands/DeleteBucketIntelligentTieringConfigurationCommand.js

@@ -1,34 +1,41 @@
+import { __extends } from "tslib";
 import { getBucketEndpointPlugin } from "@aws-sdk/middleware-bucket-endpoint";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { DeleteBucketIntelligentTieringConfigurationRequestFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restXmlDeleteBucketIntelligentTieringConfigurationCommand, serializeAws_restXmlDeleteBucketIntelligentTieringConfigurationCommand, } from "../protocols/Aws_restXml";
-export class DeleteBucketIntelligentTieringConfigurationCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var DeleteBucketIntelligentTieringConfigurationCommand = (function (_super) {
+    __extends(DeleteBucketIntelligentTieringConfigurationCommand, _super);
+    function DeleteBucketIntelligentTieringConfigurationCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    DeleteBucketIntelligentTieringConfigurationCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
         this.middlewareStack.use(getBucketEndpointPlugin(configuration));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "S3Client";
-        const commandName = "DeleteBucketIntelligentTieringConfigurationCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "S3Client";
+        var commandName = "DeleteBucketIntelligentTieringConfigurationCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: DeleteBucketIntelligentTieringConfigurationRequestFilterSensitiveLog,
-            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);
+    };
+    DeleteBucketIntelligentTieringConfigurationCommand.prototype.serialize = function (input, context) {
         return serializeAws_restXmlDeleteBucketIntelligentTieringConfigurationCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    DeleteBucketIntelligentTieringConfigurationCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restXmlDeleteBucketIntelligentTieringConfigurationCommand(output, context);
-    }
-}
+    };
+    return DeleteBucketIntelligentTieringConfigurationCommand;
+}($Command));
+export { DeleteBucketIntelligentTieringConfigurationCommand };

package/dist-es/commands/DeleteBucketInventoryConfigurationCommand.js

@@ -1,34 +1,41 @@
+import { __extends } from "tslib";
 import { getBucketEndpointPlugin } from "@aws-sdk/middleware-bucket-endpoint";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { DeleteBucketInventoryConfigurationRequestFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restXmlDeleteBucketInventoryConfigurationCommand, serializeAws_restXmlDeleteBucketInventoryConfigurationCommand, } from "../protocols/Aws_restXml";
-export class DeleteBucketInventoryConfigurationCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var DeleteBucketInventoryConfigurationCommand = (function (_super) {
+    __extends(DeleteBucketInventoryConfigurationCommand, _super);
+    function DeleteBucketInventoryConfigurationCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    DeleteBucketInventoryConfigurationCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
         this.middlewareStack.use(getBucketEndpointPlugin(configuration));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "S3Client";
-        const commandName = "DeleteBucketInventoryConfigurationCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "S3Client";
+        var commandName = "DeleteBucketInventoryConfigurationCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: DeleteBucketInventoryConfigurationRequestFilterSensitiveLog,
-            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);
+    };
+    DeleteBucketInventoryConfigurationCommand.prototype.serialize = function (input, context) {
         return serializeAws_restXmlDeleteBucketInventoryConfigurationCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    DeleteBucketInventoryConfigurationCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restXmlDeleteBucketInventoryConfigurationCommand(output, context);
-    }
-}
+    };
+    return DeleteBucketInventoryConfigurationCommand;
+}($Command));
+export { DeleteBucketInventoryConfigurationCommand };

package/dist-es/commands/DeleteBucketLifecycleCommand.js

@@ -1,34 +1,41 @@
+import { __extends } from "tslib";
 import { getBucketEndpointPlugin } from "@aws-sdk/middleware-bucket-endpoint";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { DeleteBucketLifecycleRequestFilterSensitiveLog } from "../models/models_0";
 import { deserializeAws_restXmlDeleteBucketLifecycleCommand, serializeAws_restXmlDeleteBucketLifecycleCommand, } from "../protocols/Aws_restXml";
-export class DeleteBucketLifecycleCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var DeleteBucketLifecycleCommand = (function (_super) {
+    __extends(DeleteBucketLifecycleCommand, _super);
+    function DeleteBucketLifecycleCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    DeleteBucketLifecycleCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
         this.middlewareStack.use(getBucketEndpointPlugin(configuration));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "S3Client";
-        const commandName = "DeleteBucketLifecycleCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "S3Client";
+        var commandName = "DeleteBucketLifecycleCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: DeleteBucketLifecycleRequestFilterSensitiveLog,
-            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);
+    };
+    DeleteBucketLifecycleCommand.prototype.serialize = function (input, context) {
         return serializeAws_restXmlDeleteBucketLifecycleCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    DeleteBucketLifecycleCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restXmlDeleteBucketLifecycleCommand(output, context);
-    }
-}
+    };
+    return DeleteBucketLifecycleCommand;
+}($Command));
+export { DeleteBucketLifecycleCommand };

package/dist-es/commands/DeleteBucketMetricsConfigurationCommand.js

@@ -1,34 +1,41 @@
+import { __extends } from "tslib";
 import { getBucketEndpointPlugin } from "@aws-sdk/middleware-bucket-endpoint";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { DeleteBucketMetricsConfigurationRequestFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restXmlDeleteBucketMetricsConfigurationCommand, serializeAws_restXmlDeleteBucketMetricsConfigurationCommand, } from "../protocols/Aws_restXml";
-export class DeleteBucketMetricsConfigurationCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var DeleteBucketMetricsConfigurationCommand = (function (_super) {
+    __extends(DeleteBucketMetricsConfigurationCommand, _super);
+    function DeleteBucketMetricsConfigurationCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    DeleteBucketMetricsConfigurationCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
         this.middlewareStack.use(getBucketEndpointPlugin(configuration));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "S3Client";
-        const commandName = "DeleteBucketMetricsConfigurationCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "S3Client";
+        var commandName = "DeleteBucketMetricsConfigurationCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: DeleteBucketMetricsConfigurationRequestFilterSensitiveLog,
-            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);
+    };
+    DeleteBucketMetricsConfigurationCommand.prototype.serialize = function (input, context) {
         return serializeAws_restXmlDeleteBucketMetricsConfigurationCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    DeleteBucketMetricsConfigurationCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restXmlDeleteBucketMetricsConfigurationCommand(output, context);
-    }
-}
+    };
+    return DeleteBucketMetricsConfigurationCommand;
+}($Command));
+export { DeleteBucketMetricsConfigurationCommand };

package/dist-es/commands/DeleteBucketOwnershipControlsCommand.js

@@ -1,34 +1,41 @@
+import { __extends } from "tslib";
 import { getBucketEndpointPlugin } from "@aws-sdk/middleware-bucket-endpoint";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { DeleteBucketOwnershipControlsRequestFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restXmlDeleteBucketOwnershipControlsCommand, serializeAws_restXmlDeleteBucketOwnershipControlsCommand, } from "../protocols/Aws_restXml";
-export class DeleteBucketOwnershipControlsCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var DeleteBucketOwnershipControlsCommand = (function (_super) {
+    __extends(DeleteBucketOwnershipControlsCommand, _super);
+    function DeleteBucketOwnershipControlsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    DeleteBucketOwnershipControlsCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
         this.middlewareStack.use(getBucketEndpointPlugin(configuration));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "S3Client";
-        const commandName = "DeleteBucketOwnershipControlsCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "S3Client";
+        var commandName = "DeleteBucketOwnershipControlsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: DeleteBucketOwnershipControlsRequestFilterSensitiveLog,
-            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);
+    };
+    DeleteBucketOwnershipControlsCommand.prototype.serialize = function (input, context) {
         return serializeAws_restXmlDeleteBucketOwnershipControlsCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    DeleteBucketOwnershipControlsCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restXmlDeleteBucketOwnershipControlsCommand(output, context);
-    }
-}
+    };
+    return DeleteBucketOwnershipControlsCommand;
+}($Command));
+export { DeleteBucketOwnershipControlsCommand };

package/dist-es/commands/DeleteBucketPolicyCommand.js

@@ -1,34 +1,41 @@
+import { __extends } from "tslib";
 import { getBucketEndpointPlugin } from "@aws-sdk/middleware-bucket-endpoint";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { DeleteBucketPolicyRequestFilterSensitiveLog } from "../models/models_0";
 import { deserializeAws_restXmlDeleteBucketPolicyCommand, serializeAws_restXmlDeleteBucketPolicyCommand, } from "../protocols/Aws_restXml";
-export class DeleteBucketPolicyCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var DeleteBucketPolicyCommand = (function (_super) {
+    __extends(DeleteBucketPolicyCommand, _super);
+    function DeleteBucketPolicyCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    DeleteBucketPolicyCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
         this.middlewareStack.use(getBucketEndpointPlugin(configuration));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "S3Client";
-        const commandName = "DeleteBucketPolicyCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "S3Client";
+        var commandName = "DeleteBucketPolicyCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: DeleteBucketPolicyRequestFilterSensitiveLog,
-            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);
+    };
+    DeleteBucketPolicyCommand.prototype.serialize = function (input, context) {
         return serializeAws_restXmlDeleteBucketPolicyCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    DeleteBucketPolicyCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restXmlDeleteBucketPolicyCommand(output, context);
-    }
-}
+    };
+    return DeleteBucketPolicyCommand;
+}($Command));
+export { DeleteBucketPolicyCommand };

package/dist-es/commands/DeleteBucketReplicationCommand.js

@@ -1,34 +1,41 @@
+import { __extends } from "tslib";
 import { getBucketEndpointPlugin } from "@aws-sdk/middleware-bucket-endpoint";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { DeleteBucketReplicationRequestFilterSensitiveLog } from "../models/models_0";
 import { deserializeAws_restXmlDeleteBucketReplicationCommand, serializeAws_restXmlDeleteBucketReplicationCommand, } from "../protocols/Aws_restXml";
-export class DeleteBucketReplicationCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var DeleteBucketReplicationCommand = (function (_super) {
+    __extends(DeleteBucketReplicationCommand, _super);
+    function DeleteBucketReplicationCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    DeleteBucketReplicationCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
         this.middlewareStack.use(getBucketEndpointPlugin(configuration));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "S3Client";
-        const commandName = "DeleteBucketReplicationCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "S3Client";
+        var commandName = "DeleteBucketReplicationCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: DeleteBucketReplicationRequestFilterSensitiveLog,
-            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);
+    };
+    DeleteBucketReplicationCommand.prototype.serialize = function (input, context) {
         return serializeAws_restXmlDeleteBucketReplicationCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    DeleteBucketReplicationCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restXmlDeleteBucketReplicationCommand(output, context);
-    }
-}
+    };
+    return DeleteBucketReplicationCommand;
+}($Command));
+export { DeleteBucketReplicationCommand };

package/dist-es/commands/DeleteBucketTaggingCommand.js

@@ -1,34 +1,41 @@
+import { __extends } from "tslib";
 import { getBucketEndpointPlugin } from "@aws-sdk/middleware-bucket-endpoint";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { DeleteBucketTaggingRequestFilterSensitiveLog } from "../models/models_0";
 import { deserializeAws_restXmlDeleteBucketTaggingCommand, serializeAws_restXmlDeleteBucketTaggingCommand, } from "../protocols/Aws_restXml";
-export class DeleteBucketTaggingCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var DeleteBucketTaggingCommand = (function (_super) {
+    __extends(DeleteBucketTaggingCommand, _super);
+    function DeleteBucketTaggingCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    DeleteBucketTaggingCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
         this.middlewareStack.use(getBucketEndpointPlugin(configuration));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "S3Client";
-        const commandName = "DeleteBucketTaggingCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "S3Client";
+        var commandName = "DeleteBucketTaggingCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: DeleteBucketTaggingRequestFilterSensitiveLog,
-            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);
+    };
+    DeleteBucketTaggingCommand.prototype.serialize = function (input, context) {
         return serializeAws_restXmlDeleteBucketTaggingCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    DeleteBucketTaggingCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restXmlDeleteBucketTaggingCommand(output, context);
-    }
-}
+    };
+    return DeleteBucketTaggingCommand;
+}($Command));
+export { DeleteBucketTaggingCommand };