@aws-sdk/client-s3 3.183.0 → 3.185.0

package/dist-es/S3.js

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