Restoring authorship annotation for <unril@yandex-team.ru>. Commit 2 of 2.

1 files changed, 958 insertions, 958 deletions

diff --git a/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-s3/source/S3Client.cpp b/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-s3/source/S3Client.cpp
index 84b52626ec..ca21d88bb2 100644
--- a/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-s3/source/S3Client.cpp
+++ b/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-s3/source/S3Client.cpp
@@ -14,10 +14,10 @@
 #include <aws/core/utils/xml/XmlSerializer.h>
 #include <aws/core/utils/memory/stl/AWSStringStream.h>
 #include <aws/core/utils/threading/Executor.h>
-#include <aws/core/utils/DNS.h> 
-#include <aws/core/utils/logging/LogMacros.h> 
- 
-#include <aws/core/utils/event/EventStream.h> 
+#include <aws/core/utils/DNS.h>
+#include <aws/core/utils/logging/LogMacros.h>
+
+#include <aws/core/utils/event/EventStream.h>
 #include <aws/s3/S3Client.h>
 #include <aws/s3/S3Endpoint.h>
 #include <aws/s3/S3ErrorMarshaller.h>
@@ -43,7 +43,7 @@
 #include <aws/s3/model/DeleteObjectRequest.h>
 #include <aws/s3/model/DeleteObjectTaggingRequest.h>
 #include <aws/s3/model/DeleteObjectsRequest.h>
-#include <aws/s3/model/DeletePublicAccessBlockRequest.h> 
+#include <aws/s3/model/DeletePublicAccessBlockRequest.h>
 #include <aws/s3/model/GetBucketAccelerateConfigurationRequest.h>
 #include <aws/s3/model/GetBucketAclRequest.h>
 #include <aws/s3/model/GetBucketAnalyticsConfigurationRequest.h>
@@ -58,7 +58,7 @@
 #include <aws/s3/model/GetBucketNotificationConfigurationRequest.h>
 #include <aws/s3/model/GetBucketOwnershipControlsRequest.h>
 #include <aws/s3/model/GetBucketPolicyRequest.h>
-#include <aws/s3/model/GetBucketPolicyStatusRequest.h> 
+#include <aws/s3/model/GetBucketPolicyStatusRequest.h>
 #include <aws/s3/model/GetBucketReplicationRequest.h>
 #include <aws/s3/model/GetBucketRequestPaymentRequest.h>
 #include <aws/s3/model/GetBucketTaggingRequest.h>
@@ -66,12 +66,12 @@
 #include <aws/s3/model/GetBucketWebsiteRequest.h>
 #include <aws/s3/model/GetObjectRequest.h>
 #include <aws/s3/model/GetObjectAclRequest.h>
-#include <aws/s3/model/GetObjectLegalHoldRequest.h> 
-#include <aws/s3/model/GetObjectLockConfigurationRequest.h> 
-#include <aws/s3/model/GetObjectRetentionRequest.h> 
+#include <aws/s3/model/GetObjectLegalHoldRequest.h>
+#include <aws/s3/model/GetObjectLockConfigurationRequest.h>
+#include <aws/s3/model/GetObjectRetentionRequest.h>
 #include <aws/s3/model/GetObjectTaggingRequest.h>
 #include <aws/s3/model/GetObjectTorrentRequest.h>
-#include <aws/s3/model/GetPublicAccessBlockRequest.h> 
+#include <aws/s3/model/GetPublicAccessBlockRequest.h>
 #include <aws/s3/model/HeadBucketRequest.h>
 #include <aws/s3/model/HeadObjectRequest.h>
 #include <aws/s3/model/ListBucketAnalyticsConfigurationsRequest.h>
@@ -103,13 +103,13 @@
 #include <aws/s3/model/PutBucketWebsiteRequest.h>
 #include <aws/s3/model/PutObjectRequest.h>
 #include <aws/s3/model/PutObjectAclRequest.h>
-#include <aws/s3/model/PutObjectLegalHoldRequest.h> 
-#include <aws/s3/model/PutObjectLockConfigurationRequest.h> 
-#include <aws/s3/model/PutObjectRetentionRequest.h> 
+#include <aws/s3/model/PutObjectLegalHoldRequest.h>
+#include <aws/s3/model/PutObjectLockConfigurationRequest.h>
+#include <aws/s3/model/PutObjectRetentionRequest.h>
 #include <aws/s3/model/PutObjectTaggingRequest.h>
-#include <aws/s3/model/PutPublicAccessBlockRequest.h> 
+#include <aws/s3/model/PutPublicAccessBlockRequest.h>
 #include <aws/s3/model/RestoreObjectRequest.h>
-#include <aws/s3/model/SelectObjectContentRequest.h> 
+#include <aws/s3/model/SelectObjectContentRequest.h>
 #include <aws/s3/model/UploadPartRequest.h>
 #include <aws/s3/model/UploadPartCopyRequest.h>
 
