@aws-sdk/client-s3 3.183.0 → 3.185.0

package/dist-es/commands/PutBucketWebsiteCommand.js

@@ -1,15 +1,18 @@
+import { __extends } from "tslib";
 import { getBucketEndpointPlugin } from "@aws-sdk/middleware-bucket-endpoint";
 import { getFlexibleChecksumsPlugin } from "@aws-sdk/middleware-flexible-checksums";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { PutBucketWebsiteRequestFilterSensitiveLog } from "../models/models_0";
 import { deserializeAws_restXmlPutBucketWebsiteCommand, serializeAws_restXmlPutBucketWebsiteCommand, } from "../protocols/Aws_restXml";
-export class PutBucketWebsiteCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var PutBucketWebsiteCommand = (function (_super) {
+    __extends(PutBucketWebsiteCommand, _super);
+    function PutBucketWebsiteCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    PutBucketWebsiteCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
         this.middlewareStack.use(getBucketEndpointPlugin(configuration));
         this.middlewareStack.use(getFlexibleChecksumsPlugin(configuration, {
@@ -17,24 +20,28 @@ export class PutBucketWebsiteCommand extends $Command {
             requestAlgorithmMember: "ChecksumAlgorithm",
             requestChecksumRequired: true,
         }));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "S3Client";
-        const commandName = "PutBucketWebsiteCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "S3Client";
+        var commandName = "PutBucketWebsiteCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: PutBucketWebsiteRequestFilterSensitiveLog,
-            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);
+    };
+    PutBucketWebsiteCommand.prototype.serialize = function (input, context) {
         return serializeAws_restXmlPutBucketWebsiteCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    PutBucketWebsiteCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restXmlPutBucketWebsiteCommand(output, context);
-    }
-}
+    };
+    return PutBucketWebsiteCommand;
+}($Command));
+export { PutBucketWebsiteCommand };

package/dist-es/commands/PutObjectAclCommand.js

@@ -1,15 +1,18 @@
+import { __extends } from "tslib";
 import { getBucketEndpointPlugin } from "@aws-sdk/middleware-bucket-endpoint";
 import { getFlexibleChecksumsPlugin } from "@aws-sdk/middleware-flexible-checksums";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { PutObjectAclOutputFilterSensitiveLog, PutObjectAclRequestFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restXmlPutObjectAclCommand, serializeAws_restXmlPutObjectAclCommand, } from "../protocols/Aws_restXml";
-export class PutObjectAclCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var PutObjectAclCommand = (function (_super) {
+    __extends(PutObjectAclCommand, _super);
+    function PutObjectAclCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    PutObjectAclCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
         this.middlewareStack.use(getBucketEndpointPlugin(configuration));
         this.middlewareStack.use(getFlexibleChecksumsPlugin(configuration, {
@@ -17,24 +20,28 @@ export class PutObjectAclCommand extends $Command {
             requestAlgorithmMember: "ChecksumAlgorithm",
             requestChecksumRequired: true,
         }));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "S3Client";
-        const commandName = "PutObjectAclCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "S3Client";
+        var commandName = "PutObjectAclCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: PutObjectAclRequestFilterSensitiveLog,
             outputFilterSensitiveLog: PutObjectAclOutputFilterSensitiveLog,
         };
-        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);
+    };
+    PutObjectAclCommand.prototype.serialize = function (input, context) {
         return serializeAws_restXmlPutObjectAclCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    PutObjectAclCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restXmlPutObjectAclCommand(output, context);
-    }
-}
+    };
+    return PutObjectAclCommand;
+}($Command));
+export { PutObjectAclCommand };

package/dist-es/commands/PutObjectCommand.js

@@ -1,3 +1,4 @@
+import { __extends } from "tslib";
 import { getBucketEndpointPlugin } from "@aws-sdk/middleware-bucket-endpoint";
 import { getFlexibleChecksumsPlugin } from "@aws-sdk/middleware-flexible-checksums";
 import { getCheckContentLengthHeaderPlugin } from "@aws-sdk/middleware-sdk-s3";
