@aws-sdk/client-s3 3.181.0 → 3.183.0

package/dist-es/S3.js

@@ -1,4 +1,3 @@
-import { __extends } from "tslib";
 import { AbortMultipartUploadCommand, } from "./commands/AbortMultipartUploadCommand";
 import { CompleteMultipartUploadCommand, } from "./commands/CompleteMultipartUploadCommand";
 import { CopyObjectCommand } from "./commands/CopyObjectCommand";
@@ -93,1313 +92,1307 @@ import { UploadPartCommand } from "./commands/UploadPartCommand";
 import { UploadPartCopyCommand, } from "./commands/UploadPartCopyCommand";
 import { WriteGetObjectResponseCommand, } from "./commands/WriteGetObjectResponseCommand";
 import { S3Client } from "./S3Client";
-var S3 = (function (_super) {
-    __extends(S3, _super);
-    function S3() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    S3.prototype.abortMultipartUpload = function (args, optionsOrCb, cb) {
-        var command = new AbortMultipartUploadCommand(args);
+export class S3 extends S3Client {
+    abortMultipartUpload(args, optionsOrCb, cb) {
+        const command = new AbortMultipartUploadCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    S3.prototype.completeMultipartUpload = function (args, optionsOrCb, cb) {
-        var command = new CompleteMultipartUploadCommand(args);
+    }
+    completeMultipartUpload(args, optionsOrCb, cb) {
+        const command = new CompleteMultipartUploadCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    S3.prototype.copyObject = function (args, optionsOrCb, cb) {
-        var command = new CopyObjectCommand(args);
+    }
+    copyObject(args, optionsOrCb, cb) {
+        const command = new CopyObjectCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    S3.prototype.createBucket = function (args, optionsOrCb, cb) {
-        var command = new CreateBucketCommand(args);
+    }
+    createBucket(args, optionsOrCb, cb) {
+        const command = new CreateBucketCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    S3.prototype.createMultipartUpload = function (args, optionsOrCb, cb) {
-        var command = new CreateMultipartUploadCommand(args);
+    }
+    createMultipartUpload(args, optionsOrCb, cb) {
+        const command = new CreateMultipartUploadCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    S3.prototype.deleteBucket = function (args, optionsOrCb, cb) {
-        var command = new DeleteBucketCommand(args);
+    }
+    deleteBucket(args, optionsOrCb, cb) {
+        const command = new DeleteBucketCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    S3.prototype.deleteBucketAnalyticsConfiguration = function (args, optionsOrCb, cb) {
-        var command = new DeleteBucketAnalyticsConfigurationCommand(args);
+    }
+    deleteBucketAnalyticsConfiguration(args, optionsOrCb, cb) {
+        const command = new DeleteBucketAnalyticsConfigurationCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    S3.prototype.deleteBucketCors = function (args, optionsOrCb, cb) {
-        var command = new DeleteBucketCorsCommand(args);
+    }
+    deleteBucketCors(args, optionsOrCb, cb) {
+        const command = new DeleteBucketCorsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    S3.prototype.deleteBucketEncryption = function (args, optionsOrCb, cb) {
-        var command = new DeleteBucketEncryptionCommand(args);
+    }
+    deleteBucketEncryption(args, optionsOrCb, cb) {
+        const command = new DeleteBucketEncryptionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    S3.prototype.deleteBucketIntelligentTieringConfiguration = function (args, optionsOrCb, cb) {
-        var command = new DeleteBucketIntelligentTieringConfigurationCommand(args);
+    }
+    deleteBucketIntelligentTieringConfiguration(args, optionsOrCb, cb) {
+        const command = new DeleteBucketIntelligentTieringConfigurationCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    S3.prototype.deleteBucketInventoryConfiguration = function (args, optionsOrCb, cb) {
-        var command = new DeleteBucketInventoryConfigurationCommand(args);
+    }
+    deleteBucketInventoryConfiguration(args, optionsOrCb, cb) {
+        const command = new DeleteBucketInventoryConfigurationCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    S3.prototype.deleteBucketLifecycle = function (args, optionsOrCb, cb) {
-        var command = new DeleteBucketLifecycleCommand(args);
+    }
+    deleteBucketLifecycle(args, optionsOrCb, cb) {
+        const command = new DeleteBucketLifecycleCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    S3.prototype.deleteBucketMetricsConfiguration = function (args, optionsOrCb, cb) {
-        var command = new DeleteBucketMetricsConfigurationCommand(args);
+    }
+    deleteBucketMetricsConfiguration(args, optionsOrCb, cb) {
+        const command = new DeleteBucketMetricsConfigurationCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    S3.prototype.deleteBucketOwnershipControls = function (args, optionsOrCb, cb) {
-        var command = new DeleteBucketOwnershipControlsCommand(args);
+    }
+    deleteBucketOwnershipControls(args, optionsOrCb, cb) {
+        const command = new DeleteBucketOwnershipControlsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    S3.prototype.deleteBucketPolicy = function (args, optionsOrCb, cb) {
-        var command = new DeleteBucketPolicyCommand(args);
+    }
+    deleteBucketPolicy(args, optionsOrCb, cb) {
+        const command = new DeleteBucketPolicyCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    S3.prototype.deleteBucketReplication = function (args, optionsOrCb, cb) {
-        var command = new DeleteBucketReplicationCommand(args);
+    }
+    deleteBucketReplication(args, optionsOrCb, cb) {
+        const command = new DeleteBucketReplicationCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    S3.prototype.deleteBucketTagging = function (args, optionsOrCb, cb) {
-        var command = new DeleteBucketTaggingCommand(args);
+    }
+    deleteBucketTagging(args, optionsOrCb, cb) {
+        const command = new DeleteBucketTaggingCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    S3.prototype.deleteBucketWebsite = function (args, optionsOrCb, cb) {
-        var command = new DeleteBucketWebsiteCommand(args);
+    }
+    deleteBucketWebsite(args, optionsOrCb, cb) {
+        const command = new DeleteBucketWebsiteCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    S3.prototype.deleteObject = function (args, optionsOrCb, cb) {
-        var command = new DeleteObjectCommand(args);
+    }
+    deleteObject(args, optionsOrCb, cb) {
+        const command = new DeleteObjectCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    S3.prototype.deleteObjects = function (args, optionsOrCb, cb) {
-        var command = new DeleteObjectsCommand(args);
+    }
+    deleteObjects(args, optionsOrCb, cb) {
+        const command = new DeleteObjectsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    S3.prototype.deleteObjectTagging = function (args, optionsOrCb, cb) {
-        var command = new DeleteObjectTaggingCommand(args);
+    }
+    deleteObjectTagging(args, optionsOrCb, cb) {
+        const command = new DeleteObjectTaggingCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    S3.prototype.deletePublicAccessBlock = function (args, optionsOrCb, cb) {
-        var command = new DeletePublicAccessBlockCommand(args);
+    }
+    deletePublicAccessBlock(args, optionsOrCb, cb) {
+        const command = new DeletePublicAccessBlockCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    S3.prototype.getBucketAccelerateConfiguration = function (args, optionsOrCb, cb) {
-        var command = new GetBucketAccelerateConfigurationCommand(args);
+    }
+    getBucketAccelerateConfiguration(args, optionsOrCb, cb) {
+        const command = new GetBucketAccelerateConfigurationCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    S3.prototype.getBucketAcl = function (args, optionsOrCb, cb) {
-        var command = new GetBucketAclCommand(args);
+    }
+    getBucketAcl(args, optionsOrCb, cb) {
+        const command = new GetBucketAclCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    S3.prototype.getBucketAnalyticsConfiguration = function (args, optionsOrCb, cb) {
-        var command = new GetBucketAnalyticsConfigurationCommand(args);
+    }
+    getBucketAnalyticsConfiguration(args, optionsOrCb, cb) {
+        const command = new GetBucketAnalyticsConfigurationCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    S3.prototype.getBucketCors = function (args, optionsOrCb, cb) {
-        var command = new GetBucketCorsCommand(args);
+    }
+    getBucketCors(args, optionsOrCb, cb) {
+        const command = new GetBucketCorsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    S3.prototype.getBucketEncryption = function (args, optionsOrCb, cb) {
-        var command = new GetBucketEncryptionCommand(args);
+    }
+    getBucketEncryption(args, optionsOrCb, cb) {
+        const command = new GetBucketEncryptionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    S3.prototype.getBucketIntelligentTieringConfiguration = function (args, optionsOrCb, cb) {
-        var command = new GetBucketIntelligentTieringConfigurationCommand(args);
+    }
+    getBucketIntelligentTieringConfiguration(args, optionsOrCb, cb) {
+        const command = new GetBucketIntelligentTieringConfigurationCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    S3.prototype.getBucketInventoryConfiguration = function (args, optionsOrCb, cb) {
-        var command = new GetBucketInventoryConfigurationCommand(args);
+    }
+    getBucketInventoryConfiguration(args, optionsOrCb, cb) {
+        const command = new GetBucketInventoryConfigurationCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    S3.prototype.getBucketLifecycleConfiguration = function (args, optionsOrCb, cb) {
-        var command = new GetBucketLifecycleConfigurationCommand(args);
+    }
+    getBucketLifecycleConfiguration(args, optionsOrCb, cb) {
+        const command = new GetBucketLifecycleConfigurationCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    S3.prototype.getBucketLocation = function (args, optionsOrCb, cb) {
-        var command = new GetBucketLocationCommand(args);
+    }
+    getBucketLocation(args, optionsOrCb, cb) {
+        const command = new GetBucketLocationCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    S3.prototype.getBucketLogging = function (args, optionsOrCb, cb) {
-        var command = new GetBucketLoggingCommand(args);
+    }
+    getBucketLogging(args, optionsOrCb, cb) {
+        const command = new GetBucketLoggingCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    S3.prototype.getBucketMetricsConfiguration = function (args, optionsOrCb, cb) {
-        var command = new GetBucketMetricsConfigurationCommand(args);
+    }
+    getBucketMetricsConfiguration(args, optionsOrCb, cb) {
+        const command = new GetBucketMetricsConfigurationCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    S3.prototype.getBucketNotificationConfiguration = function (args, optionsOrCb, cb) {
-        var command = new GetBucketNotificationConfigurationCommand(args);
+    }
+    getBucketNotificationConfiguration(args, optionsOrCb, cb) {
+        const command = new GetBucketNotificationConfigurationCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    S3.prototype.getBucketOwnershipControls = function (args, optionsOrCb, cb) {
-        var command = new GetBucketOwnershipControlsCommand(args);
+    }
+    getBucketOwnershipControls(args, optionsOrCb, cb) {
+        const command = new GetBucketOwnershipControlsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    S3.prototype.getBucketPolicy = function (args, optionsOrCb, cb) {
-        var command = new GetBucketPolicyCommand(args);
+    }
+    getBucketPolicy(args, optionsOrCb, cb) {
+        const command = new GetBucketPolicyCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    S3.prototype.getBucketPolicyStatus = function (args, optionsOrCb, cb) {
-        var command = new GetBucketPolicyStatusCommand(args);
+    }
+    getBucketPolicyStatus(args, optionsOrCb, cb) {
+        const command = new GetBucketPolicyStatusCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    S3.prototype.getBucketReplication = function (args, optionsOrCb, cb) {
-        var command = new GetBucketReplicationCommand(args);
+    }
+    getBucketReplication(args, optionsOrCb, cb) {
+        const command = new GetBucketReplicationCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    S3.prototype.getBucketRequestPayment = function (args, optionsOrCb, cb) {
-        var command = new GetBucketRequestPaymentCommand(args);
+    }
+    getBucketRequestPayment(args, optionsOrCb, cb) {
+        const command = new GetBucketRequestPaymentCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    S3.prototype.getBucketTagging = function (args, optionsOrCb, cb) {
-        var command = new GetBucketTaggingCommand(args);
+    }
+    getBucketTagging(args, optionsOrCb, cb) {
+        const command = new GetBucketTaggingCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    S3.prototype.getBucketVersioning = function (args, optionsOrCb, cb) {
-        var command = new GetBucketVersioningCommand(args);
+    }
+    getBucketVersioning(args, optionsOrCb, cb) {
+        const command = new GetBucketVersioningCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    S3.prototype.getBucketWebsite = function (args, optionsOrCb, cb) {
-        var command = new GetBucketWebsiteCommand(args);
+    }
+    getBucketWebsite(args, optionsOrCb, cb) {
+        const command = new GetBucketWebsiteCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    S3.prototype.getObject = function (args, optionsOrCb, cb) {
-        var command = new GetObjectCommand(args);
+    }
+    getObject(args, optionsOrCb, cb) {
+        const command = new GetObjectCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    S3.prototype.getObjectAcl = function (args, optionsOrCb, cb) {
-        var command = new GetObjectAclCommand(args);
+    }
+    getObjectAcl(args, optionsOrCb, cb) {
+        const command = new GetObjectAclCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    S3.prototype.getObjectAttributes = function (args, optionsOrCb, cb) {
-        var command = new GetObjectAttributesCommand(args);
+    }
+    getObjectAttributes(args, optionsOrCb, cb) {
+        const command = new GetObjectAttributesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    S3.prototype.getObjectLegalHold = function (args, optionsOrCb, cb) {
-        var command = new GetObjectLegalHoldCommand(args);
+    }
+    getObjectLegalHold(args, optionsOrCb, cb) {
+        const command = new GetObjectLegalHoldCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    S3.prototype.getObjectLockConfiguration = function (args, optionsOrCb, cb) {
-        var command = new GetObjectLockConfigurationCommand(args);
+    }
+    getObjectLockConfiguration(args, optionsOrCb, cb) {
+        const command = new GetObjectLockConfigurationCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    S3.prototype.getObjectRetention = function (args, optionsOrCb, cb) {
-        var command = new GetObjectRetentionCommand(args);
+    }
+    getObjectRetention(args, optionsOrCb, cb) {
+        const command = new GetObjectRetentionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    S3.prototype.getObjectTagging = function (args, optionsOrCb, cb) {
-        var command = new GetObjectTaggingCommand(args);
+    }
+    getObjectTagging(args, optionsOrCb, cb) {
+        const command = new GetObjectTaggingCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    S3.prototype.getObjectTorrent = function (args, optionsOrCb, cb) {
-        var command = new GetObjectTorrentCommand(args);
+    }
+    getObjectTorrent(args, optionsOrCb, cb) {
+        const command = new GetObjectTorrentCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    S3.prototype.getPublicAccessBlock = function (args, optionsOrCb, cb) {
-        var command = new GetPublicAccessBlockCommand(args);
+    }
+    getPublicAccessBlock(args, optionsOrCb, cb) {
+        const command = new GetPublicAccessBlockCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    S3.prototype.headBucket = function (args, optionsOrCb, cb) {
-        var command = new HeadBucketCommand(args);
+    }
+    headBucket(args, optionsOrCb, cb) {
+        const command = new HeadBucketCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    S3.prototype.headObject = function (args, optionsOrCb, cb) {
-        var command = new HeadObjectCommand(args);
+    }
+    headObject(args, optionsOrCb, cb) {
+        const command = new HeadObjectCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    S3.prototype.listBucketAnalyticsConfigurations = function (args, optionsOrCb, cb) {
-        var command = new ListBucketAnalyticsConfigurationsCommand(args);
+    }
+    listBucketAnalyticsConfigurations(args, optionsOrCb, cb) {
+        const command = new ListBucketAnalyticsConfigurationsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    S3.prototype.listBucketIntelligentTieringConfigurations = function (args, optionsOrCb, cb) {
-        var command = new ListBucketIntelligentTieringConfigurationsCommand(args);
+    }
+    listBucketIntelligentTieringConfigurations(args, optionsOrCb, cb) {
+        const command = new ListBucketIntelligentTieringConfigurationsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    S3.prototype.listBucketInventoryConfigurations = function (args, optionsOrCb, cb) {
-        var command = new ListBucketInventoryConfigurationsCommand(args);
+    }
+    listBucketInventoryConfigurations(args, optionsOrCb, cb) {
+        const command = new ListBucketInventoryConfigurationsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    S3.prototype.listBucketMetricsConfigurations = function (args, optionsOrCb, cb) {
-        var command = new ListBucketMetricsConfigurationsCommand(args);
+    }
+    listBucketMetricsConfigurations(args, optionsOrCb, cb) {
+        const command = new ListBucketMetricsConfigurationsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    S3.prototype.listBuckets = function (args, optionsOrCb, cb) {
-        var command = new ListBucketsCommand(args);
+    }
+    listBuckets(args, optionsOrCb, cb) {
+        const command = new ListBucketsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    S3.prototype.listMultipartUploads = function (args, optionsOrCb, cb) {
-        var command = new ListMultipartUploadsCommand(args);
+    }
+    listMultipartUploads(args, optionsOrCb, cb) {
+        const command = new ListMultipartUploadsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    S3.prototype.listObjects = function (args, optionsOrCb, cb) {
-        var command = new ListObjectsCommand(args);
+    }
+    listObjects(args, optionsOrCb, cb) {
+        const command = new ListObjectsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    S3.prototype.listObjectsV2 = function (args, optionsOrCb, cb) {
-        var command = new ListObjectsV2Command(args);
+    }
+    listObjectsV2(args, optionsOrCb, cb) {
+        const command = new ListObjectsV2Command(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    S3.prototype.listObjectVersions = function (args, optionsOrCb, cb) {
-        var command = new ListObjectVersionsCommand(args);
+    }
+    listObjectVersions(args, optionsOrCb, cb) {
+        const command = new ListObjectVersionsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    S3.prototype.listParts = function (args, optionsOrCb, cb) {
-        var command = new ListPartsCommand(args);
+    }
+    listParts(args, optionsOrCb, cb) {
+        const command = new ListPartsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    S3.prototype.putBucketAccelerateConfiguration = function (args, optionsOrCb, cb) {
-        var command = new PutBucketAccelerateConfigurationCommand(args);
+    }
+    putBucketAccelerateConfiguration(args, optionsOrCb, cb) {
+        const command = new PutBucketAccelerateConfigurationCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    S3.prototype.putBucketAcl = function (args, optionsOrCb, cb) {
-        var command = new PutBucketAclCommand(args);
+    }
+    putBucketAcl(args, optionsOrCb, cb) {
+        const command = new PutBucketAclCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    S3.prototype.putBucketAnalyticsConfiguration = function (args, optionsOrCb, cb) {
-        var command = new PutBucketAnalyticsConfigurationCommand(args);
+    }
+    putBucketAnalyticsConfiguration(args, optionsOrCb, cb) {
+        const command = new PutBucketAnalyticsConfigurationCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    S3.prototype.putBucketCors = function (args, optionsOrCb, cb) {
-        var command = new PutBucketCorsCommand(args);
+    }
+    putBucketCors(args, optionsOrCb, cb) {
+        const command = new PutBucketCorsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    S3.prototype.putBucketEncryption = function (args, optionsOrCb, cb) {
-        var command = new PutBucketEncryptionCommand(args);
+    }
+    putBucketEncryption(args, optionsOrCb, cb) {
+        const command = new PutBucketEncryptionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    S3.prototype.putBucketIntelligentTieringConfiguration = function (args, optionsOrCb, cb) {
-        var command = new PutBucketIntelligentTieringConfigurationCommand(args);
+    }
+    putBucketIntelligentTieringConfiguration(args, optionsOrCb, cb) {
+        const command = new PutBucketIntelligentTieringConfigurationCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    S3.prototype.putBucketInventoryConfiguration = function (args, optionsOrCb, cb) {
-        var command = new PutBucketInventoryConfigurationCommand(args);
+    }
+    putBucketInventoryConfiguration(args, optionsOrCb, cb) {
+        const command = new PutBucketInventoryConfigurationCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    S3.prototype.putBucketLifecycleConfiguration = function (args, optionsOrCb, cb) {
-        var command = new PutBucketLifecycleConfigurationCommand(args);
+    }
+    putBucketLifecycleConfiguration(args, optionsOrCb, cb) {
+        const command = new PutBucketLifecycleConfigurationCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    S3.prototype.putBucketLogging = function (args, optionsOrCb, cb) {
-        var command = new PutBucketLoggingCommand(args);
+    }
+    putBucketLogging(args, optionsOrCb, cb) {
+        const command = new PutBucketLoggingCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    S3.prototype.putBucketMetricsConfiguration = function (args, optionsOrCb, cb) {
-        var command = new PutBucketMetricsConfigurationCommand(args);
+    }
+    putBucketMetricsConfiguration(args, optionsOrCb, cb) {
+        const command = new PutBucketMetricsConfigurationCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    S3.prototype.putBucketNotificationConfiguration = function (args, optionsOrCb, cb) {
-        var command = new PutBucketNotificationConfigurationCommand(args);
+    }
+    putBucketNotificationConfiguration(args, optionsOrCb, cb) {
+        const command = new PutBucketNotificationConfigurationCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    S3.prototype.putBucketOwnershipControls = function (args, optionsOrCb, cb) {
-        var command = new PutBucketOwnershipControlsCommand(args);
+    }
+    putBucketOwnershipControls(args, optionsOrCb, cb) {
+        const command = new PutBucketOwnershipControlsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    S3.prototype.putBucketPolicy = function (args, optionsOrCb, cb) {
-        var command = new PutBucketPolicyCommand(args);
+    }
+    putBucketPolicy(args, optionsOrCb, cb) {
+        const command = new PutBucketPolicyCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    S3.prototype.putBucketReplication = function (args, optionsOrCb, cb) {
-        var command = new PutBucketReplicationCommand(args);
+    }
+    putBucketReplication(args, optionsOrCb, cb) {
+        const command = new PutBucketReplicationCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    S3.prototype.putBucketRequestPayment = function (args, optionsOrCb, cb) {
-        var command = new PutBucketRequestPaymentCommand(args);
+    }
+    putBucketRequestPayment(args, optionsOrCb, cb) {
+        const command = new PutBucketRequestPaymentCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    S3.prototype.putBucketTagging = function (args, optionsOrCb, cb) {
-        var command = new PutBucketTaggingCommand(args);
+    }
+    putBucketTagging(args, optionsOrCb, cb) {
+        const command = new PutBucketTaggingCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    S3.prototype.putBucketVersioning = function (args, optionsOrCb, cb) {
-        var command = new PutBucketVersioningCommand(args);
+    }
+    putBucketVersioning(args, optionsOrCb, cb) {
+        const command = new PutBucketVersioningCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    S3.prototype.putBucketWebsite = function (args, optionsOrCb, cb) {
-        var command = new PutBucketWebsiteCommand(args);
+    }
+    putBucketWebsite(args, optionsOrCb, cb) {
+        const command = new PutBucketWebsiteCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    S3.prototype.putObject = function (args, optionsOrCb, cb) {
-        var command = new PutObjectCommand(args);
+    }
+    putObject(args, optionsOrCb, cb) {
+        const command = new PutObjectCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    S3.prototype.putObjectAcl = function (args, optionsOrCb, cb) {
-        var command = new PutObjectAclCommand(args);
+    }
+    putObjectAcl(args, optionsOrCb, cb) {
+        const command = new PutObjectAclCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    S3.prototype.putObjectLegalHold = function (args, optionsOrCb, cb) {
-        var command = new PutObjectLegalHoldCommand(args);
+    }
+    putObjectLegalHold(args, optionsOrCb, cb) {
+        const command = new PutObjectLegalHoldCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    S3.prototype.putObjectLockConfiguration = function (args, optionsOrCb, cb) {
-        var command = new PutObjectLockConfigurationCommand(args);
+    }
+    putObjectLockConfiguration(args, optionsOrCb, cb) {
+        const command = new PutObjectLockConfigurationCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    S3.prototype.putObjectRetention = function (args, optionsOrCb, cb) {
-        var command = new PutObjectRetentionCommand(args);
+    }
+    putObjectRetention(args, optionsOrCb, cb) {
+        const command = new PutObjectRetentionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    S3.prototype.putObjectTagging = function (args, optionsOrCb, cb) {
-        var command = new PutObjectTaggingCommand(args);
+    }
+    putObjectTagging(args, optionsOrCb, cb) {
+        const command = new PutObjectTaggingCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    S3.prototype.putPublicAccessBlock = function (args, optionsOrCb, cb) {
-        var command = new PutPublicAccessBlockCommand(args);
+    }
+    putPublicAccessBlock(args, optionsOrCb, cb) {
+        const command = new PutPublicAccessBlockCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    S3.prototype.restoreObject = function (args, optionsOrCb, cb) {
-        var command = new RestoreObjectCommand(args);
+    }
+    restoreObject(args, optionsOrCb, cb) {
+        const command = new RestoreObjectCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    S3.prototype.selectObjectContent = function (args, optionsOrCb, cb) {
-        var command = new SelectObjectContentCommand(args);
+    }
+    selectObjectContent(args, optionsOrCb, cb) {
+        const command = new SelectObjectContentCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    S3.prototype.uploadPart = function (args, optionsOrCb, cb) {
-        var command = new UploadPartCommand(args);
+    }
+    uploadPart(args, optionsOrCb, cb) {
+        const command = new UploadPartCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    S3.prototype.uploadPartCopy = function (args, optionsOrCb, cb) {
-        var command = new UploadPartCopyCommand(args);
+    }
+    uploadPartCopy(args, optionsOrCb, cb) {
+        const command = new UploadPartCopyCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    S3.prototype.writeGetObjectResponse = function (args, optionsOrCb, cb) {
-        var command = new WriteGetObjectResponseCommand(args);
+    }
+    writeGetObjectResponse(args, optionsOrCb, cb) {
+        const command = new WriteGetObjectResponseCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    return S3;
-}(S3Client));
-export { S3 };
+    }
+}