@@ -165,57 +165,57 @@ void S3Client::init(const ClientConfiguration& config)
 {
   SetServiceClientName("S3");
   LoadS3SpecificConfig(config.profileName);
-  m_configScheme = SchemeMapper::ToString(config.scheme); 
-  m_scheme = m_configScheme; 
+  m_configScheme = SchemeMapper::ToString(config.scheme);
+  m_scheme = m_configScheme;
   m_useDualStack = config.useDualStack;
-  if (config.endpointOverride.empty()) 
-  { 
+  if (config.endpointOverride.empty())
+  {
       m_useCustomEndpoint = false;
       m_baseUri = S3Endpoint::ForRegion(config.region, config.useDualStack, m_USEast1RegionalEndpointOption == Aws::S3::US_EAST_1_REGIONAL_ENDPOINT_OPTION::REGIONAL);
-  } 
-  else 
-  { 
+  }
+  else
+  {
       m_useCustomEndpoint = true;
-      OverrideEndpoint(config.endpointOverride); 
-  } 
-}
-
-void S3Client::OverrideEndpoint(const Aws::String& endpoint) 
-{ 
-  if (endpoint.compare(0, 7, "http://") == 0) 
-  { 
-      m_scheme = "http"; 
-      m_baseUri = endpoint.substr(7); 
-  } 
-  else if (endpoint.compare(0, 8, "https://") == 0) 
-  { 
-      m_scheme = "https"; 
-      m_baseUri = endpoint.substr(8); 
-  } 
-  else 
-  { 
-      m_scheme = m_configScheme; 
-      m_baseUri = endpoint; 
-  } 
-} 
+      OverrideEndpoint(config.endpointOverride);
+  }
+}
+
+void S3Client::OverrideEndpoint(const Aws::String& endpoint)
+{
+  if (endpoint.compare(0, 7, "http://") == 0)
+  {
+      m_scheme = "http";
+      m_baseUri = endpoint.substr(7);
+  }
+  else if (endpoint.compare(0, 8, "https://") == 0)
+  {
+      m_scheme = "https";
+      m_baseUri = endpoint.substr(8);
+  }
+  else
+  {
+      m_scheme = m_configScheme;
+      m_baseUri = endpoint;
+  }
+}
 
 AbortMultipartUploadOutcome S3Client::AbortMultipartUpload(const AbortMultipartUploadRequest& request) const
 {
-  if (!request.BucketHasBeenSet()) 
-  { 
-    AWS_LOGSTREAM_ERROR("AbortMultipartUpload", "Required field: Bucket, is not set"); 
-    return AbortMultipartUploadOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false)); 
-  } 
-  if (!request.KeyHasBeenSet()) 
-  { 
-    AWS_LOGSTREAM_ERROR("AbortMultipartUpload", "Required field: Key, is not set"); 
-    return AbortMultipartUploadOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Key]", false)); 
-  } 
-  if (!request.UploadIdHasBeenSet()) 
-  { 
-    AWS_LOGSTREAM_ERROR("AbortMultipartUpload", "Required field: UploadId, is not set"); 
-    return AbortMultipartUploadOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [UploadId]", false)); 
-  } 
+  if (!request.BucketHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("AbortMultipartUpload", "Required field: Bucket, is not set");
+    return AbortMultipartUploadOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
+  }
+  if (!request.KeyHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("AbortMultipartUpload", "Required field: Key, is not set");
+    return AbortMultipartUploadOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Key]", false));
+  }
+  if (!request.UploadIdHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("AbortMultipartUpload", "Required field: UploadId, is not set");
+    return AbortMultipartUploadOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [UploadId]", false));
+  }
   ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
   if (!computeEndpointOutcome.IsSuccess())
   {
@@ -249,21 +249,21 @@ void S3Client::AbortMultipartUploadAsyncHelper(const AbortMultipartUploadRequest
 
 CompleteMultipartUploadOutcome S3Client::CompleteMultipartUpload(const CompleteMultipartUploadRequest& request) const
 {
-  if (!request.BucketHasBeenSet()) 
-  { 
-    AWS_LOGSTREAM_ERROR("CompleteMultipartUpload", "Required field: Bucket, is not set"); 
-    return CompleteMultipartUploadOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false)); 
-  } 
-  if (!request.KeyHasBeenSet()) 
-  { 
-    AWS_LOGSTREAM_ERROR("CompleteMultipartUpload", "Required field: Key, is not set"); 
-    return CompleteMultipartUploadOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Key]", false)); 
-  } 
-  if (!request.UploadIdHasBeenSet()) 
-  { 
-    AWS_LOGSTREAM_ERROR("CompleteMultipartUpload", "Required field: UploadId, is not set"); 
-    return CompleteMultipartUploadOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [UploadId]", false)); 
-  } 
+  if (!request.BucketHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("CompleteMultipartUpload", "Required field: Bucket, is not set");
+    return CompleteMultipartUploadOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
+  }
+  if (!request.KeyHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("CompleteMultipartUpload", "Required field: Key, is not set");
+    return CompleteMultipartUploadOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Key]", false));
+  }
+  if (!request.UploadIdHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("CompleteMultipartUpload", "Required field: UploadId, is not set");
+    return CompleteMultipartUploadOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [UploadId]", false));
+  }
   ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
   if (!computeEndpointOutcome.IsSuccess())
   {
@@ -297,21 +297,21 @@ void S3Client::CompleteMultipartUploadAsyncHelper(const CompleteMultipartUploadR
 
 CopyObjectOutcome S3Client::CopyObject(const CopyObjectRequest& request) const
 {
-  if (!request.BucketHasBeenSet()) 
-  { 
-    AWS_LOGSTREAM_ERROR("CopyObject", "Required field: Bucket, is not set"); 
-    return CopyObjectOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false)); 
-  } 
-  if (!request.CopySourceHasBeenSet()) 
-  { 
-    AWS_LOGSTREAM_ERROR("CopyObject", "Required field: CopySource, is not set"); 
-    return CopyObjectOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [CopySource]", false)); 
-  } 
-  if (!request.KeyHasBeenSet()) 
-  { 
-    AWS_LOGSTREAM_ERROR("CopyObject", "Required field: Key, is not set"); 
-    return CopyObjectOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Key]", false)); 
-  } 
+  if (!request.BucketHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("CopyObject", "Required field: Bucket, is not set");
+    return CopyObjectOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
+  }
+  if (!request.CopySourceHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("CopyObject", "Required field: CopySource, is not set");
+    return CopyObjectOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [CopySource]", false));
+  }
+  if (!request.KeyHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("CopyObject", "Required field: Key, is not set");
+    return CopyObjectOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Key]", false));
+  }
   ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
   if (!computeEndpointOutcome.IsSuccess())
   {
@@ -345,11 +345,11 @@ void S3Client::CopyObjectAsyncHelper(const CopyObjectRequest& request, const Cop
 
 CreateBucketOutcome S3Client::CreateBucket(const CreateBucketRequest& request) const
 {
-  if (!request.BucketHasBeenSet()) 
-  { 
-    AWS_LOGSTREAM_ERROR("CreateBucket", "Required field: Bucket, is not set"); 
-    return CreateBucketOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false)); 
-  } 
+  if (!request.BucketHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("CreateBucket", "Required field: Bucket, is not set");
+    return CreateBucketOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
+  }
   ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString();
   if (!computeEndpointOutcome.IsSuccess())
   {
@@ -383,16 +383,16 @@ void S3Client::CreateBucketAsyncHelper(const CreateBucketRequest& request, const
 
 CreateMultipartUploadOutcome S3Client::CreateMultipartUpload(const CreateMultipartUploadRequest& request) const
 {
-  if (!request.BucketHasBeenSet()) 
-  { 
-    AWS_LOGSTREAM_ERROR("CreateMultipartUpload", "Required field: Bucket, is not set"); 
-    return CreateMultipartUploadOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false)); 
-  } 
-  if (!request.KeyHasBeenSet()) 
-  { 
-    AWS_LOGSTREAM_ERROR("CreateMultipartUpload", "Required field: Key, is not set"); 
-    return CreateMultipartUploadOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Key]", false)); 
-  } 
+  if (!request.BucketHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("CreateMultipartUpload", "Required field: Bucket, is not set");
+    return CreateMultipartUploadOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
+  }
+  if (!request.KeyHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("CreateMultipartUpload", "Required field: Key, is not set");
+    return CreateMultipartUploadOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Key]", false));
+  }
   ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
   if (!computeEndpointOutcome.IsSuccess())
   {
@@ -428,11 +428,11 @@ void S3Client::CreateMultipartUploadAsyncHelper(const CreateMultipartUploadReque
 
 DeleteBucketOutcome S3Client::DeleteBucket(const DeleteBucketRequest& request) const
 {
-  if (!request.BucketHasBeenSet()) 
-  { 
-    AWS_LOGSTREAM_ERROR("DeleteBucket", "Required field: Bucket, is not set"); 
-    return DeleteBucketOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false)); 
-  } 
+  if (!request.BucketHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("DeleteBucket", "Required field: Bucket, is not set");
+    return DeleteBucketOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
+  }
   ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
   if (!computeEndpointOutcome.IsSuccess())
   {
@@ -464,16 +464,16 @@ void S3Client::DeleteBucketAsyncHelper(const DeleteBucketRequest& request, const
 
 DeleteBucketAnalyticsConfigurationOutcome S3Client::DeleteBucketAnalyticsConfiguration(const DeleteBucketAnalyticsConfigurationRequest& request) const
 {
-  if (!request.BucketHasBeenSet()) 
-  { 
-    AWS_LOGSTREAM_ERROR("DeleteBucketAnalyticsConfiguration", "Required field: Bucket, is not set"); 
-    return DeleteBucketAnalyticsConfigurationOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false)); 
-  } 
-  if (!request.IdHasBeenSet()) 
-  { 
-    AWS_LOGSTREAM_ERROR("DeleteBucketAnalyticsConfiguration", "Required field: Id, is not set"); 
-    return DeleteBucketAnalyticsConfigurationOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Id]", false)); 
-  } 
+  if (!request.BucketHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("DeleteBucketAnalyticsConfiguration", "Required field: Bucket, is not set");
+    return DeleteBucketAnalyticsConfigurationOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
+  }
+  if (!request.IdHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("DeleteBucketAnalyticsConfiguration", "Required field: Id, is not set");
+    return DeleteBucketAnalyticsConfigurationOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Id]", false));
+  }
   ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
   if (!computeEndpointOutcome.IsSuccess())
   {
@@ -506,11 +506,11 @@ void S3Client::DeleteBucketAnalyticsConfigurationAsyncHelper(const DeleteBucketA
 
 DeleteBucketCorsOutcome S3Client::DeleteBucketCors(const DeleteBucketCorsRequest& request) const
 {
-  if (!request.BucketHasBeenSet()) 
-  { 
-    AWS_LOGSTREAM_ERROR("DeleteBucketCors", "Required field: Bucket, is not set"); 
-    return DeleteBucketCorsOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false)); 
-  } 
+  if (!request.BucketHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("DeleteBucketCors", "Required field: Bucket, is not set");
+    return DeleteBucketCorsOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
+  }
   ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
   if (!computeEndpointOutcome.IsSuccess())
   {
@@ -543,11 +543,11 @@ void S3Client::DeleteBucketCorsAsyncHelper(const DeleteBucketCorsRequest& reques
 
 DeleteBucketEncryptionOutcome S3Client::DeleteBucketEncryption(const DeleteBucketEncryptionRequest& request) const
 {
-  if (!request.BucketHasBeenSet()) 
-  { 
-    AWS_LOGSTREAM_ERROR("DeleteBucketEncryption", "Required field: Bucket, is not set"); 
-    return DeleteBucketEncryptionOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false)); 
-  } 
+  if (!request.BucketHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("DeleteBucketEncryption", "Required field: Bucket, is not set");
+    return DeleteBucketEncryptionOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
+  }
   ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
   if (!computeEndpointOutcome.IsSuccess())
   {
@@ -622,16 +622,16 @@ void S3Client::DeleteBucketIntelligentTieringConfigurationAsyncHelper(const Dele
 
 DeleteBucketInventoryConfigurationOutcome S3Client::DeleteBucketInventoryConfiguration(const DeleteBucketInventoryConfigurationRequest& request) const
 {
-  if (!request.BucketHasBeenSet()) 
-  { 
-    AWS_LOGSTREAM_ERROR("DeleteBucketInventoryConfiguration", "Required field: Bucket, is not set"); 
-    return DeleteBucketInventoryConfigurationOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false)); 
-  } 
-  if (!request.IdHasBeenSet()) 
-  { 
-    AWS_LOGSTREAM_ERROR("DeleteBucketInventoryConfiguration", "Required field: Id, is not set"); 
-    return DeleteBucketInventoryConfigurationOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Id]", false)); 
-  } 
+  if (!request.BucketHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("DeleteBucketInventoryConfiguration", "Required field: Bucket, is not set");
+    return DeleteBucketInventoryConfigurationOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
+  }
+  if (!request.IdHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("DeleteBucketInventoryConfiguration", "Required field: Id, is not set");
+    return DeleteBucketInventoryConfigurationOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Id]", false));
+  }
   ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
   if (!computeEndpointOutcome.IsSuccess())
   {
@@ -664,11 +664,11 @@ void S3Client::DeleteBucketInventoryConfigurationAsyncHelper(const DeleteBucketI
 
 DeleteBucketLifecycleOutcome S3Client::DeleteBucketLifecycle(const DeleteBucketLifecycleRequest& request) const
 {
-  if (!request.BucketHasBeenSet()) 
-  { 
-    AWS_LOGSTREAM_ERROR("DeleteBucketLifecycle", "Required field: Bucket, is not set"); 
-    return DeleteBucketLifecycleOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false)); 
-  } 
+  if (!request.BucketHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("DeleteBucketLifecycle", "Required field: Bucket, is not set");
+    return DeleteBucketLifecycleOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
+  }
   ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
   if (!computeEndpointOutcome.IsSuccess())
   {
@@ -701,16 +701,16 @@ void S3Client::DeleteBucketLifecycleAsyncHelper(const DeleteBucketLifecycleReque
 
 DeleteBucketMetricsConfigurationOutcome S3Client::DeleteBucketMetricsConfiguration(const DeleteBucketMetricsConfigurationRequest& request) const
 {
-  if (!request.BucketHasBeenSet()) 
-  { 
-    AWS_LOGSTREAM_ERROR("DeleteBucketMetricsConfiguration", "Required field: Bucket, is not set"); 
-    return DeleteBucketMetricsConfigurationOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false)); 
-  } 
-  if (!request.IdHasBeenSet()) 
-  { 
-    AWS_LOGSTREAM_ERROR("DeleteBucketMetricsConfiguration", "Required field: Id, is not set"); 
-    return DeleteBucketMetricsConfigurationOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Id]", false)); 
-  } 
+  if (!request.BucketHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("DeleteBucketMetricsConfiguration", "Required field: Bucket, is not set");
+    return DeleteBucketMetricsConfigurationOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
+  }
+  if (!request.IdHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("DeleteBucketMetricsConfiguration", "Required field: Id, is not set");
+    return DeleteBucketMetricsConfigurationOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Id]", false));
+  }
   ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
   if (!computeEndpointOutcome.IsSuccess())
   {
@@ -780,11 +780,11 @@ void S3Client::DeleteBucketOwnershipControlsAsyncHelper(const DeleteBucketOwners
 
 DeleteBucketPolicyOutcome S3Client::DeleteBucketPolicy(const DeleteBucketPolicyRequest& request) const
 {
-  if (!request.BucketHasBeenSet()) 
-  { 
-    AWS_LOGSTREAM_ERROR("DeleteBucketPolicy", "Required field: Bucket, is not set"); 
-    return DeleteBucketPolicyOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false)); 
-  } 
+  if (!request.BucketHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("DeleteBucketPolicy", "Required field: Bucket, is not set");
+    return DeleteBucketPolicyOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
+  }
   ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
   if (!computeEndpointOutcome.IsSuccess())
   {
@@ -817,11 +817,11 @@ void S3Client::DeleteBucketPolicyAsyncHelper(const DeleteBucketPolicyRequest& re
 
 DeleteBucketReplicationOutcome S3Client::DeleteBucketReplication(const DeleteBucketReplicationRequest& request) const
 {
-  if (!request.BucketHasBeenSet()) 
-  { 
-    AWS_LOGSTREAM_ERROR("DeleteBucketReplication", "Required field: Bucket, is not set"); 
-    return DeleteBucketReplicationOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false)); 
-  } 
+  if (!request.BucketHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("DeleteBucketReplication", "Required field: Bucket, is not set");
+    return DeleteBucketReplicationOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
+  }
   ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
   if (!computeEndpointOutcome.IsSuccess())
   {
@@ -854,11 +854,11 @@ void S3Client::DeleteBucketReplicationAsyncHelper(const DeleteBucketReplicationR
 
 DeleteBucketTaggingOutcome S3Client::DeleteBucketTagging(const DeleteBucketTaggingRequest& request) const
 {
-  if (!request.BucketHasBeenSet()) 
-  { 
-    AWS_LOGSTREAM_ERROR("DeleteBucketTagging", "Required field: Bucket, is not set"); 
-    return DeleteBucketTaggingOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false)); 
-  } 
+  if (!request.BucketHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("DeleteBucketTagging", "Required field: Bucket, is not set");
+    return DeleteBucketTaggingOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
+  }
   ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
   if (!computeEndpointOutcome.IsSuccess())
   {
@@ -891,11 +891,11 @@ void S3Client::DeleteBucketTaggingAsyncHelper(const DeleteBucketTaggingRequest&
 
 DeleteBucketWebsiteOutcome S3Client::DeleteBucketWebsite(const DeleteBucketWebsiteRequest& request) const
 {
-  if (!request.BucketHasBeenSet()) 
-  { 
-    AWS_LOGSTREAM_ERROR("DeleteBucketWebsite", "Required field: Bucket, is not set"); 
-    return DeleteBucketWebsiteOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false)); 
-  } 
+  if (!request.BucketHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("DeleteBucketWebsite", "Required field: Bucket, is not set");
+    return DeleteBucketWebsiteOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
+  }
   ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
   if (!computeEndpointOutcome.IsSuccess())
   {
@@ -928,16 +928,16 @@ void S3Client::DeleteBucketWebsiteAsyncHelper(const DeleteBucketWebsiteRequest&
 
 DeleteObjectOutcome S3Client::DeleteObject(const DeleteObjectRequest& request) const
 {
-  if (!request.BucketHasBeenSet()) 
-  { 
-    AWS_LOGSTREAM_ERROR("DeleteObject", "Required field: Bucket, is not set"); 
-    return DeleteObjectOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false)); 
-  } 
-  if (!request.KeyHasBeenSet()) 
-  { 
-    AWS_LOGSTREAM_ERROR("DeleteObject", "Required field: Key, is not set"); 
-    return DeleteObjectOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Key]", false)); 
-  } 
+  if (!request.BucketHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("DeleteObject", "Required field: Bucket, is not set");
+    return DeleteObjectOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
+  }
+  if (!request.KeyHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("DeleteObject", "Required field: Key, is not set");
+    return DeleteObjectOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Key]", false));
+  }
   ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
   if (!computeEndpointOutcome.IsSuccess())
   {
@@ -971,16 +971,16 @@ void S3Client::DeleteObjectAsyncHelper(const DeleteObjectRequest& request, const
 
 DeleteObjectTaggingOutcome S3Client::DeleteObjectTagging(const DeleteObjectTaggingRequest& request) const
 {
-  if (!request.BucketHasBeenSet()) 
-  { 
-    AWS_LOGSTREAM_ERROR("DeleteObjectTagging", "Required field: Bucket, is not set"); 
-    return DeleteObjectTaggingOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false)); 
-  } 
-  if (!request.KeyHasBeenSet()) 
-  { 
-    AWS_LOGSTREAM_ERROR("DeleteObjectTagging", "Required field: Key, is not set"); 
-    return DeleteObjectTaggingOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Key]", false)); 
-  } 
+  if (!request.BucketHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("DeleteObjectTagging", "Required field: Bucket, is not set");
+    return DeleteObjectTaggingOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
+  }
+  if (!request.KeyHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("DeleteObjectTagging", "Required field: Key, is not set");
+    return DeleteObjectTaggingOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Key]", false));
+  }
   ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
   if (!computeEndpointOutcome.IsSuccess())
   {
@@ -1016,11 +1016,11 @@ void S3Client::DeleteObjectTaggingAsyncHelper(const DeleteObjectTaggingRequest&
 
 DeleteObjectsOutcome S3Client::DeleteObjects(const DeleteObjectsRequest& request) const
 {
-  if (!request.BucketHasBeenSet()) 
-  { 
-    AWS_LOGSTREAM_ERROR("DeleteObjects", "Required field: Bucket, is not set"); 
-    return DeleteObjectsOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false)); 
-  } 
+  if (!request.BucketHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("DeleteObjects", "Required field: Bucket, is not set");
+    return DeleteObjectsOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
+  }
   ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
   if (!computeEndpointOutcome.IsSuccess())
   {
@@ -1051,50 +1051,50 @@ void S3Client::DeleteObjectsAsyncHelper(const DeleteObjectsRequest& request, con
   handler(this, request, DeleteObjects(request), context);
 }
 
-DeletePublicAccessBlockOutcome S3Client::DeletePublicAccessBlock(const DeletePublicAccessBlockRequest& request) const 
-{ 
-  if (!request.BucketHasBeenSet()) 
-  { 
-    AWS_LOGSTREAM_ERROR("DeletePublicAccessBlock", "Required field: Bucket, is not set"); 
-    return DeletePublicAccessBlockOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false)); 
-  } 
+DeletePublicAccessBlockOutcome S3Client::DeletePublicAccessBlock(const DeletePublicAccessBlockRequest& request) const
+{
+  if (!request.BucketHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("DeletePublicAccessBlock", "Required field: Bucket, is not set");
+    return DeletePublicAccessBlockOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
+  }
   ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
   if (!computeEndpointOutcome.IsSuccess())
   {
     return DeletePublicAccessBlockOutcome(computeEndpointOutcome.GetError());
   }
   Aws::Http::URI uri = computeEndpointOutcome.GetResult().endpoint;
-  Aws::StringStream ss; 
-  ss.str("?publicAccessBlock"); 
-  uri.SetQueryString(ss.str()); 
+  Aws::StringStream ss;
+  ss.str("?publicAccessBlock");
+  uri.SetQueryString(ss.str());
   return DeletePublicAccessBlockOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_DELETE, Aws::Auth::SIGV4_SIGNER, computeEndpointOutcome.GetResult().signerRegion.c_str() /*signerRegionOverride*/, computeEndpointOutcome.GetResult().signerServiceName.c_str() /*signerServiceNameOverride*/));
-} 
- 
-DeletePublicAccessBlockOutcomeCallable S3Client::DeletePublicAccessBlockCallable(const DeletePublicAccessBlockRequest& request) const 
-{ 
-  auto task = Aws::MakeShared< std::packaged_task< DeletePublicAccessBlockOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeletePublicAccessBlock(request); } ); 
-  auto packagedFunction = [task]() { (*task)(); }; 
-  m_executor->Submit(packagedFunction); 
-  return task->get_future(); 
-} 
- 
-void S3Client::DeletePublicAccessBlockAsync(const DeletePublicAccessBlockRequest& request, const DeletePublicAccessBlockResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const 
-{ 
-  m_executor->Submit( [this, request, handler, context](){ this->DeletePublicAccessBlockAsyncHelper( request, handler, context ); } ); 
-} 
- 
-void S3Client::DeletePublicAccessBlockAsyncHelper(const DeletePublicAccessBlockRequest& request, const DeletePublicAccessBlockResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const 
-{ 
-  handler(this, request, DeletePublicAccessBlock(request), context); 
-} 
- 
+}
+
+DeletePublicAccessBlockOutcomeCallable S3Client::DeletePublicAccessBlockCallable(const DeletePublicAccessBlockRequest& request) const
+{
+  auto task = Aws::MakeShared< std::packaged_task< DeletePublicAccessBlockOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeletePublicAccessBlock(request); } );
+  auto packagedFunction = [task]() { (*task)(); };
+  m_executor->Submit(packagedFunction);
+  return task->get_future();
+}
+
+void S3Client::DeletePublicAccessBlockAsync(const DeletePublicAccessBlockRequest& request, const DeletePublicAccessBlockResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  m_executor->Submit( [this, request, handler, context](){ this->DeletePublicAccessBlockAsyncHelper( request, handler, context ); } );
+}
+
+void S3Client::DeletePublicAccessBlockAsyncHelper(const DeletePublicAccessBlockRequest& request, const DeletePublicAccessBlockResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  handler(this, request, DeletePublicAccessBlock(request), context);
+}
+
 GetBucketAccelerateConfigurationOutcome S3Client::GetBucketAccelerateConfiguration(const GetBucketAccelerateConfigurationRequest& request) const
 {
-  if (!request.BucketHasBeenSet()) 
-  { 
-    AWS_LOGSTREAM_ERROR("GetBucketAccelerateConfiguration", "Required field: Bucket, is not set"); 
-    return GetBucketAccelerateConfigurationOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false)); 
-  } 
+  if (!request.BucketHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("GetBucketAccelerateConfiguration", "Required field: Bucket, is not set");
+    return GetBucketAccelerateConfigurationOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
+  }
   ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
   if (!computeEndpointOutcome.IsSuccess())
   {
@@ -1127,11 +1127,11 @@ void S3Client::GetBucketAccelerateConfigurationAsyncHelper(const GetBucketAccele
 
 GetBucketAclOutcome S3Client::GetBucketAcl(const GetBucketAclRequest& request) const
 {
-  if (!request.BucketHasBeenSet()) 
-  { 
-    AWS_LOGSTREAM_ERROR("GetBucketAcl", "Required field: Bucket, is not set"); 
-    return GetBucketAclOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false)); 
-  } 
+  if (!request.BucketHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("GetBucketAcl", "Required field: Bucket, is not set");
+    return GetBucketAclOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
+  }
   ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
   if (!computeEndpointOutcome.IsSuccess())
   {
@@ -1164,16 +1164,16 @@ void S3Client::GetBucketAclAsyncHelper(const GetBucketAclRequest& request, const
 
 GetBucketAnalyticsConfigurationOutcome S3Client::GetBucketAnalyticsConfiguration(const GetBucketAnalyticsConfigurationRequest& request) const
 {
-  if (!request.BucketHasBeenSet()) 
-  { 
-    AWS_LOGSTREAM_ERROR("GetBucketAnalyticsConfiguration", "Required field: Bucket, is not set"); 
-    return GetBucketAnalyticsConfigurationOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false)); 
-  } 
-  if (!request.IdHasBeenSet()) 
-  { 
-    AWS_LOGSTREAM_ERROR("GetBucketAnalyticsConfiguration", "Required field: Id, is not set"); 
-    return GetBucketAnalyticsConfigurationOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Id]", false)); 
-  } 
+  if (!request.BucketHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("GetBucketAnalyticsConfiguration", "Required field: Bucket, is not set");
+    return GetBucketAnalyticsConfigurationOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
+  }
+  if (!request.IdHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("GetBucketAnalyticsConfiguration", "Required field: Id, is not set");
+    return GetBucketAnalyticsConfigurationOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Id]", false));
+  }
   ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
   if (!computeEndpointOutcome.IsSuccess())
   {
@@ -1206,11 +1206,11 @@ void S3Client::GetBucketAnalyticsConfigurationAsyncHelper(const GetBucketAnalyti
 
 GetBucketCorsOutcome S3Client::GetBucketCors(const GetBucketCorsRequest& request) const
 {
-  if (!request.BucketHasBeenSet()) 
-  { 
-    AWS_LOGSTREAM_ERROR("GetBucketCors", "Required field: Bucket, is not set"); 
-    return GetBucketCorsOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false)); 
-  } 
+  if (!request.BucketHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("GetBucketCors", "Required field: Bucket, is not set");
+    return GetBucketCorsOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
+  }
   ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
   if (!computeEndpointOutcome.IsSuccess())
   {
@@ -1243,11 +1243,11 @@ void S3Client::GetBucketCorsAsyncHelper(const GetBucketCorsRequest& request, con
 
 GetBucketEncryptionOutcome S3Client::GetBucketEncryption(const GetBucketEncryptionRequest& request) const
 {
-  if (!request.BucketHasBeenSet()) 
-  { 
-    AWS_LOGSTREAM_ERROR("GetBucketEncryption", "Required field: Bucket, is not set"); 
-    return GetBucketEncryptionOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false)); 
-  } 
+  if (!request.BucketHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("GetBucketEncryption", "Required field: Bucket, is not set");
+    return GetBucketEncryptionOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
+  }
   ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
   if (!computeEndpointOutcome.IsSuccess())
   {
@@ -1322,16 +1322,16 @@ void S3Client::GetBucketIntelligentTieringConfigurationAsyncHelper(const GetBuck
 
 GetBucketInventoryConfigurationOutcome S3Client::GetBucketInventoryConfiguration(const GetBucketInventoryConfigurationRequest& request) const
 {
-  if (!request.BucketHasBeenSet()) 
-  { 
-    AWS_LOGSTREAM_ERROR("GetBucketInventoryConfiguration", "Required field: Bucket, is not set"); 
-    return GetBucketInventoryConfigurationOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false)); 
-  } 
-  if (!request.IdHasBeenSet()) 
-  { 
-    AWS_LOGSTREAM_ERROR("GetBucketInventoryConfiguration", "Required field: Id, is not set"); 
-    return GetBucketInventoryConfigurationOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Id]", false)); 
-  } 
+  if (!request.BucketHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("GetBucketInventoryConfiguration", "Required field: Bucket, is not set");
+    return GetBucketInventoryConfigurationOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
+  }
+  if (!request.IdHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("GetBucketInventoryConfiguration", "Required field: Id, is not set");
+    return GetBucketInventoryConfigurationOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Id]", false));
+  }
   ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
   if (!computeEndpointOutcome.IsSuccess())
   {
@@ -1364,11 +1364,11 @@ void S3Client::GetBucketInventoryConfigurationAsyncHelper(const GetBucketInvento
 
 GetBucketLifecycleConfigurationOutcome S3Client::GetBucketLifecycleConfiguration(const GetBucketLifecycleConfigurationRequest& request) const
 {
-  if (!request.BucketHasBeenSet()) 
-  { 
-    AWS_LOGSTREAM_ERROR("GetBucketLifecycleConfiguration", "Required field: Bucket, is not set"); 
-    return GetBucketLifecycleConfigurationOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false)); 
-  } 
+  if (!request.BucketHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("GetBucketLifecycleConfiguration", "Required field: Bucket, is not set");
+    return GetBucketLifecycleConfigurationOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
+  }
   ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
   if (!computeEndpointOutcome.IsSuccess())
   {
@@ -1401,11 +1401,11 @@ void S3Client::GetBucketLifecycleConfigurationAsyncHelper(const GetBucketLifecyc
 
 GetBucketLocationOutcome S3Client::GetBucketLocation(const GetBucketLocationRequest& request) const
 {
-  if (!request.BucketHasBeenSet()) 
-  { 
-    AWS_LOGSTREAM_ERROR("GetBucketLocation", "Required field: Bucket, is not set"); 
-    return GetBucketLocationOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false)); 
-  } 
+  if (!request.BucketHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("GetBucketLocation", "Required field: Bucket, is not set");
+    return GetBucketLocationOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
+  }
   ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
   if (!computeEndpointOutcome.IsSuccess())
   {
@@ -1438,11 +1438,11 @@ void S3Client::GetBucketLocationAsyncHelper(const GetBucketLocationRequest& requ
 
 GetBucketLoggingOutcome S3Client::GetBucketLogging(const GetBucketLoggingRequest& request) const
 {
-  if (!request.BucketHasBeenSet()) 
-  { 
-    AWS_LOGSTREAM_ERROR("GetBucketLogging", "Required field: Bucket, is not set"); 
-    return GetBucketLoggingOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false)); 
-  } 
+  if (!request.BucketHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("GetBucketLogging", "Required field: Bucket, is not set");
+    return GetBucketLoggingOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
+  }
   ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
   if (!computeEndpointOutcome.IsSuccess())
   {
@@ -1475,16 +1475,16 @@ void S3Client::GetBucketLoggingAsyncHelper(const GetBucketLoggingRequest& reques
 
 GetBucketMetricsConfigurationOutcome S3Client::GetBucketMetricsConfiguration(const GetBucketMetricsConfigurationRequest& request) const
 {
-  if (!request.BucketHasBeenSet()) 
-  { 
-    AWS_LOGSTREAM_ERROR("GetBucketMetricsConfiguration", "Required field: Bucket, is not set"); 
-    return GetBucketMetricsConfigurationOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false)); 
-  } 
-  if (!request.IdHasBeenSet()) 
-  { 
-    AWS_LOGSTREAM_ERROR("GetBucketMetricsConfiguration", "Required field: Id, is not set"); 
-    return GetBucketMetricsConfigurationOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Id]", false)); 
-  } 
+  if (!request.BucketHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("GetBucketMetricsConfiguration", "Required field: Bucket, is not set");
+    return GetBucketMetricsConfigurationOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
+  }
+  if (!request.IdHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("GetBucketMetricsConfiguration", "Required field: Id, is not set");
+    return GetBucketMetricsConfigurationOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Id]", false));
+  }
   ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
   if (!computeEndpointOutcome.IsSuccess())
   {
@@ -1517,11 +1517,11 @@ void S3Client::GetBucketMetricsConfigurationAsyncHelper(const GetBucketMetricsCo
 
 GetBucketNotificationConfigurationOutcome S3Client::GetBucketNotificationConfiguration(const GetBucketNotificationConfigurationRequest& request) const
 {
-  if (!request.BucketHasBeenSet()) 
-  { 
-    AWS_LOGSTREAM_ERROR("GetBucketNotificationConfiguration", "Required field: Bucket, is not set"); 
-    return GetBucketNotificationConfigurationOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false)); 
-  } 
+  if (!request.BucketHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("GetBucketNotificationConfiguration", "Required field: Bucket, is not set");
+    return GetBucketNotificationConfigurationOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
+  }
   ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
   if (!computeEndpointOutcome.IsSuccess())
   {
@@ -1591,11 +1591,11 @@ void S3Client::GetBucketOwnershipControlsAsyncHelper(const GetBucketOwnershipCon
 
 GetBucketPolicyOutcome S3Client::GetBucketPolicy(const GetBucketPolicyRequest& request) const
 {
-  if (!request.BucketHasBeenSet()) 
-  { 
-    AWS_LOGSTREAM_ERROR("GetBucketPolicy", "Required field: Bucket, is not set"); 
-    return GetBucketPolicyOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false)); 
-  } 
+  if (!request.BucketHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("GetBucketPolicy", "Required field: Bucket, is not set");
+    return GetBucketPolicyOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
+  }
   ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
   if (!computeEndpointOutcome.IsSuccess())
   {
@@ -1626,50 +1626,50 @@ void S3Client::GetBucketPolicyAsyncHelper(const GetBucketPolicyRequest& request,
   handler(this, request, GetBucketPolicy(request), context);
 }
 
-GetBucketPolicyStatusOutcome S3Client::GetBucketPolicyStatus(const GetBucketPolicyStatusRequest& request) const 
-{ 
-  if (!request.BucketHasBeenSet()) 
-  { 
-    AWS_LOGSTREAM_ERROR("GetBucketPolicyStatus", "Required field: Bucket, is not set"); 
-    return GetBucketPolicyStatusOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false)); 
-  } 
+GetBucketPolicyStatusOutcome S3Client::GetBucketPolicyStatus(const GetBucketPolicyStatusRequest& request) const
+{
+  if (!request.BucketHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("GetBucketPolicyStatus", "Required field: Bucket, is not set");
+    return GetBucketPolicyStatusOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
+  }
   ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
   if (!computeEndpointOutcome.IsSuccess())
   {
     return GetBucketPolicyStatusOutcome(computeEndpointOutcome.GetError());
   }
   Aws::Http::URI uri = computeEndpointOutcome.GetResult().endpoint;
-  Aws::StringStream ss; 
-  ss.str("?policyStatus"); 
-  uri.SetQueryString(ss.str()); 
+  Aws::StringStream ss;
+  ss.str("?policyStatus");
+  uri.SetQueryString(ss.str());
   return GetBucketPolicyStatusOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER, computeEndpointOutcome.GetResult().signerRegion.c_str() /*signerRegionOverride*/, computeEndpointOutcome.GetResult().signerServiceName.c_str() /*signerServiceNameOverride*/));
-} 
- 
-GetBucketPolicyStatusOutcomeCallable S3Client::GetBucketPolicyStatusCallable(const GetBucketPolicyStatusRequest& request) const 
-{ 
-  auto task = Aws::MakeShared< std::packaged_task< GetBucketPolicyStatusOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetBucketPolicyStatus(request); } ); 
-  auto packagedFunction = [task]() { (*task)(); }; 
-  m_executor->Submit(packagedFunction); 
-  return task->get_future(); 
-} 
- 
-void S3Client::GetBucketPolicyStatusAsync(const GetBucketPolicyStatusRequest& request, const GetBucketPolicyStatusResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const 
-{ 
-  m_executor->Submit( [this, request, handler, context](){ this->GetBucketPolicyStatusAsyncHelper( request, handler, context ); } ); 
-} 
- 
-void S3Client::GetBucketPolicyStatusAsyncHelper(const GetBucketPolicyStatusRequest& request, const GetBucketPolicyStatusResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const 
-{ 
-  handler(this, request, GetBucketPolicyStatus(request), context); 
-} 
- 
+}
+
+GetBucketPolicyStatusOutcomeCallable S3Client::GetBucketPolicyStatusCallable(const GetBucketPolicyStatusRequest& request) const
+{
+  auto task = Aws::MakeShared< std::packaged_task< GetBucketPolicyStatusOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetBucketPolicyStatus(request); } );
+  auto packagedFunction = [task]() { (*task)(); };
+  m_executor->Submit(packagedFunction);
+  return task->get_future();
+}
+
+void S3Client::GetBucketPolicyStatusAsync(const GetBucketPolicyStatusRequest& request, const GetBucketPolicyStatusResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  m_executor->Submit( [this, request, handler, context](){ this->GetBucketPolicyStatusAsyncHelper( request, handler, context ); } );
+}
+
+void S3Client::GetBucketPolicyStatusAsyncHelper(const GetBucketPolicyStatusRequest& request, const GetBucketPolicyStatusResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  handler(this, request, GetBucketPolicyStatus(request), context);
+}
+
 GetBucketReplicationOutcome S3Client::GetBucketReplication(const GetBucketReplicationRequest& request) const
 {
-  if (!request.BucketHasBeenSet()) 
-  { 
-    AWS_LOGSTREAM_ERROR("GetBucketReplication", "Required field: Bucket, is not set"); 
-    return GetBucketReplicationOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false)); 
-  } 
+  if (!request.BucketHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("GetBucketReplication", "Required field: Bucket, is not set");
+    return GetBucketReplicationOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
+  }
   ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
   if (!computeEndpointOutcome.IsSuccess())
   {
@@ -1702,11 +1702,11 @@ void S3Client::GetBucketReplicationAsyncHelper(const GetBucketReplicationRequest
 
 GetBucketRequestPaymentOutcome S3Client::GetBucketRequestPayment(const GetBucketRequestPaymentRequest& request) const
 {
-  if (!request.BucketHasBeenSet()) 
-  { 
-    AWS_LOGSTREAM_ERROR("GetBucketRequestPayment", "Required field: Bucket, is not set"); 
-    return GetBucketRequestPaymentOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false)); 
-  } 
+  if (!request.BucketHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("GetBucketRequestPayment", "Required field: Bucket, is not set");
+    return GetBucketRequestPaymentOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
+  }
   ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
   if (!computeEndpointOutcome.IsSuccess())
   {
@@ -1739,11 +1739,11 @@ void S3Client::GetBucketRequestPaymentAsyncHelper(const GetBucketRequestPaymentR
 
 GetBucketTaggingOutcome S3Client::GetBucketTagging(const GetBucketTaggingRequest& request) const
 {
-  if (!request.BucketHasBeenSet()) 
-  { 
-    AWS_LOGSTREAM_ERROR("GetBucketTagging", "Required field: Bucket, is not set"); 
-    return GetBucketTaggingOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false)); 
-  } 
+  if (!request.BucketHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("GetBucketTagging", "Required field: Bucket, is not set");
+    return GetBucketTaggingOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
+  }
   ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
   if (!computeEndpointOutcome.IsSuccess())
   {
@@ -1776,11 +1776,11 @@ void S3Client::GetBucketTaggingAsyncHelper(const GetBucketTaggingRequest& reques
 
 GetBucketVersioningOutcome S3Client::GetBucketVersioning(const GetBucketVersioningRequest& request) const
 {
-  if (!request.BucketHasBeenSet()) 
-  { 
-    AWS_LOGSTREAM_ERROR("GetBucketVersioning", "Required field: Bucket, is not set"); 
-    return GetBucketVersioningOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false)); 
-  } 
+  if (!request.BucketHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("GetBucketVersioning", "Required field: Bucket, is not set");
+    return GetBucketVersioningOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
+  }
   ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
   if (!computeEndpointOutcome.IsSuccess())
   {
@@ -1813,11 +1813,11 @@ void S3Client::GetBucketVersioningAsyncHelper(const GetBucketVersioningRequest&
 
 GetBucketWebsiteOutcome S3Client::GetBucketWebsite(const GetBucketWebsiteRequest& request) const
 {
-  if (!request.BucketHasBeenSet()) 
-  { 
-    AWS_LOGSTREAM_ERROR("GetBucketWebsite", "Required field: Bucket, is not set"); 
-    return GetBucketWebsiteOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false)); 
-  } 
+  if (!request.BucketHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("GetBucketWebsite", "Required field: Bucket, is not set");
+    return GetBucketWebsiteOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
+  }
   ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
   if (!computeEndpointOutcome.IsSuccess())
   {
@@ -1850,16 +1850,16 @@ void S3Client::GetBucketWebsiteAsyncHelper(const GetBucketWebsiteRequest& reques
 
 GetObjectOutcome S3Client::GetObject(const GetObjectRequest& request) const
 {
-  if (!request.BucketHasBeenSet()) 
-  { 
-    AWS_LOGSTREAM_ERROR("GetObject", "Required field: Bucket, is not set"); 
-    return GetObjectOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false)); 
-  } 
-  if (!request.KeyHasBeenSet()) 
-  { 
-    AWS_LOGSTREAM_ERROR("GetObject", "Required field: Key, is not set"); 
-    return GetObjectOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Key]", false)); 
-  } 
+  if (!request.BucketHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("GetObject", "Required field: Bucket, is not set");
+    return GetObjectOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
+  }
+  if (!request.KeyHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("GetObject", "Required field: Key, is not set");
+    return GetObjectOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Key]", false));
+  }
   ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
   if (!computeEndpointOutcome.IsSuccess())
   {
@@ -1893,16 +1893,16 @@ void S3Client::GetObjectAsyncHelper(const GetObjectRequest& request, const GetOb
 
 GetObjectAclOutcome S3Client::GetObjectAcl(const GetObjectAclRequest& request) const
 {
-  if (!request.BucketHasBeenSet()) 
-  { 
-    AWS_LOGSTREAM_ERROR("GetObjectAcl", "Required field: Bucket, is not set"); 
-    return GetObjectAclOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false)); 
-  } 
-  if (!request.KeyHasBeenSet()) 
-  { 
-    AWS_LOGSTREAM_ERROR("GetObjectAcl", "Required field: Key, is not set"); 
-    return GetObjectAclOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Key]", false)); 
-  } 
+  if (!request.BucketHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("GetObjectAcl", "Required field: Bucket, is not set");
+    return GetObjectAclOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
+  }
+  if (!request.KeyHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("GetObjectAcl", "Required field: Key, is not set");
+    return GetObjectAclOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Key]", false));
+  }
   ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
   if (!computeEndpointOutcome.IsSuccess())
   {
@@ -1936,18 +1936,18 @@ void S3Client::GetObjectAclAsyncHelper(const GetObjectAclRequest& request, const
   handler(this, request, GetObjectAcl(request), context);
 }
 
-GetObjectLegalHoldOutcome S3Client::GetObjectLegalHold(const GetObjectLegalHoldRequest& request) const 
+GetObjectLegalHoldOutcome S3Client::GetObjectLegalHold(const GetObjectLegalHoldRequest& request) const
 {
-  if (!request.BucketHasBeenSet()) 
-  { 
-    AWS_LOGSTREAM_ERROR("GetObjectLegalHold", "Required field: Bucket, is not set"); 
-    return GetObjectLegalHoldOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false)); 
-  } 
-  if (!request.KeyHasBeenSet()) 
-  { 
-    AWS_LOGSTREAM_ERROR("GetObjectLegalHold", "Required field: Key, is not set"); 
-    return GetObjectLegalHoldOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Key]", false)); 
-  } 
+  if (!request.BucketHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("GetObjectLegalHold", "Required field: Bucket, is not set");
+    return GetObjectLegalHoldOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
+  }
+  if (!request.KeyHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("GetObjectLegalHold", "Required field: Key, is not set");
+    return GetObjectLegalHoldOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Key]", false));
+  }
   ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
   if (!computeEndpointOutcome.IsSuccess())
   {
@@ -1955,136 +1955,136 @@ GetObjectLegalHoldOutcome S3Client::GetObjectLegalHold(const GetObjectLegalHoldR
   }
   Aws::Http::URI uri = computeEndpointOutcome.GetResult().endpoint;
   Aws::StringStream ss;
-  ss << "/"; 
-  ss << request.GetKey(); 
-  uri.SetPath(uri.GetPath() + ss.str()); 
-  ss.str("?legal-hold"); 
-  uri.SetQueryString(ss.str()); 
+  ss << "/";
+  ss << request.GetKey();
+  uri.SetPath(uri.GetPath() + ss.str());
+  ss.str("?legal-hold");
+  uri.SetQueryString(ss.str());
   return GetObjectLegalHoldOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER, computeEndpointOutcome.GetResult().signerRegion.c_str() /*signerRegionOverride*/, computeEndpointOutcome.GetResult().signerServiceName.c_str() /*signerServiceNameOverride*/));