@@ -6,12 +7,14 @@ import { getSsecPlugin } from "@aws-sdk/middleware-ssec";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { PutObjectOutputFilterSensitiveLog, PutObjectRequestFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restXmlPutObjectCommand, serializeAws_restXmlPutObjectCommand } from "../protocols/Aws_restXml";
-export class PutObjectCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var PutObjectCommand = (function (_super) {
+    __extends(PutObjectCommand, _super);
+    function PutObjectCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    PutObjectCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
         this.middlewareStack.use(getCheckContentLengthHeaderPlugin(configuration));
         this.middlewareStack.use(getSsecPlugin(configuration));
@@ -21,24 +24,28 @@ export class PutObjectCommand extends $Command {
             requestAlgorithmMember: "ChecksumAlgorithm",
             requestChecksumRequired: false,
         }));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "S3Client";
-        const commandName = "PutObjectCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "S3Client";
+        var commandName = "PutObjectCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: PutObjectRequestFilterSensitiveLog,
             outputFilterSensitiveLog: PutObjectOutputFilterSensitiveLog,
         };
-        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);
+    };
+    PutObjectCommand.prototype.serialize = function (input, context) {
         return serializeAws_restXmlPutObjectCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    PutObjectCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restXmlPutObjectCommand(output, context);
-    }
-}
+    };
+    return PutObjectCommand;
+}($Command));
+export { PutObjectCommand };

package/dist-es/commands/PutObjectLegalHoldCommand.js

@@ -1,15 +1,18 @@
+import { __extends } from "tslib";
 import { getBucketEndpointPlugin } from "@aws-sdk/middleware-bucket-endpoint";
 import { getFlexibleChecksumsPlugin } from "@aws-sdk/middleware-flexible-checksums";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { PutObjectLegalHoldOutputFilterSensitiveLog, PutObjectLegalHoldRequestFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restXmlPutObjectLegalHoldCommand, serializeAws_restXmlPutObjectLegalHoldCommand, } from "../protocols/Aws_restXml";
-export class PutObjectLegalHoldCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var PutObjectLegalHoldCommand = (function (_super) {
+    __extends(PutObjectLegalHoldCommand, _super);
+    function PutObjectLegalHoldCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    PutObjectLegalHoldCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
         this.middlewareStack.use(getBucketEndpointPlugin(configuration));
         this.middlewareStack.use(getFlexibleChecksumsPlugin(configuration, {
@@ -17,24 +20,28 @@ export class PutObjectLegalHoldCommand extends $Command {
             requestAlgorithmMember: "ChecksumAlgorithm",
             requestChecksumRequired: true,
         }));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "S3Client";
-        const commandName = "PutObjectLegalHoldCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "S3Client";
+        var commandName = "PutObjectLegalHoldCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: PutObjectLegalHoldRequestFilterSensitiveLog,
             outputFilterSensitiveLog: PutObjectLegalHoldOutputFilterSensitiveLog,
         };
-        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);
+    };
+    PutObjectLegalHoldCommand.prototype.serialize = function (input, context) {
         return serializeAws_restXmlPutObjectLegalHoldCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    PutObjectLegalHoldCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restXmlPutObjectLegalHoldCommand(output, context);
-    }
-}
+    };
+    return PutObjectLegalHoldCommand;
+}($Command));
+export { PutObjectLegalHoldCommand };

package/dist-es/commands/PutObjectLockConfigurationCommand.js

@@ -1,15 +1,18 @@
+import { __extends } from "tslib";
 import { getBucketEndpointPlugin } from "@aws-sdk/middleware-bucket-endpoint";
 import { getFlexibleChecksumsPlugin } from "@aws-sdk/middleware-flexible-checksums";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { PutObjectLockConfigurationOutputFilterSensitiveLog, PutObjectLockConfigurationRequestFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restXmlPutObjectLockConfigurationCommand, serializeAws_restXmlPutObjectLockConfigurationCommand, } from "../protocols/Aws_restXml";
-export class PutObjectLockConfigurationCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var PutObjectLockConfigurationCommand = (function (_super) {
+    __extends(PutObjectLockConfigurationCommand, _super);
+    function PutObjectLockConfigurationCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    PutObjectLockConfigurationCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
         this.middlewareStack.use(getBucketEndpointPlugin(configuration));
         this.middlewareStack.use(getFlexibleChecksumsPlugin(configuration, {
@@ -17,24 +20,28 @@ export class PutObjectLockConfigurationCommand extends $Command {
             requestAlgorithmMember: "ChecksumAlgorithm",
             requestChecksumRequired: true,
         }));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "S3Client";
-        const commandName = "PutObjectLockConfigurationCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "S3Client";
+        var commandName = "PutObjectLockConfigurationCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: PutObjectLockConfigurationRequestFilterSensitiveLog,
             outputFilterSensitiveLog: PutObjectLockConfigurationOutputFilterSensitiveLog,
         };
-        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);
+    };
+    PutObjectLockConfigurationCommand.prototype.serialize = function (input, context) {
         return serializeAws_restXmlPutObjectLockConfigurationCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    PutObjectLockConfigurationCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restXmlPutObjectLockConfigurationCommand(output, context);
-    }
-}
+    };
+    return PutObjectLockConfigurationCommand;
+}($Command));
+export { PutObjectLockConfigurationCommand };

package/dist-es/commands/PutObjectRetentionCommand.js

@@ -1,15 +1,18 @@
+import { __extends } from "tslib";
 import { getBucketEndpointPlugin } from "@aws-sdk/middleware-bucket-endpoint";
 import { getFlexibleChecksumsPlugin } from "@aws-sdk/middleware-flexible-checksums";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { PutObjectRetentionOutputFilterSensitiveLog, PutObjectRetentionRequestFilterSensitiveLog, } from "../models/models_1";
 import { deserializeAws_restXmlPutObjectRetentionCommand, serializeAws_restXmlPutObjectRetentionCommand, } from "../protocols/Aws_restXml";
-export class PutObjectRetentionCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var PutObjectRetentionCommand = (function (_super) {
+    __extends(PutObjectRetentionCommand, _super);
+    function PutObjectRetentionCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    PutObjectRetentionCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
         this.middlewareStack.use(getBucketEndpointPlugin(configuration));
         this.middlewareStack.use(getFlexibleChecksumsPlugin(configuration, {
@@ -17,24 +20,28 @@ export class PutObjectRetentionCommand extends $Command {
             requestAlgorithmMember: "ChecksumAlgorithm",
             requestChecksumRequired: true,
         }));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "S3Client";
-        const commandName = "PutObjectRetentionCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "S3Client";
+        var commandName = "PutObjectRetentionCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: PutObjectRetentionRequestFilterSensitiveLog,
             outputFilterSensitiveLog: PutObjectRetentionOutputFilterSensitiveLog,
         };
-        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);
+    };
+    PutObjectRetentionCommand.prototype.serialize = function (input, context) {
         return serializeAws_restXmlPutObjectRetentionCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    PutObjectRetentionCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restXmlPutObjectRetentionCommand(output, context);
-    }
-}
+    };
+    return PutObjectRetentionCommand;
+}($Command));
+export { PutObjectRetentionCommand };

package/dist-es/commands/PutObjectTaggingCommand.js

@@ -1,15 +1,18 @@
+import { __extends } from "tslib";
 import { getBucketEndpointPlugin } from "@aws-sdk/middleware-bucket-endpoint";
 import { getFlexibleChecksumsPlugin } from "@aws-sdk/middleware-flexible-checksums";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { PutObjectTaggingOutputFilterSensitiveLog, PutObjectTaggingRequestFilterSensitiveLog, } from "../models/models_1";
 import { deserializeAws_restXmlPutObjectTaggingCommand, serializeAws_restXmlPutObjectTaggingCommand, } from "../protocols/Aws_restXml";
-export class PutObjectTaggingCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var PutObjectTaggingCommand = (function (_super) {
+    __extends(PutObjectTaggingCommand, _super);
+    function PutObjectTaggingCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    PutObjectTaggingCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
         this.middlewareStack.use(getBucketEndpointPlugin(configuration));
         this.middlewareStack.use(getFlexibleChecksumsPlugin(configuration, {
@@ -17,24 +20,28 @@ export class PutObjectTaggingCommand extends $Command {
             requestAlgorithmMember: "ChecksumAlgorithm",
             requestChecksumRequired: true,
         }));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "S3Client";
-        const commandName = "PutObjectTaggingCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "S3Client";
+        var commandName = "PutObjectTaggingCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: PutObjectTaggingRequestFilterSensitiveLog,
             outputFilterSensitiveLog: PutObjectTaggingOutputFilterSensitiveLog,
         };
-        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);
+    };
+    PutObjectTaggingCommand.prototype.serialize = function (input, context) {
         return serializeAws_restXmlPutObjectTaggingCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    PutObjectTaggingCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restXmlPutObjectTaggingCommand(output, context);
-    }
-}
+    };
+    return PutObjectTaggingCommand;
+}($Command));
+export { PutObjectTaggingCommand };