-} 
- 
-GetObjectLegalHoldOutcomeCallable S3Client::GetObjectLegalHoldCallable(const GetObjectLegalHoldRequest& request) const 
-{ 
-  auto task = Aws::MakeShared< std::packaged_task< GetObjectLegalHoldOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetObjectLegalHold(request); } ); 
-  auto packagedFunction = [task]() { (*task)(); }; 
-  m_executor->Submit(packagedFunction); 
-  return task->get_future(); 
-} 
- 
-void S3Client::GetObjectLegalHoldAsync(const GetObjectLegalHoldRequest& request, const GetObjectLegalHoldResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const 
-{ 
-  m_executor->Submit( [this, request, handler, context](){ this->GetObjectLegalHoldAsyncHelper( request, handler, context ); } ); 
-} 
- 
-void S3Client::GetObjectLegalHoldAsyncHelper(const GetObjectLegalHoldRequest& request, const GetObjectLegalHoldResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const 
-{ 
-  handler(this, request, GetObjectLegalHold(request), context); 
-} 
- 
-GetObjectLockConfigurationOutcome S3Client::GetObjectLockConfiguration(const GetObjectLockConfigurationRequest& request) const 
-{ 
-  if (!request.BucketHasBeenSet()) 
-  { 
-    AWS_LOGSTREAM_ERROR("GetObjectLockConfiguration", "Required field: Bucket, is not set"); 
-    return GetObjectLockConfigurationOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false)); 
-  } 
+}
+
+GetObjectLegalHoldOutcomeCallable S3Client::GetObjectLegalHoldCallable(const GetObjectLegalHoldRequest& request) const
+{
+  auto task = Aws::MakeShared< std::packaged_task< GetObjectLegalHoldOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetObjectLegalHold(request); } );
+  auto packagedFunction = [task]() { (*task)(); };
+  m_executor->Submit(packagedFunction);
+  return task->get_future();
+}
+
+void S3Client::GetObjectLegalHoldAsync(const GetObjectLegalHoldRequest& request, const GetObjectLegalHoldResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  m_executor->Submit( [this, request, handler, context](){ this->GetObjectLegalHoldAsyncHelper( request, handler, context ); } );
+}
+
+void S3Client::GetObjectLegalHoldAsyncHelper(const GetObjectLegalHoldRequest& request, const GetObjectLegalHoldResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  handler(this, request, GetObjectLegalHold(request), context);
+}
+
+GetObjectLockConfigurationOutcome S3Client::GetObjectLockConfiguration(const GetObjectLockConfigurationRequest& request) const
+{
+  if (!request.BucketHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("GetObjectLockConfiguration", "Required field: Bucket, is not set");
+    return GetObjectLockConfigurationOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
+  }
   ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
   if (!computeEndpointOutcome.IsSuccess())
   {
     return GetObjectLockConfigurationOutcome(computeEndpointOutcome.GetError());
   }
   Aws::Http::URI uri = computeEndpointOutcome.GetResult().endpoint;
-  Aws::StringStream ss; 
-  ss.str("?object-lock"); 
-  uri.SetQueryString(ss.str()); 
+  Aws::StringStream ss;
+  ss.str("?object-lock");
+  uri.SetQueryString(ss.str());
   return GetObjectLockConfigurationOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER, computeEndpointOutcome.GetResult().signerRegion.c_str() /*signerRegionOverride*/, computeEndpointOutcome.GetResult().signerServiceName.c_str() /*signerServiceNameOverride*/));
-} 
- 
-GetObjectLockConfigurationOutcomeCallable S3Client::GetObjectLockConfigurationCallable(const GetObjectLockConfigurationRequest& request) const 
-{ 
-  auto task = Aws::MakeShared< std::packaged_task< GetObjectLockConfigurationOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetObjectLockConfiguration(request); } ); 
-  auto packagedFunction = [task]() { (*task)(); }; 
-  m_executor->Submit(packagedFunction); 
-  return task->get_future(); 
-} 
- 
-void S3Client::GetObjectLockConfigurationAsync(const GetObjectLockConfigurationRequest& request, const GetObjectLockConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const 
-{ 
-  m_executor->Submit( [this, request, handler, context](){ this->GetObjectLockConfigurationAsyncHelper( request, handler, context ); } ); 
-} 
- 
-void S3Client::GetObjectLockConfigurationAsyncHelper(const GetObjectLockConfigurationRequest& request, const GetObjectLockConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const 
-{ 
-  handler(this, request, GetObjectLockConfiguration(request), context); 
-} 
- 
-GetObjectRetentionOutcome S3Client::GetObjectRetention(const GetObjectRetentionRequest& request) const 
-{ 
-  if (!request.BucketHasBeenSet()) 
-  { 
-    AWS_LOGSTREAM_ERROR("GetObjectRetention", "Required field: Bucket, is not set"); 
-    return GetObjectRetentionOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false)); 
-  } 
-  if (!request.KeyHasBeenSet()) 
-  { 
-    AWS_LOGSTREAM_ERROR("GetObjectRetention", "Required field: Key, is not set"); 
-    return GetObjectRetentionOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Key]", false)); 
-  } 
+}
+
+GetObjectLockConfigurationOutcomeCallable S3Client::GetObjectLockConfigurationCallable(const GetObjectLockConfigurationRequest& request) const
+{
+  auto task = Aws::MakeShared< std::packaged_task< GetObjectLockConfigurationOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetObjectLockConfiguration(request); } );
+  auto packagedFunction = [task]() { (*task)(); };
+  m_executor->Submit(packagedFunction);
+  return task->get_future();
+}
+
+void S3Client::GetObjectLockConfigurationAsync(const GetObjectLockConfigurationRequest& request, const GetObjectLockConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  m_executor->Submit( [this, request, handler, context](){ this->GetObjectLockConfigurationAsyncHelper( request, handler, context ); } );
+}
+
+void S3Client::GetObjectLockConfigurationAsyncHelper(const GetObjectLockConfigurationRequest& request, const GetObjectLockConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  handler(this, request, GetObjectLockConfiguration(request), context);
+}
+
+GetObjectRetentionOutcome S3Client::GetObjectRetention(const GetObjectRetentionRequest& request) const
+{
+  if (!request.BucketHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("GetObjectRetention", "Required field: Bucket, is not set");
+    return GetObjectRetentionOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
+  }
+  if (!request.KeyHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("GetObjectRetention", "Required field: Key, is not set");
+    return GetObjectRetentionOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Key]", false));
+  }
   ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
   if (!computeEndpointOutcome.IsSuccess())
   {
     return GetObjectRetentionOutcome(computeEndpointOutcome.GetError());
   }
   Aws::Http::URI uri = computeEndpointOutcome.GetResult().endpoint;
-  Aws::StringStream ss; 
+  Aws::StringStream ss;
   ss << "/";
   ss << request.GetKey();
   uri.SetPath(uri.GetPath() + ss.str());
-  ss.str("?retention"); 
-  uri.SetQueryString(ss.str()); 
+  ss.str("?retention");
+  uri.SetQueryString(ss.str());
   return GetObjectRetentionOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER, computeEndpointOutcome.GetResult().signerRegion.c_str() /*signerRegionOverride*/, computeEndpointOutcome.GetResult().signerServiceName.c_str() /*signerServiceNameOverride*/));