package/dist-es/commands/PutPublicAccessBlockCommand.js

@@ -1,15 +1,18 @@
+import { __extends } from "tslib";
 import { getBucketEndpointPlugin } from "@aws-sdk/middleware-bucket-endpoint";
 import { getFlexibleChecksumsPlugin } from "@aws-sdk/middleware-flexible-checksums";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { PutPublicAccessBlockRequestFilterSensitiveLog } from "../models/models_1";
 import { deserializeAws_restXmlPutPublicAccessBlockCommand, serializeAws_restXmlPutPublicAccessBlockCommand, } from "../protocols/Aws_restXml";
-export class PutPublicAccessBlockCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var PutPublicAccessBlockCommand = (function (_super) {
+    __extends(PutPublicAccessBlockCommand, _super);
+    function PutPublicAccessBlockCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    PutPublicAccessBlockCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
         this.middlewareStack.use(getBucketEndpointPlugin(configuration));
         this.middlewareStack.use(getFlexibleChecksumsPlugin(configuration, {
@@ -17,24 +20,28 @@ export class PutPublicAccessBlockCommand extends $Command {
             requestAlgorithmMember: "ChecksumAlgorithm",
             requestChecksumRequired: true,
         }));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "S3Client";
-        const commandName = "PutPublicAccessBlockCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "S3Client";
+        var commandName = "PutPublicAccessBlockCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: PutPublicAccessBlockRequestFilterSensitiveLog,
-            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);
+    };
+    PutPublicAccessBlockCommand.prototype.serialize = function (input, context) {
         return serializeAws_restXmlPutPublicAccessBlockCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    PutPublicAccessBlockCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restXmlPutPublicAccessBlockCommand(output, context);
-    }
-}
+    };
+    return PutPublicAccessBlockCommand;
+}($Command));
+export { PutPublicAccessBlockCommand };

package/dist-es/commands/RestoreObjectCommand.js

@@ -1,15 +1,18 @@
+import { __extends } from "tslib";
 import { getBucketEndpointPlugin } from "@aws-sdk/middleware-bucket-endpoint";
 import { getFlexibleChecksumsPlugin } from "@aws-sdk/middleware-flexible-checksums";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { RestoreObjectOutputFilterSensitiveLog, RestoreObjectRequestFilterSensitiveLog, } from "../models/models_1";
 import { deserializeAws_restXmlRestoreObjectCommand, serializeAws_restXmlRestoreObjectCommand, } from "../protocols/Aws_restXml";
-export class RestoreObjectCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var RestoreObjectCommand = (function (_super) {
+    __extends(RestoreObjectCommand, _super);
+    function RestoreObjectCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    RestoreObjectCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
         this.middlewareStack.use(getBucketEndpointPlugin(configuration));
         this.middlewareStack.use(getFlexibleChecksumsPlugin(configuration, {
@@ -17,24 +20,28 @@ export class RestoreObjectCommand extends $Command {
             requestAlgorithmMember: "ChecksumAlgorithm",
             requestChecksumRequired: false,
         }));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "S3Client";
-        const commandName = "RestoreObjectCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "S3Client";
+        var commandName = "RestoreObjectCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: RestoreObjectRequestFilterSensitiveLog,
             outputFilterSensitiveLog: RestoreObjectOutputFilterSensitiveLog,
         };
-        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);
+    };
+    RestoreObjectCommand.prototype.serialize = function (input, context) {
         return serializeAws_restXmlRestoreObjectCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    RestoreObjectCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restXmlRestoreObjectCommand(output, context);
-    }
-}
+    };
+    return RestoreObjectCommand;
+}($Command));
+export { RestoreObjectCommand };