-} 
- 
-GetObjectRetentionOutcomeCallable S3Client::GetObjectRetentionCallable(const GetObjectRetentionRequest& request) const 
-{ 
-  auto task = Aws::MakeShared< std::packaged_task< GetObjectRetentionOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetObjectRetention(request); } ); 
-  auto packagedFunction = [task]() { (*task)(); }; 
-  m_executor->Submit(packagedFunction); 
-  return task->get_future(); 
-} 
- 
-void S3Client::GetObjectRetentionAsync(const GetObjectRetentionRequest& request, const GetObjectRetentionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const 
-{ 
-  m_executor->Submit( [this, request, handler, context](){ this->GetObjectRetentionAsyncHelper( request, handler, context ); } ); 
-} 
- 
-void S3Client::GetObjectRetentionAsyncHelper(const GetObjectRetentionRequest& request, const GetObjectRetentionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const 
-{ 
-  handler(this, request, GetObjectRetention(request), context); 
-} 
- 
-GetObjectTaggingOutcome S3Client::GetObjectTagging(const GetObjectTaggingRequest& request) const 
-{ 
-  if (!request.BucketHasBeenSet()) 
-  { 
-    AWS_LOGSTREAM_ERROR("GetObjectTagging", "Required field: Bucket, is not set"); 
-    return GetObjectTaggingOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false)); 
-  } 
-  if (!request.KeyHasBeenSet()) 
-  { 
-    AWS_LOGSTREAM_ERROR("GetObjectTagging", "Required field: Key, is not set"); 
-    return GetObjectTaggingOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Key]", false)); 
-  } 
+}
+
+GetObjectRetentionOutcomeCallable S3Client::GetObjectRetentionCallable(const GetObjectRetentionRequest& request) const
+{
+  auto task = Aws::MakeShared< std::packaged_task< GetObjectRetentionOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetObjectRetention(request); } );
+  auto packagedFunction = [task]() { (*task)(); };
+  m_executor->Submit(packagedFunction);
+  return task->get_future();
+}
+
+void S3Client::GetObjectRetentionAsync(const GetObjectRetentionRequest& request, const GetObjectRetentionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  m_executor->Submit( [this, request, handler, context](){ this->GetObjectRetentionAsyncHelper( request, handler, context ); } );
+}
+
+void S3Client::GetObjectRetentionAsyncHelper(const GetObjectRetentionRequest& request, const GetObjectRetentionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  handler(this, request, GetObjectRetention(request), context);
+}
+
+GetObjectTaggingOutcome S3Client::GetObjectTagging(const GetObjectTaggingRequest& request) const
+{
+  if (!request.BucketHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("GetObjectTagging", "Required field: Bucket, is not set");
+    return GetObjectTaggingOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
+  }
+  if (!request.KeyHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("GetObjectTagging", "Required field: Key, is not set");
+    return GetObjectTaggingOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Key]", false));
+  }
   ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
   if (!computeEndpointOutcome.IsSuccess())
   {
     return GetObjectTaggingOutcome(computeEndpointOutcome.GetError());
   }
   Aws::Http::URI uri = computeEndpointOutcome.GetResult().endpoint;
-  Aws::StringStream ss; 
-  ss << "/"; 
-  ss << request.GetKey(); 
-  uri.SetPath(uri.GetPath() + ss.str()); 
+  Aws::StringStream ss;
+  ss << "/";
+  ss << request.GetKey();
+  uri.SetPath(uri.GetPath() + ss.str());
   ss.str("?tagging");
   uri.SetQueryString(ss.str());
   return GetObjectTaggingOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER, computeEndpointOutcome.GetResult().signerRegion.c_str() /*signerRegionOverride*/, computeEndpointOutcome.GetResult().signerServiceName.c_str() /*signerServiceNameOverride*/));
@@ -2110,16 +2110,16 @@ void S3Client::GetObjectTaggingAsyncHelper(const GetObjectTaggingRequest& reques
 
 GetObjectTorrentOutcome S3Client::GetObjectTorrent(const GetObjectTorrentRequest& request) const
 {
-  if (!request.BucketHasBeenSet()) 
-  { 
-    AWS_LOGSTREAM_ERROR("GetObjectTorrent", "Required field: Bucket, is not set"); 
-    return GetObjectTorrentOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false)); 
-  } 
-  if (!request.KeyHasBeenSet()) 
-  { 
-    AWS_LOGSTREAM_ERROR("GetObjectTorrent", "Required field: Key, is not set"); 
-    return GetObjectTorrentOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Key]", false)); 
-  } 
+  if (!request.BucketHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("GetObjectTorrent", "Required field: Bucket, is not set");
+    return GetObjectTorrentOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
+  }
+  if (!request.KeyHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("GetObjectTorrent", "Required field: Key, is not set");
+    return GetObjectTorrentOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Key]", false));
+  }
   ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
   if (!computeEndpointOutcome.IsSuccess())
   {
@@ -2153,50 +2153,50 @@ void S3Client::GetObjectTorrentAsyncHelper(const GetObjectTorrentRequest& reques
   handler(this, request, GetObjectTorrent(request), context);
 }
 
-GetPublicAccessBlockOutcome S3Client::GetPublicAccessBlock(const GetPublicAccessBlockRequest& request) const 
-{ 
-  if (!request.BucketHasBeenSet()) 
-  { 
-    AWS_LOGSTREAM_ERROR("GetPublicAccessBlock", "Required field: Bucket, is not set"); 
-    return GetPublicAccessBlockOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false)); 
-  } 
+GetPublicAccessBlockOutcome S3Client::GetPublicAccessBlock(const GetPublicAccessBlockRequest& request) const
+{
+  if (!request.BucketHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("GetPublicAccessBlock", "Required field: Bucket, is not set");
+    return GetPublicAccessBlockOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
+  }
   ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
   if (!computeEndpointOutcome.IsSuccess())
   {
     return GetPublicAccessBlockOutcome(computeEndpointOutcome.GetError());
   }
   Aws::Http::URI uri = computeEndpointOutcome.GetResult().endpoint;
-  Aws::StringStream ss; 
-  ss.str("?publicAccessBlock"); 
-  uri.SetQueryString(ss.str()); 
+  Aws::StringStream ss;
+  ss.str("?publicAccessBlock");
+  uri.SetQueryString(ss.str());
   return GetPublicAccessBlockOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER, computeEndpointOutcome.GetResult().signerRegion.c_str() /*signerRegionOverride*/, computeEndpointOutcome.GetResult().signerServiceName.c_str() /*signerServiceNameOverride*/));
-} 
- 
-GetPublicAccessBlockOutcomeCallable S3Client::GetPublicAccessBlockCallable(const GetPublicAccessBlockRequest& request) const 
-{ 
-  auto task = Aws::MakeShared< std::packaged_task< GetPublicAccessBlockOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetPublicAccessBlock(request); } ); 
-  auto packagedFunction = [task]() { (*task)(); }; 
-  m_executor->Submit(packagedFunction); 
-  return task->get_future(); 
-} 
- 
-void S3Client::GetPublicAccessBlockAsync(const GetPublicAccessBlockRequest& request, const GetPublicAccessBlockResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const 
-{ 
-  m_executor->Submit( [this, request, handler, context](){ this->GetPublicAccessBlockAsyncHelper( request, handler, context ); } ); 
-} 
- 
-void S3Client::GetPublicAccessBlockAsyncHelper(const GetPublicAccessBlockRequest& request, const GetPublicAccessBlockResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const 
-{ 
-  handler(this, request, GetPublicAccessBlock(request), context); 
-} 
- 
+}
+
+GetPublicAccessBlockOutcomeCallable S3Client::GetPublicAccessBlockCallable(const GetPublicAccessBlockRequest& request) const
+{
+  auto task = Aws::MakeShared< std::packaged_task< GetPublicAccessBlockOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetPublicAccessBlock(request); } );
+  auto packagedFunction = [task]() { (*task)(); };
+  m_executor->Submit(packagedFunction);
+  return task->get_future();
+}
+
+void S3Client::GetPublicAccessBlockAsync(const GetPublicAccessBlockRequest& request, const GetPublicAccessBlockResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  m_executor->Submit( [this, request, handler, context](){ this->GetPublicAccessBlockAsyncHelper( request, handler, context ); } );
+}
+
+void S3Client::GetPublicAccessBlockAsyncHelper(const GetPublicAccessBlockRequest& request, const GetPublicAccessBlockResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  handler(this, request, GetPublicAccessBlock(request), context);
+}
+
 HeadBucketOutcome S3Client::HeadBucket(const HeadBucketRequest& request) const
 {
-  if (!request.BucketHasBeenSet()) 
-  { 
-    AWS_LOGSTREAM_ERROR("HeadBucket", "Required field: Bucket, is not set"); 
-    return HeadBucketOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false)); 
-  } 
+  if (!request.BucketHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("HeadBucket", "Required field: Bucket, is not set");
+    return HeadBucketOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
+  }
   ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
   if (!computeEndpointOutcome.IsSuccess())
   {
@@ -2228,16 +2228,16 @@ void S3Client::HeadBucketAsyncHelper(const HeadBucketRequest& request, const Hea
 
 HeadObjectOutcome S3Client::HeadObject(const HeadObjectRequest& request) const
 {
-  if (!request.BucketHasBeenSet()) 
-  { 
-    AWS_LOGSTREAM_ERROR("HeadObject", "Required field: Bucket, is not set"); 
-    return HeadObjectOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false)); 
-  } 
-  if (!request.KeyHasBeenSet()) 
-  { 
-    AWS_LOGSTREAM_ERROR("HeadObject", "Required field: Key, is not set"); 
-    return HeadObjectOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Key]", false)); 
-  } 
+  if (!request.BucketHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("HeadObject", "Required field: Bucket, is not set");
+    return HeadObjectOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
+  }
+  if (!request.KeyHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("HeadObject", "Required field: Key, is not set");
+    return HeadObjectOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Key]", false));
+  }
   ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
   if (!computeEndpointOutcome.IsSuccess())
   {
@@ -2271,11 +2271,11 @@ void S3Client::HeadObjectAsyncHelper(const HeadObjectRequest& request, const Hea
 
 ListBucketAnalyticsConfigurationsOutcome S3Client::ListBucketAnalyticsConfigurations(const ListBucketAnalyticsConfigurationsRequest& request) const
 {
-  if (!request.BucketHasBeenSet()) 
-  { 
-    AWS_LOGSTREAM_ERROR("ListBucketAnalyticsConfigurations", "Required field: Bucket, is not set"); 
-    return ListBucketAnalyticsConfigurationsOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false)); 
-  } 
+  if (!request.BucketHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("ListBucketAnalyticsConfigurations", "Required field: Bucket, is not set");
+    return ListBucketAnalyticsConfigurationsOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
+  }
   ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
   if (!computeEndpointOutcome.IsSuccess())
   {
@@ -2345,11 +2345,11 @@ void S3Client::ListBucketIntelligentTieringConfigurationsAsyncHelper(const ListB
 
 ListBucketInventoryConfigurationsOutcome S3Client::ListBucketInventoryConfigurations(const ListBucketInventoryConfigurationsRequest& request) const
 {
-  if (!request.BucketHasBeenSet()) 
-  { 
-    AWS_LOGSTREAM_ERROR("ListBucketInventoryConfigurations", "Required field: Bucket, is not set"); 
-    return ListBucketInventoryConfigurationsOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false)); 
-  } 
+  if (!request.BucketHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("ListBucketInventoryConfigurations", "Required field: Bucket, is not set");
+    return ListBucketInventoryConfigurationsOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
+  }
   ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
   if (!computeEndpointOutcome.IsSuccess())
   {
@@ -2382,11 +2382,11 @@ void S3Client::ListBucketInventoryConfigurationsAsyncHelper(const ListBucketInve
 
 ListBucketMetricsConfigurationsOutcome S3Client::ListBucketMetricsConfigurations(const ListBucketMetricsConfigurationsRequest& request) const
 {
-  if (!request.BucketHasBeenSet()) 
-  { 
-    AWS_LOGSTREAM_ERROR("ListBucketMetricsConfigurations", "Required field: Bucket, is not set"); 
-    return ListBucketMetricsConfigurationsOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false)); 
-  } 
+  if (!request.BucketHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("ListBucketMetricsConfigurations", "Required field: Bucket, is not set");
+    return ListBucketMetricsConfigurationsOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
+  }
   ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
   if (!computeEndpointOutcome.IsSuccess())
   {
@@ -2449,11 +2449,11 @@ void S3Client::ListBucketsAsyncHelper(const ListBucketsResponseReceivedHandler&
 
 ListMultipartUploadsOutcome S3Client::ListMultipartUploads(const ListMultipartUploadsRequest& request) const
 {
-  if (!request.BucketHasBeenSet()) 
-  { 
-    AWS_LOGSTREAM_ERROR("ListMultipartUploads", "Required field: Bucket, is not set"); 
-    return ListMultipartUploadsOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false)); 
-  } 
+  if (!request.BucketHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("ListMultipartUploads", "Required field: Bucket, is not set");
+    return ListMultipartUploadsOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
+  }
   ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
   if (!computeEndpointOutcome.IsSuccess())
   {
@@ -2486,11 +2486,11 @@ void S3Client::ListMultipartUploadsAsyncHelper(const ListMultipartUploadsRequest
 
 ListObjectVersionsOutcome S3Client::ListObjectVersions(const ListObjectVersionsRequest& request) const
 {
-  if (!request.BucketHasBeenSet()) 
-  { 
-    AWS_LOGSTREAM_ERROR("ListObjectVersions", "Required field: Bucket, is not set"); 
-    return ListObjectVersionsOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false)); 
-  } 
+  if (!request.BucketHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("ListObjectVersions", "Required field: Bucket, is not set");
+    return ListObjectVersionsOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
+  }
   ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
   if (!computeEndpointOutcome.IsSuccess())
   {
@@ -2523,11 +2523,11 @@ void S3Client::ListObjectVersionsAsyncHelper(const ListObjectVersionsRequest& re
 
 ListObjectsOutcome S3Client::ListObjects(const ListObjectsRequest& request) const
 {
-  if (!request.BucketHasBeenSet()) 
-  { 
-    AWS_LOGSTREAM_ERROR("ListObjects", "Required field: Bucket, is not set"); 
-    return ListObjectsOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false)); 
-  } 
+  if (!request.BucketHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("ListObjects", "Required field: Bucket, is not set");
+    return ListObjectsOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
+  }
   ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
   if (!computeEndpointOutcome.IsSuccess())
   {
@@ -2559,11 +2559,11 @@ void S3Client::ListObjectsAsyncHelper(const ListObjectsRequest& request, const L
 
 ListObjectsV2Outcome S3Client::ListObjectsV2(const ListObjectsV2Request& request) const
 {
-  if (!request.BucketHasBeenSet()) 
-  { 
-    AWS_LOGSTREAM_ERROR("ListObjectsV2", "Required field: Bucket, is not set"); 
-    return ListObjectsV2Outcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false)); 
-  } 
+  if (!request.BucketHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("ListObjectsV2", "Required field: Bucket, is not set");
+    return ListObjectsV2Outcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
+  }
   ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
   if (!computeEndpointOutcome.IsSuccess())
   {
@@ -2596,21 +2596,21 @@ void S3Client::ListObjectsV2AsyncHelper(const ListObjectsV2Request& request, con
 
 ListPartsOutcome S3Client::ListParts(const ListPartsRequest& request) const
 {
-  if (!request.BucketHasBeenSet()) 
-  { 
-    AWS_LOGSTREAM_ERROR("ListParts", "Required field: Bucket, is not set"); 
-    return ListPartsOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false)); 
-  } 
-  if (!request.KeyHasBeenSet()) 
-  { 
-    AWS_LOGSTREAM_ERROR("ListParts", "Required field: Key, is not set"); 
-    return ListPartsOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Key]", false)); 
-  } 
-  if (!request.UploadIdHasBeenSet()) 
-  { 
-    AWS_LOGSTREAM_ERROR("ListParts", "Required field: UploadId, is not set"); 
-    return ListPartsOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [UploadId]", false)); 
-  } 
+  if (!request.BucketHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("ListParts", "Required field: Bucket, is not set");
+    return ListPartsOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
+  }
+  if (!request.KeyHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("ListParts", "Required field: Key, is not set");
+    return ListPartsOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Key]", false));
+  }
+  if (!request.UploadIdHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("ListParts", "Required field: UploadId, is not set");
+    return ListPartsOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [UploadId]", false));
+  }
   ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
   if (!computeEndpointOutcome.IsSuccess())
   {
@@ -2644,11 +2644,11 @@ void S3Client::ListPartsAsyncHelper(const ListPartsRequest& request, const ListP
 
 PutBucketAccelerateConfigurationOutcome S3Client::PutBucketAccelerateConfiguration(const PutBucketAccelerateConfigurationRequest& request) const
 {
-  if (!request.BucketHasBeenSet()) 
-  { 
-    AWS_LOGSTREAM_ERROR("PutBucketAccelerateConfiguration", "Required field: Bucket, is not set"); 
-    return PutBucketAccelerateConfigurationOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false)); 
-  } 
+  if (!request.BucketHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("PutBucketAccelerateConfiguration", "Required field: Bucket, is not set");
+    return PutBucketAccelerateConfigurationOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
+  }
   ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
   if (!computeEndpointOutcome.IsSuccess())
   {
@@ -2681,11 +2681,11 @@ void S3Client::PutBucketAccelerateConfigurationAsyncHelper(const PutBucketAccele
 
 PutBucketAclOutcome S3Client::PutBucketAcl(const PutBucketAclRequest& request) const
 {
-  if (!request.BucketHasBeenSet()) 
-  { 
-    AWS_LOGSTREAM_ERROR("PutBucketAcl", "Required field: Bucket, is not set"); 
-    return PutBucketAclOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false)); 
-  } 
+  if (!request.BucketHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("PutBucketAcl", "Required field: Bucket, is not set");
+    return PutBucketAclOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
+  }
   ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
   if (!computeEndpointOutcome.IsSuccess())
   {
@@ -2718,16 +2718,16 @@ void S3Client::PutBucketAclAsyncHelper(const PutBucketAclRequest& request, const
 
 PutBucketAnalyticsConfigurationOutcome S3Client::PutBucketAnalyticsConfiguration(const PutBucketAnalyticsConfigurationRequest& request) const
 {
-  if (!request.BucketHasBeenSet()) 
-  { 
-    AWS_LOGSTREAM_ERROR("PutBucketAnalyticsConfiguration", "Required field: Bucket, is not set"); 
-    return PutBucketAnalyticsConfigurationOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false)); 
-  } 
-  if (!request.IdHasBeenSet()) 
-  { 
-    AWS_LOGSTREAM_ERROR("PutBucketAnalyticsConfiguration", "Required field: Id, is not set"); 
-    return PutBucketAnalyticsConfigurationOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Id]", false)); 
-  } 
+  if (!request.BucketHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("PutBucketAnalyticsConfiguration", "Required field: Bucket, is not set");
+    return PutBucketAnalyticsConfigurationOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
+  }
+  if (!request.IdHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("PutBucketAnalyticsConfiguration", "Required field: Id, is not set");
+    return PutBucketAnalyticsConfigurationOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Id]", false));
+  }
   ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
   if (!computeEndpointOutcome.IsSuccess())
   {
@@ -2760,11 +2760,11 @@ void S3Client::PutBucketAnalyticsConfigurationAsyncHelper(const PutBucketAnalyti
 
 PutBucketCorsOutcome S3Client::PutBucketCors(const PutBucketCorsRequest& request) const
 {
-  if (!request.BucketHasBeenSet()) 
-  { 
-    AWS_LOGSTREAM_ERROR("PutBucketCors", "Required field: Bucket, is not set"); 
-    return PutBucketCorsOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false)); 
-  } 
+  if (!request.BucketHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("PutBucketCors", "Required field: Bucket, is not set");
+    return PutBucketCorsOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
+  }
   ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
   if (!computeEndpointOutcome.IsSuccess())
   {
@@ -2797,11 +2797,11 @@ void S3Client::PutBucketCorsAsyncHelper(const PutBucketCorsRequest& request, con
 
 PutBucketEncryptionOutcome S3Client::PutBucketEncryption(const PutBucketEncryptionRequest& request) const
 {
-  if (!request.BucketHasBeenSet()) 
-  { 
-    AWS_LOGSTREAM_ERROR("PutBucketEncryption", "Required field: Bucket, is not set"); 
-    return PutBucketEncryptionOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false)); 
-  } 
+  if (!request.BucketHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("PutBucketEncryption", "Required field: Bucket, is not set");
+    return PutBucketEncryptionOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
+  }
   ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
   if (!computeEndpointOutcome.IsSuccess())
   {
@@ -2876,16 +2876,16 @@ void S3Client::PutBucketIntelligentTieringConfigurationAsyncHelper(const PutBuck
 
 PutBucketInventoryConfigurationOutcome S3Client::PutBucketInventoryConfiguration(const PutBucketInventoryConfigurationRequest& request) const
 {
-  if (!request.BucketHasBeenSet()) 
-  { 
-    AWS_LOGSTREAM_ERROR("PutBucketInventoryConfiguration", "Required field: Bucket, is not set"); 
-    return PutBucketInventoryConfigurationOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false)); 
-  } 
-  if (!request.IdHasBeenSet()) 
-  { 
-    AWS_LOGSTREAM_ERROR("PutBucketInventoryConfiguration", "Required field: Id, is not set"); 
-    return PutBucketInventoryConfigurationOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Id]", false)); 
-  } 
+  if (!request.BucketHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("PutBucketInventoryConfiguration", "Required field: Bucket, is not set");
+    return PutBucketInventoryConfigurationOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
+  }
+  if (!request.IdHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("PutBucketInventoryConfiguration", "Required field: Id, is not set");
+    return PutBucketInventoryConfigurationOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Id]", false));
+  }
   ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
   if (!computeEndpointOutcome.IsSuccess())
   {
@@ -2918,11 +2918,11 @@ void S3Client::PutBucketInventoryConfigurationAsyncHelper(const PutBucketInvento
 
 PutBucketLifecycleConfigurationOutcome S3Client::PutBucketLifecycleConfiguration(const PutBucketLifecycleConfigurationRequest& request) const
 {
-  if (!request.BucketHasBeenSet()) 
-  { 
-    AWS_LOGSTREAM_ERROR("PutBucketLifecycleConfiguration", "Required field: Bucket, is not set"); 
-    return PutBucketLifecycleConfigurationOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false)); 
-  } 
+  if (!request.BucketHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("PutBucketLifecycleConfiguration", "Required field: Bucket, is not set");
+    return PutBucketLifecycleConfigurationOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
+  }
   ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
   if (!computeEndpointOutcome.IsSuccess())
   {
@@ -2955,11 +2955,11 @@ void S3Client::PutBucketLifecycleConfigurationAsyncHelper(const PutBucketLifecyc
 
 PutBucketLoggingOutcome S3Client::PutBucketLogging(const PutBucketLoggingRequest& request) const
 {
-  if (!request.BucketHasBeenSet()) 
-  { 
-    AWS_LOGSTREAM_ERROR("PutBucketLogging", "Required field: Bucket, is not set"); 
-    return PutBucketLoggingOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false)); 
-  } 
+  if (!request.BucketHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("PutBucketLogging", "Required field: Bucket, is not set");
+    return PutBucketLoggingOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
+  }
   ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
   if (!computeEndpointOutcome.IsSuccess())
   {
@@ -2992,16 +2992,16 @@ void S3Client::PutBucketLoggingAsyncHelper(const PutBucketLoggingRequest& reques
 
 PutBucketMetricsConfigurationOutcome S3Client::PutBucketMetricsConfiguration(const PutBucketMetricsConfigurationRequest& request) const
 {
-  if (!request.BucketHasBeenSet()) 
-  { 
-    AWS_LOGSTREAM_ERROR("PutBucketMetricsConfiguration", "Required field: Bucket, is not set"); 
-    return PutBucketMetricsConfigurationOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false)); 
-  } 
-  if (!request.IdHasBeenSet()) 
-  { 
-    AWS_LOGSTREAM_ERROR("PutBucketMetricsConfiguration", "Required field: Id, is not set"); 
-    return PutBucketMetricsConfigurationOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Id]", false)); 
-  } 
+  if (!request.BucketHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("PutBucketMetricsConfiguration", "Required field: Bucket, is not set");
+    return PutBucketMetricsConfigurationOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
+  }
+  if (!request.IdHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("PutBucketMetricsConfiguration", "Required field: Id, is not set");
+    return PutBucketMetricsConfigurationOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Id]", false));
+  }
   ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
   if (!computeEndpointOutcome.IsSuccess())
   {
@@ -3034,11 +3034,11 @@ void S3Client::PutBucketMetricsConfigurationAsyncHelper(const PutBucketMetricsCo
 
 PutBucketNotificationConfigurationOutcome S3Client::PutBucketNotificationConfiguration(const PutBucketNotificationConfigurationRequest& request) const
 {
-  if (!request.BucketHasBeenSet()) 
-  { 
-    AWS_LOGSTREAM_ERROR("PutBucketNotificationConfiguration", "Required field: Bucket, is not set"); 
-    return PutBucketNotificationConfigurationOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false)); 
-  } 
+  if (!request.BucketHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("PutBucketNotificationConfiguration", "Required field: Bucket, is not set");
+    return PutBucketNotificationConfigurationOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
+  }
   ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
   if (!computeEndpointOutcome.IsSuccess())
   {
@@ -3108,11 +3108,11 @@ void S3Client::PutBucketOwnershipControlsAsyncHelper(const PutBucketOwnershipCon
 
 PutBucketPolicyOutcome S3Client::PutBucketPolicy(const PutBucketPolicyRequest& request) const
 {
-  if (!request.BucketHasBeenSet()) 
-  { 
-    AWS_LOGSTREAM_ERROR("PutBucketPolicy", "Required field: Bucket, is not set"); 
-    return PutBucketPolicyOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false)); 
-  } 
+  if (!request.BucketHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("PutBucketPolicy", "Required field: Bucket, is not set");
+    return PutBucketPolicyOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
+  }
   ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
   if (!computeEndpointOutcome.IsSuccess())
   {
@@ -3145,11 +3145,11 @@ void S3Client::PutBucketPolicyAsyncHelper(const PutBucketPolicyRequest& request,
 
 PutBucketReplicationOutcome S3Client::PutBucketReplication(const PutBucketReplicationRequest& request) const
 {
-  if (!request.BucketHasBeenSet()) 
-  { 
-    AWS_LOGSTREAM_ERROR("PutBucketReplication", "Required field: Bucket, is not set"); 
-    return PutBucketReplicationOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false)); 
-  } 
+  if (!request.BucketHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("PutBucketReplication", "Required field: Bucket, is not set");
+    return PutBucketReplicationOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
+  }
   ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
   if (!computeEndpointOutcome.IsSuccess())
   {
@@ -3182,11 +3182,11 @@ void S3Client::PutBucketReplicationAsyncHelper(const PutBucketReplicationRequest
 
 PutBucketRequestPaymentOutcome S3Client::PutBucketRequestPayment(const PutBucketRequestPaymentRequest& request) const
 {
-  if (!request.BucketHasBeenSet()) 
-  { 
-    AWS_LOGSTREAM_ERROR("PutBucketRequestPayment", "Required field: Bucket, is not set"); 
-    return PutBucketRequestPaymentOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false)); 
-  } 
+  if (!request.BucketHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("PutBucketRequestPayment", "Required field: Bucket, is not set");
+    return PutBucketRequestPaymentOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
+  }
   ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
   if (!computeEndpointOutcome.IsSuccess())
   {
@@ -3219,11 +3219,11 @@ void S3Client::PutBucketRequestPaymentAsyncHelper(const PutBucketRequestPaymentR
 
 PutBucketTaggingOutcome S3Client::PutBucketTagging(const PutBucketTaggingRequest& request) const
 {
-  if (!request.BucketHasBeenSet()) 
-  { 
-    AWS_LOGSTREAM_ERROR("PutBucketTagging", "Required field: Bucket, is not set"); 
-    return PutBucketTaggingOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false)); 
-  } 
+  if (!request.BucketHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("PutBucketTagging", "Required field: Bucket, is not set");
+    return PutBucketTaggingOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
+  }
   ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
   if (!computeEndpointOutcome.IsSuccess())
   {
@@ -3256,11 +3256,11 @@ void S3Client::PutBucketTaggingAsyncHelper(const PutBucketTaggingRequest& reques
 
 PutBucketVersioningOutcome S3Client::PutBucketVersioning(const PutBucketVersioningRequest& request) const
 {
-  if (!request.BucketHasBeenSet()) 
-  { 
-    AWS_LOGSTREAM_ERROR("PutBucketVersioning", "Required field: Bucket, is not set"); 
-    return PutBucketVersioningOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false)); 
-  } 
+  if (!request.BucketHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("PutBucketVersioning", "Required field: Bucket, is not set");
+    return PutBucketVersioningOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
+  }
   ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
   if (!computeEndpointOutcome.IsSuccess())
   {
@@ -3293,11 +3293,11 @@ void S3Client::PutBucketVersioningAsyncHelper(const PutBucketVersioningRequest&
 
 PutBucketWebsiteOutcome S3Client::PutBucketWebsite(const PutBucketWebsiteRequest& request) const
 {
-  if (!request.BucketHasBeenSet()) 
-  { 
-    AWS_LOGSTREAM_ERROR("PutBucketWebsite", "Required field: Bucket, is not set"); 
-    return PutBucketWebsiteOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false)); 
-  } 
+  if (!request.BucketHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("PutBucketWebsite", "Required field: Bucket, is not set");
+    return PutBucketWebsiteOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
+  }
   ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
   if (!computeEndpointOutcome.IsSuccess())
   {
@@ -3330,16 +3330,16 @@ void S3Client::PutBucketWebsiteAsyncHelper(const PutBucketWebsiteRequest& reques
 
 PutObjectOutcome S3Client::PutObject(const PutObjectRequest& request) const
 {
-  if (!request.BucketHasBeenSet()) 
-  { 
-    AWS_LOGSTREAM_ERROR("PutObject", "Required field: Bucket, is not set"); 
-    return PutObjectOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false)); 
-  } 
-  if (!request.KeyHasBeenSet()) 
-  { 
-    AWS_LOGSTREAM_ERROR("PutObject", "Required field: Key, is not set"); 
-    return PutObjectOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Key]", false)); 
-  } 
+  if (!request.BucketHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("PutObject", "Required field: Bucket, is not set");
+    return PutObjectOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
+  }
+  if (!request.KeyHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("PutObject", "Required field: Key, is not set");
+    return PutObjectOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Key]", false));
+  }
   ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
   if (!computeEndpointOutcome.IsSuccess())
   {
@@ -3373,16 +3373,16 @@ void S3Client::PutObjectAsyncHelper(const PutObjectRequest& request, const PutOb
 
 PutObjectAclOutcome S3Client::PutObjectAcl(const PutObjectAclRequest& request) const
 {
-  if (!request.BucketHasBeenSet()) 
-  { 
-    AWS_LOGSTREAM_ERROR("PutObjectAcl", "Required field: Bucket, is not set"); 
-    return PutObjectAclOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false)); 
-  } 
-  if (!request.KeyHasBeenSet()) 
-  { 
-    AWS_LOGSTREAM_ERROR("PutObjectAcl", "Required field: Key, is not set"); 
-    return PutObjectAclOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Key]", false)); 
-  } 
+  if (!request.BucketHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("PutObjectAcl", "Required field: Bucket, is not set");
+    return PutObjectAclOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
+  }
+  if (!request.KeyHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("PutObjectAcl", "Required field: Key, is not set");
+    return PutObjectAclOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Key]", false));
+  }
   ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
   if (!computeEndpointOutcome.IsSuccess())
   {
@@ -3416,18 +3416,18 @@ void S3Client::PutObjectAclAsyncHelper(const PutObjectAclRequest& request, const
   handler(this, request, PutObjectAcl(request), context);
 }
 
-PutObjectLegalHoldOutcome S3Client::PutObjectLegalHold(const PutObjectLegalHoldRequest& request) const 
+PutObjectLegalHoldOutcome S3Client::PutObjectLegalHold(const PutObjectLegalHoldRequest& request) const
 {
-  if (!request.BucketHasBeenSet()) 
-  { 
-    AWS_LOGSTREAM_ERROR("PutObjectLegalHold", "Required field: Bucket, is not set"); 
-    return PutObjectLegalHoldOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false)); 
-  } 
-  if (!request.KeyHasBeenSet()) 
-  { 
-    AWS_LOGSTREAM_ERROR("PutObjectLegalHold", "Required field: Key, is not set"); 
-    return PutObjectLegalHoldOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Key]", false)); 
-  } 
+  if (!request.BucketHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("PutObjectLegalHold", "Required field: Bucket, is not set");
+    return PutObjectLegalHoldOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
+  }
+  if (!request.KeyHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("PutObjectLegalHold", "Required field: Key, is not set");
+    return PutObjectLegalHoldOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Key]", false));
+  }
   ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
   if (!computeEndpointOutcome.IsSuccess())
   {
@@ -3435,136 +3435,136 @@ PutObjectLegalHoldOutcome S3Client::PutObjectLegalHold(const PutObjectLegalHoldR
   }
   Aws::Http::URI uri = computeEndpointOutcome.GetResult().endpoint;
   Aws::StringStream ss;
-  ss << "/"; 
-  ss << request.GetKey(); 
-  uri.SetPath(uri.GetPath() + ss.str()); 
-  ss.str("?legal-hold"); 
-  uri.SetQueryString(ss.str()); 
+  ss << "/";
+  ss << request.GetKey();
+  uri.SetPath(uri.GetPath() + ss.str());
+  ss.str("?legal-hold");
+  uri.SetQueryString(ss.str());
   return PutObjectLegalHoldOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_PUT, Aws::Auth::SIGV4_SIGNER, computeEndpointOutcome.GetResult().signerRegion.c_str() /*signerRegionOverride*/, computeEndpointOutcome.GetResult().signerServiceName.c_str() /*signerServiceNameOverride*/));
-} 
- 
-PutObjectLegalHoldOutcomeCallable S3Client::PutObjectLegalHoldCallable(const PutObjectLegalHoldRequest& request) const 
-{ 
-  auto task = Aws::MakeShared< std::packaged_task< PutObjectLegalHoldOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->PutObjectLegalHold(request); } ); 
-  auto packagedFunction = [task]() { (*task)(); }; 
-  m_executor->Submit(packagedFunction); 
-  return task->get_future(); 
-} 
- 
-void S3Client::PutObjectLegalHoldAsync(const PutObjectLegalHoldRequest& request, const PutObjectLegalHoldResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const 
-{ 
-  m_executor->Submit( [this, request, handler, context](){ this->PutObjectLegalHoldAsyncHelper( request, handler, context ); } ); 
-} 
- 
-void S3Client::PutObjectLegalHoldAsyncHelper(const PutObjectLegalHoldRequest& request, const PutObjectLegalHoldResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const 
-{ 
-  handler(this, request, PutObjectLegalHold(request), context); 
-} 
- 
-PutObjectLockConfigurationOutcome S3Client::PutObjectLockConfiguration(const PutObjectLockConfigurationRequest& request) const 
-{ 
-  if (!request.BucketHasBeenSet()) 
-  { 
-    AWS_LOGSTREAM_ERROR("PutObjectLockConfiguration", "Required field: Bucket, is not set"); 
-    return PutObjectLockConfigurationOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false)); 
-  } 
+}
+
+PutObjectLegalHoldOutcomeCallable S3Client::PutObjectLegalHoldCallable(const PutObjectLegalHoldRequest& request) const
+{
+  auto task = Aws::MakeShared< std::packaged_task< PutObjectLegalHoldOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->PutObjectLegalHold(request); } );
+  auto packagedFunction = [task]() { (*task)(); };
+  m_executor->Submit(packagedFunction);
+  return task->get_future();
+}
+
+void S3Client::PutObjectLegalHoldAsync(const PutObjectLegalHoldRequest& request, const PutObjectLegalHoldResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  m_executor->Submit( [this, request, handler, context](){ this->PutObjectLegalHoldAsyncHelper( request, handler, context ); } );
+}
+
+void S3Client::PutObjectLegalHoldAsyncHelper(const PutObjectLegalHoldRequest& request, const PutObjectLegalHoldResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  handler(this, request, PutObjectLegalHold(request), context);
+}
+
+PutObjectLockConfigurationOutcome S3Client::PutObjectLockConfiguration(const PutObjectLockConfigurationRequest& request) const
+{
+  if (!request.BucketHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("PutObjectLockConfiguration", "Required field: Bucket, is not set");
+    return PutObjectLockConfigurationOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
+  }
   ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
   if (!computeEndpointOutcome.IsSuccess())
   {
     return PutObjectLockConfigurationOutcome(computeEndpointOutcome.GetError());
   }
   Aws::Http::URI uri = computeEndpointOutcome.GetResult().endpoint;
-  Aws::StringStream ss; 
-  ss.str("?object-lock"); 
-  uri.SetQueryString(ss.str()); 
+  Aws::StringStream ss;
+  ss.str("?object-lock");
+  uri.SetQueryString(ss.str());
   return PutObjectLockConfigurationOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_PUT, Aws::Auth::SIGV4_SIGNER, computeEndpointOutcome.GetResult().signerRegion.c_str() /*signerRegionOverride*/, computeEndpointOutcome.GetResult().signerServiceName.c_str() /*signerServiceNameOverride*/));
-} 
- 
-PutObjectLockConfigurationOutcomeCallable S3Client::PutObjectLockConfigurationCallable(const PutObjectLockConfigurationRequest& request) const 
-{ 
-  auto task = Aws::MakeShared< std::packaged_task< PutObjectLockConfigurationOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->PutObjectLockConfiguration(request); } ); 
-  auto packagedFunction = [task]() { (*task)(); }; 
-  m_executor->Submit(packagedFunction); 
-  return task->get_future(); 
-} 
- 
-void S3Client::PutObjectLockConfigurationAsync(const PutObjectLockConfigurationRequest& request, const PutObjectLockConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const 
-{ 
-  m_executor->Submit( [this, request, handler, context](){ this->PutObjectLockConfigurationAsyncHelper( request, handler, context ); } ); 
-} 
- 
-void S3Client::PutObjectLockConfigurationAsyncHelper(const PutObjectLockConfigurationRequest& request, const PutObjectLockConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const 
-{ 
-  handler(this, request, PutObjectLockConfiguration(request), context); 
-} 
- 
-PutObjectRetentionOutcome S3Client::PutObjectRetention(const PutObjectRetentionRequest& request) const 
-{ 
-  if (!request.BucketHasBeenSet()) 
-  { 
-    AWS_LOGSTREAM_ERROR("PutObjectRetention", "Required field: Bucket, is not set"); 
-    return PutObjectRetentionOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false)); 
-  } 
-  if (!request.KeyHasBeenSet()) 
-  { 
-    AWS_LOGSTREAM_ERROR("PutObjectRetention", "Required field: Key, is not set"); 
-    return PutObjectRetentionOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Key]", false)); 
-  } 
+}
+
+PutObjectLockConfigurationOutcomeCallable S3Client::PutObjectLockConfigurationCallable(const PutObjectLockConfigurationRequest& request) const
+{
+  auto task = Aws::MakeShared< std::packaged_task< PutObjectLockConfigurationOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->PutObjectLockConfiguration(request); } );
+  auto packagedFunction = [task]() { (*task)(); };
+  m_executor->Submit(packagedFunction);
+  return task->get_future();
+}
+
+void S3Client::PutObjectLockConfigurationAsync(const PutObjectLockConfigurationRequest& request, const PutObjectLockConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  m_executor->Submit( [this, request, handler, context](){ this->PutObjectLockConfigurationAsyncHelper( request, handler, context ); } );
+}
+
+void S3Client::PutObjectLockConfigurationAsyncHelper(const PutObjectLockConfigurationRequest& request, const PutObjectLockConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  handler(this, request, PutObjectLockConfiguration(request), context);
+}
+
+PutObjectRetentionOutcome S3Client::PutObjectRetention(const PutObjectRetentionRequest& request) const
+{
+  if (!request.BucketHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("PutObjectRetention", "Required field: Bucket, is not set");
+    return PutObjectRetentionOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
+  }
+  if (!request.KeyHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("PutObjectRetention", "Required field: Key, is not set");
+    return PutObjectRetentionOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Key]", false));
+  }
   ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
   if (!computeEndpointOutcome.IsSuccess())
   {
     return PutObjectRetentionOutcome(computeEndpointOutcome.GetError());
   }
   Aws::Http::URI uri = computeEndpointOutcome.GetResult().endpoint;
-  Aws::StringStream ss; 
+  Aws::StringStream ss;
   ss << "/";
   ss << request.GetKey();
   uri.SetPath(uri.GetPath() + ss.str());
-  ss.str("?retention"); 
-  uri.SetQueryString(ss.str()); 
+  ss.str("?retention");
+  uri.SetQueryString(ss.str());
   return PutObjectRetentionOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_PUT, Aws::Auth::SIGV4_SIGNER, computeEndpointOutcome.GetResult().signerRegion.c_str() /*signerRegionOverride*/, computeEndpointOutcome.GetResult().signerServiceName.c_str() /*signerServiceNameOverride*/));
-} 
- 
-PutObjectRetentionOutcomeCallable S3Client::PutObjectRetentionCallable(const PutObjectRetentionRequest& request) const 
-{ 
-  auto task = Aws::MakeShared< std::packaged_task< PutObjectRetentionOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->PutObjectRetention(request); } ); 
-  auto packagedFunction = [task]() { (*task)(); }; 
-  m_executor->Submit(packagedFunction); 
-  return task->get_future(); 
-} 
- 
-void S3Client::PutObjectRetentionAsync(const PutObjectRetentionRequest& request, const PutObjectRetentionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const 
-{ 
-  m_executor->Submit( [this, request, handler, context](){ this->PutObjectRetentionAsyncHelper( request, handler, context ); } ); 
-} 
- 
-void S3Client::PutObjectRetentionAsyncHelper(const PutObjectRetentionRequest& request, const PutObjectRetentionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const 
-{ 
-  handler(this, request, PutObjectRetention(request), context); 
-} 
- 
-PutObjectTaggingOutcome S3Client::PutObjectTagging(const PutObjectTaggingRequest& request) const 
-{ 
-  if (!request.BucketHasBeenSet()) 
-  { 
-    AWS_LOGSTREAM_ERROR("PutObjectTagging", "Required field: Bucket, is not set"); 
-    return PutObjectTaggingOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false)); 
-  } 
-  if (!request.KeyHasBeenSet()) 
-  { 
-    AWS_LOGSTREAM_ERROR("PutObjectTagging", "Required field: Key, is not set"); 
-    return PutObjectTaggingOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Key]", false)); 
-  } 
+}
+
+PutObjectRetentionOutcomeCallable S3Client::PutObjectRetentionCallable(const PutObjectRetentionRequest& request) const
+{
+  auto task = Aws::MakeShared< std::packaged_task< PutObjectRetentionOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->PutObjectRetention(request); } );
+  auto packagedFunction = [task]() { (*task)(); };
+  m_executor->Submit(packagedFunction);
+  return task->get_future();
+}
+
+void S3Client::PutObjectRetentionAsync(const PutObjectRetentionRequest& request, const PutObjectRetentionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  m_executor->Submit( [this, request, handler, context](){ this->PutObjectRetentionAsyncHelper( request, handler, context ); } );
+}
+
+void S3Client::PutObjectRetentionAsyncHelper(const PutObjectRetentionRequest& request, const PutObjectRetentionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  handler(this, request, PutObjectRetention(request), context);
+}
+
+PutObjectTaggingOutcome S3Client::PutObjectTagging(const PutObjectTaggingRequest& request) const
+{
+  if (!request.BucketHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("PutObjectTagging", "Required field: Bucket, is not set");
+    return PutObjectTaggingOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
+  }
+  if (!request.KeyHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("PutObjectTagging", "Required field: Key, is not set");
+    return PutObjectTaggingOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Key]", false));
+  }
   ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
   if (!computeEndpointOutcome.IsSuccess())
   {
     return PutObjectTaggingOutcome(computeEndpointOutcome.GetError());
   }
   Aws::Http::URI uri = computeEndpointOutcome.GetResult().endpoint;
-  Aws::StringStream ss; 
-  ss << "/"; 
-  ss << request.GetKey(); 
-  uri.SetPath(uri.GetPath() + ss.str()); 
+  Aws::StringStream ss;
+  ss << "/";
+  ss << request.GetKey();
+  uri.SetPath(uri.GetPath() + ss.str());
   ss.str("?tagging");
   uri.SetQueryString(ss.str());
   return PutObjectTaggingOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_PUT, Aws::Auth::SIGV4_SIGNER, computeEndpointOutcome.GetResult().signerRegion.c_str() /*signerRegionOverride*/, computeEndpointOutcome.GetResult().signerServiceName.c_str() /*signerServiceNameOverride*/));
@@ -3588,55 +3588,55 @@ void S3Client::PutObjectTaggingAsyncHelper(const PutObjectTaggingRequest& reques
   handler(this, request, PutObjectTagging(request), context);
 }
 
-PutPublicAccessBlockOutcome S3Client::PutPublicAccessBlock(const PutPublicAccessBlockRequest& request) const 
-{ 
-  if (!request.BucketHasBeenSet()) 
-  { 
-    AWS_LOGSTREAM_ERROR("PutPublicAccessBlock", "Required field: Bucket, is not set"); 
-    return PutPublicAccessBlockOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false)); 
-  } 
+PutPublicAccessBlockOutcome S3Client::PutPublicAccessBlock(const PutPublicAccessBlockRequest& request) const
+{
+  if (!request.BucketHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("PutPublicAccessBlock", "Required field: Bucket, is not set");
+    return PutPublicAccessBlockOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
+  }
   ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
   if (!computeEndpointOutcome.IsSuccess())
   {
     return PutPublicAccessBlockOutcome(computeEndpointOutcome.GetError());
   }
   Aws::Http::URI uri = computeEndpointOutcome.GetResult().endpoint;
-  Aws::StringStream ss; 
-  ss.str("?publicAccessBlock"); 
-  uri.SetQueryString(ss.str()); 
+  Aws::StringStream ss;
+  ss.str("?publicAccessBlock");
+  uri.SetQueryString(ss.str());
   return PutPublicAccessBlockOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_PUT, Aws::Auth::SIGV4_SIGNER, computeEndpointOutcome.GetResult().signerRegion.c_str() /*signerRegionOverride*/, computeEndpointOutcome.GetResult().signerServiceName.c_str() /*signerServiceNameOverride*/));
-} 
- 
-PutPublicAccessBlockOutcomeCallable S3Client::PutPublicAccessBlockCallable(const PutPublicAccessBlockRequest& request) const 
-{ 
-  auto task = Aws::MakeShared< std::packaged_task< PutPublicAccessBlockOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->PutPublicAccessBlock(request); } ); 
-  auto packagedFunction = [task]() { (*task)(); }; 
-  m_executor->Submit(packagedFunction); 
-  return task->get_future(); 
-} 
- 
-void S3Client::PutPublicAccessBlockAsync(const PutPublicAccessBlockRequest& request, const PutPublicAccessBlockResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const 
-{ 
-  m_executor->Submit( [this, request, handler, context](){ this->PutPublicAccessBlockAsyncHelper( request, handler, context ); } ); 
-} 
- 
-void S3Client::PutPublicAccessBlockAsyncHelper(const PutPublicAccessBlockRequest& request, const PutPublicAccessBlockResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const 
-{ 
-  handler(this, request, PutPublicAccessBlock(request), context); 
-} 
- 
+}
+
+PutPublicAccessBlockOutcomeCallable S3Client::PutPublicAccessBlockCallable(const PutPublicAccessBlockRequest& request) const
+{
+  auto task = Aws::MakeShared< std::packaged_task< PutPublicAccessBlockOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->PutPublicAccessBlock(request); } );
+  auto packagedFunction = [task]() { (*task)(); };
+  m_executor->Submit(packagedFunction);
+  return task->get_future();
+}
+
+void S3Client::PutPublicAccessBlockAsync(const PutPublicAccessBlockRequest& request, const PutPublicAccessBlockResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  m_executor->Submit( [this, request, handler, context](){ this->PutPublicAccessBlockAsyncHelper( request, handler, context ); } );
+}
+
+void S3Client::PutPublicAccessBlockAsyncHelper(const PutPublicAccessBlockRequest& request, const PutPublicAccessBlockResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  handler(this, request, PutPublicAccessBlock(request), context);
+}
+
 RestoreObjectOutcome S3Client::RestoreObject(const RestoreObjectRequest& request) const
 {
-  if (!request.BucketHasBeenSet()) 
-  { 
-    AWS_LOGSTREAM_ERROR("RestoreObject", "Required field: Bucket, is not set"); 
-    return RestoreObjectOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false)); 
-  } 
-  if (!request.KeyHasBeenSet()) 
-  { 
-    AWS_LOGSTREAM_ERROR("RestoreObject", "Required field: Key, is not set"); 
-    return RestoreObjectOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Key]", false)); 
-  } 
+  if (!request.BucketHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("RestoreObject", "Required field: Bucket, is not set");
+    return RestoreObjectOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
+  }
+  if (!request.KeyHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("RestoreObject", "Required field: Key, is not set");
+    return RestoreObjectOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Key]", false));
+  }
   ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
   if (!computeEndpointOutcome.IsSuccess())
   {
@@ -3670,76 +3670,76 @@ void S3Client::RestoreObjectAsyncHelper(const RestoreObjectRequest& request, con
   handler(this, request, RestoreObject(request), context);
 }
 
-SelectObjectContentOutcome S3Client::SelectObjectContent(SelectObjectContentRequest& request) const 
-{ 
-  if (!request.BucketHasBeenSet()) 
-  { 
-    AWS_LOGSTREAM_ERROR("SelectObjectContent", "Required field: Bucket, is not set"); 
-    return SelectObjectContentOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false)); 
-  } 
-  if (!request.KeyHasBeenSet()) 
-  { 
-    AWS_LOGSTREAM_ERROR("SelectObjectContent", "Required field: Key, is not set"); 
-    return SelectObjectContentOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Key]", false)); 
-  } 
+SelectObjectContentOutcome S3Client::SelectObjectContent(SelectObjectContentRequest& request) const
+{
+  if (!request.BucketHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("SelectObjectContent", "Required field: Bucket, is not set");
+    return SelectObjectContentOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
+  }
+  if (!request.KeyHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("SelectObjectContent", "Required field: Key, is not set");
+    return SelectObjectContentOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Key]", false));
+  }
   ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
   if (!computeEndpointOutcome.IsSuccess())
   {
     return SelectObjectContentOutcome(computeEndpointOutcome.GetError());
   }
   Aws::Http::URI uri = computeEndpointOutcome.GetResult().endpoint;
-  Aws::StringStream ss; 
-  ss << "/"; 
-  ss << request.GetKey(); 
-  uri.SetPath(uri.GetPath() + ss.str()); 
-  ss.str("?select&select-type=2"); 
-  uri.SetQueryString(ss.str()); 
-  request.SetResponseStreamFactory( 
+  Aws::StringStream ss;
+  ss << "/";
+  ss << request.GetKey();
+  uri.SetPath(uri.GetPath() + ss.str());
+  ss.str("?select&select-type=2");
+  uri.SetQueryString(ss.str());
+  request.SetResponseStreamFactory(
       [&] { request.GetEventStreamDecoder().Reset(); return Aws::New<Aws::Utils::Event::EventDecoderStream>(ALLOCATION_TAG, request.GetEventStreamDecoder()); }
-  ); 
+  );
   return SelectObjectContentOutcome(MakeRequestWithEventStream(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER, computeEndpointOutcome.GetResult().signerRegion.c_str() /*signerRegionOverride*/, computeEndpointOutcome.GetResult().signerServiceName.c_str() /*signerServiceNameOverride*/));
-} 
- 
-SelectObjectContentOutcomeCallable S3Client::SelectObjectContentCallable(SelectObjectContentRequest& request) const 
-{ 
-  auto task = Aws::MakeShared< std::packaged_task< SelectObjectContentOutcome() > >(ALLOCATION_TAG, [this, &request](){ return this->SelectObjectContent(request); } ); 
-  auto packagedFunction = [task]() { (*task)(); }; 
-  m_executor->Submit(packagedFunction); 
-  return task->get_future(); 
-} 
- 
-void S3Client::SelectObjectContentAsync(SelectObjectContentRequest& request, const SelectObjectContentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const 
-{ 
-  m_executor->Submit( [this, &request, handler, context](){ this->SelectObjectContentAsyncHelper( request, handler, context ); } ); 
-} 
- 
-void S3Client::SelectObjectContentAsyncHelper(SelectObjectContentRequest& request, const SelectObjectContentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const 
-{ 
-  handler(this, request, SelectObjectContent(request), context); 
-} 
- 
+}
+
+SelectObjectContentOutcomeCallable S3Client::SelectObjectContentCallable(SelectObjectContentRequest& request) const
+{
+  auto task = Aws::MakeShared< std::packaged_task< SelectObjectContentOutcome() > >(ALLOCATION_TAG, [this, &request](){ return this->SelectObjectContent(request); } );
+  auto packagedFunction = [task]() { (*task)(); };
+  m_executor->Submit(packagedFunction);
+  return task->get_future();
+}
+
+void S3Client::SelectObjectContentAsync(SelectObjectContentRequest& request, const SelectObjectContentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  m_executor->Submit( [this, &request, handler, context](){ this->SelectObjectContentAsyncHelper( request, handler, context ); } );
+}
+
+void S3Client::SelectObjectContentAsyncHelper(SelectObjectContentRequest& request, const SelectObjectContentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  handler(this, request, SelectObjectContent(request), context);
+}
+
 UploadPartOutcome S3Client::UploadPart(const UploadPartRequest& request) const
 {
-  if (!request.BucketHasBeenSet()) 
-  { 
-    AWS_LOGSTREAM_ERROR("UploadPart", "Required field: Bucket, is not set"); 
-    return UploadPartOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false)); 
-  } 
-  if (!request.KeyHasBeenSet()) 
-  { 
-    AWS_LOGSTREAM_ERROR("UploadPart", "Required field: Key, is not set"); 
-    return UploadPartOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Key]", false)); 
-  } 
-  if (!request.PartNumberHasBeenSet()) 
-  { 
-    AWS_LOGSTREAM_ERROR("UploadPart", "Required field: PartNumber, is not set"); 
-    return UploadPartOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [PartNumber]", false)); 
-  } 
-  if (!request.UploadIdHasBeenSet()) 
-  { 
-    AWS_LOGSTREAM_ERROR("UploadPart", "Required field: UploadId, is not set"); 
-    return UploadPartOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [UploadId]", false)); 
-  } 
+  if (!request.BucketHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("UploadPart", "Required field: Bucket, is not set");
+    return UploadPartOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
+  }
+  if (!request.KeyHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("UploadPart", "Required field: Key, is not set");
+    return UploadPartOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Key]", false));
+  }
+  if (!request.PartNumberHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("UploadPart", "Required field: PartNumber, is not set");
+    return UploadPartOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [PartNumber]", false));
+  }
+  if (!request.UploadIdHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("UploadPart", "Required field: UploadId, is not set");
+    return UploadPartOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [UploadId]", false));
+  }
   ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
   if (!computeEndpointOutcome.IsSuccess())
   {
@@ -3773,31 +3773,31 @@ void S3Client::UploadPartAsyncHelper(const UploadPartRequest& request, const Upl
 
 UploadPartCopyOutcome S3Client::UploadPartCopy(const UploadPartCopyRequest& request) const
 {
-  if (!request.BucketHasBeenSet()) 
-  { 
-    AWS_LOGSTREAM_ERROR("UploadPartCopy", "Required field: Bucket, is not set"); 
-    return UploadPartCopyOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false)); 
-  } 
-  if (!request.CopySourceHasBeenSet()) 
-  { 
-    AWS_LOGSTREAM_ERROR("UploadPartCopy", "Required field: CopySource, is not set"); 
-    return UploadPartCopyOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [CopySource]", false)); 
-  } 
-  if (!request.KeyHasBeenSet()) 
-  { 
-    AWS_LOGSTREAM_ERROR("UploadPartCopy", "Required field: Key, is not set"); 
-    return UploadPartCopyOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Key]", false)); 
-  } 
-  if (!request.PartNumberHasBeenSet()) 
-  { 
-    AWS_LOGSTREAM_ERROR("UploadPartCopy", "Required field: PartNumber, is not set"); 
-    return UploadPartCopyOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [PartNumber]", false)); 
-  } 
-  if (!request.UploadIdHasBeenSet()) 
-  { 
-    AWS_LOGSTREAM_ERROR("UploadPartCopy", "Required field: UploadId, is not set"); 
-    return UploadPartCopyOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [UploadId]", false)); 
-  } 
+  if (!request.BucketHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("UploadPartCopy", "Required field: Bucket, is not set");
+    return UploadPartCopyOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Bucket]", false));
+  }
+  if (!request.CopySourceHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("UploadPartCopy", "Required field: CopySource, is not set");
+    return UploadPartCopyOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [CopySource]", false));
+  }
+  if (!request.KeyHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("UploadPartCopy", "Required field: Key, is not set");
+    return UploadPartCopyOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Key]", false));
+  }
+  if (!request.PartNumberHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("UploadPartCopy", "Required field: PartNumber, is not set");
+    return UploadPartCopyOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [PartNumber]", false));
+  }
+  if (!request.UploadIdHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("UploadPartCopy", "Required field: UploadId, is not set");
+    return UploadPartCopyOutcome(Aws::Client::AWSError<S3Errors>(S3Errors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [UploadId]", false));
+  }
   ComputeEndpointOutcome computeEndpointOutcome = ComputeEndpointString(request.GetBucket());
   if (!computeEndpointOutcome.IsSuccess())
   {