S3Client.h

 
#pragma once
#include <aws/core/auth/AWSAuthSigner.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/utils/DNS.h>
#include <aws/core/utils/xml/XmlSerializer.h>
#include <aws/s3/S3PaginationBase.h>
#include <aws/s3/S3ServiceClientModel.h>
#include <aws/s3/S3Waiter.h>
#include <aws/s3/S3_EXPORTS.h>
 
// TODO: temporary fix for naming conflicts on Windows.
#ifdef _WIN32
#ifdef GetObject
#undef GetObject
#endif
#endif
 
namespace Aws {
namespace S3 {
namespace SSEHeaders {
static const char SERVER_SIDE_ENCRYPTION[] = "x-amz-server-side-encryption";
static const char SERVER_SIDE_ENCRYPTION_AWS_KMS_KEY_ID[] = "x-amz-server-side-encryption-aws-kms-key-id";
static const char SERVER_SIDE_ENCRYPTION_CUSTOMER_ALGORITHM[] = "x-amz-server-side-encryption-customer-algorithm";
static const char SERVER_SIDE_ENCRYPTION_CUSTOMER_KEY[] = "x-amz-server-side-encryption-customer-key";
static const char SERVER_SIDE_ENCRYPTION_CUSTOMER_KEY_MD5[] = "x-amz-server-side-encryption-customer-key-MD5";
}  // namespace SSEHeaders
 
// max expiration for presigned urls in s3 is 7 days.
static const unsigned MAX_EXPIRATION_SECONDS = 7 * 24 * 60 * 60;
 
class AWS_S3_API S3Client : public Aws::Client::AWSXMLClient,
                            public Aws::Client::ClientWithAsyncTemplateMethods<S3Client>,
                            public S3PaginationBase<S3Client>,
                            public S3Waiter<S3Client> {
 public:
  typedef Aws::Client::AWSXMLClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef S3ClientConfiguration ClientConfigurationType;
  typedef S3EndpointProvider EndpointProviderType;
 
  S3Client(const S3Client& rhs);
 
  S3Client& operator=(const S3Client& rhs);
 
  S3Client(S3Client&& rhs) noexcept;
 
  S3Client& operator=(S3Client&& rhs) noexcept;
  S3Client(const Aws::S3::S3ClientConfiguration& clientConfiguration = Aws::S3::S3ClientConfiguration(),
           std::shared_ptr<S3EndpointProviderBase> endpointProvider = nullptr);
 
  S3Client(const Aws::Auth::AWSCredentials& credentials, std::shared_ptr<S3EndpointProviderBase> endpointProvider = nullptr,
           const Aws::S3::S3ClientConfiguration& clientConfiguration = Aws::S3::S3ClientConfiguration());
 
  S3Client(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
           std::shared_ptr<S3EndpointProviderBase> endpointProvider = nullptr,
           const Aws::S3::S3ClientConfiguration& clientConfiguration = Aws::S3::S3ClientConfiguration());
 
  /* Legacy constructors due deprecation */
  S3Client(
      const Aws::Client::ClientConfiguration& clientConfiguration, Aws::Client::AWSAuthV4Signer::PayloadSigningPolicy signPayloads,
      bool useVirtualAddressing,
      Aws::S3::US_EAST_1_REGIONAL_ENDPOINT_OPTION USEast1RegionalEndPointOption = Aws::S3::US_EAST_1_REGIONAL_ENDPOINT_OPTION::NOT_SET);
 
  S3Client(
      const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration,
      Aws::Client::AWSAuthV4Signer::PayloadSigningPolicy signPayloads, bool useVirtualAddressing,
      Aws::S3::US_EAST_1_REGIONAL_ENDPOINT_OPTION USEast1RegionalEndPointOption = Aws::S3::US_EAST_1_REGIONAL_ENDPOINT_OPTION::NOT_SET);
 
  S3Client(
      const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
      const Aws::Client::ClientConfiguration& clientConfiguration, Aws::Client::AWSAuthV4Signer::PayloadSigningPolicy signPayloads,
      bool useVirtualAddressing,
      Aws::S3::US_EAST_1_REGIONAL_ENDPOINT_OPTION USEast1RegionalEndPointOption = Aws::S3::US_EAST_1_REGIONAL_ENDPOINT_OPTION::NOT_SET);
 
  /* End of legacy constructors due deprecation */
  virtual ~S3Client();
 
  virtual Model::AbortMultipartUploadOutcome AbortMultipartUpload(const Model::AbortMultipartUploadRequest& request) const;
 
  template <typename AbortMultipartUploadRequestT = Model::AbortMultipartUploadRequest>
  Model::AbortMultipartUploadOutcomeCallable AbortMultipartUploadCallable(const AbortMultipartUploadRequestT& request) const {
    return SubmitCallable(&S3Client::AbortMultipartUpload, request);
  }
 
  template <typename AbortMultipartUploadRequestT = Model::AbortMultipartUploadRequest>
  void AbortMultipartUploadAsync(const AbortMultipartUploadRequestT& request, const AbortMultipartUploadResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3Client::AbortMultipartUpload, request, handler, context);
  }
 
  virtual Model::CompleteMultipartUploadOutcome CompleteMultipartUpload(const Model::CompleteMultipartUploadRequest& request) const;
 
  template <typename CompleteMultipartUploadRequestT = Model::CompleteMultipartUploadRequest>
  Model::CompleteMultipartUploadOutcomeCallable CompleteMultipartUploadCallable(const CompleteMultipartUploadRequestT& request) const {
    return SubmitCallable(&S3Client::CompleteMultipartUpload, request);
  }
 
  template <typename CompleteMultipartUploadRequestT = Model::CompleteMultipartUploadRequest>
  void CompleteMultipartUploadAsync(const CompleteMultipartUploadRequestT& request,
                                    const CompleteMultipartUploadResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3Client::CompleteMultipartUpload, request, handler, context);
  }
 
  virtual Model::CopyObjectOutcome CopyObject(const Model::CopyObjectRequest& request) const;
 
  virtual Model::CopyObjectOutcomeCallable CopyObjectCallable(const Model::CopyObjectRequest& request) const;
 
  virtual void CopyObjectAsync(const Model::CopyObjectRequest& request, const CopyObjectResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
 
  virtual Model::CreateBucketOutcome CreateBucket(const Model::CreateBucketRequest& request) const;
 
  template <typename CreateBucketRequestT = Model::CreateBucketRequest>
  Model::CreateBucketOutcomeCallable CreateBucketCallable(const CreateBucketRequestT& request) const {
    return SubmitCallable(&S3Client::CreateBucket, request);
  }
 
  template <typename CreateBucketRequestT = Model::CreateBucketRequest>
  void CreateBucketAsync(const CreateBucketRequestT& request, const CreateBucketResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3Client::CreateBucket, request, handler, context);
  }
 
  virtual Model::CreateBucketMetadataConfigurationOutcome CreateBucketMetadataConfiguration(
      const Model::CreateBucketMetadataConfigurationRequest& request) const;
 
  template <typename CreateBucketMetadataConfigurationRequestT = Model::CreateBucketMetadataConfigurationRequest>
  Model::CreateBucketMetadataConfigurationOutcomeCallable CreateBucketMetadataConfigurationCallable(
      const CreateBucketMetadataConfigurationRequestT& request) const {
    return SubmitCallable(&S3Client::CreateBucketMetadataConfiguration, request);
  }
 
  template <typename CreateBucketMetadataConfigurationRequestT = Model::CreateBucketMetadataConfigurationRequest>
  void CreateBucketMetadataConfigurationAsync(const CreateBucketMetadataConfigurationRequestT& request,
                                              const CreateBucketMetadataConfigurationResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3Client::CreateBucketMetadataConfiguration, request, handler, context);
  }
 
  virtual Model::CreateBucketMetadataTableConfigurationOutcome CreateBucketMetadataTableConfiguration(
      const Model::CreateBucketMetadataTableConfigurationRequest& request) const;
 
  template <typename CreateBucketMetadataTableConfigurationRequestT = Model::CreateBucketMetadataTableConfigurationRequest>
  Model::CreateBucketMetadataTableConfigurationOutcomeCallable CreateBucketMetadataTableConfigurationCallable(
      const CreateBucketMetadataTableConfigurationRequestT& request) const {
    return SubmitCallable(&S3Client::CreateBucketMetadataTableConfiguration, request);
  }
 
  template <typename CreateBucketMetadataTableConfigurationRequestT = Model::CreateBucketMetadataTableConfigurationRequest>
  void CreateBucketMetadataTableConfigurationAsync(const CreateBucketMetadataTableConfigurationRequestT& request,
                                                   const CreateBucketMetadataTableConfigurationResponseReceivedHandler& handler,
                                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3Client::CreateBucketMetadataTableConfiguration, request, handler, context);
  }
 
  virtual Model::CreateMultipartUploadOutcome CreateMultipartUpload(const Model::CreateMultipartUploadRequest& request) const;
 
  template <typename CreateMultipartUploadRequestT = Model::CreateMultipartUploadRequest>
  Model::CreateMultipartUploadOutcomeCallable CreateMultipartUploadCallable(const CreateMultipartUploadRequestT& request) const {
    return SubmitCallable(&S3Client::CreateMultipartUpload, request);
  }
 
  template <typename CreateMultipartUploadRequestT = Model::CreateMultipartUploadRequest>
  void CreateMultipartUploadAsync(const CreateMultipartUploadRequestT& request, const CreateMultipartUploadResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3Client::CreateMultipartUpload, request, handler, context);
  }
 
  virtual Model::CreateSessionOutcome CreateSession(const Model::CreateSessionRequest& request) const;
 
  template <typename CreateSessionRequestT = Model::CreateSessionRequest>
  Model::CreateSessionOutcomeCallable CreateSessionCallable(const CreateSessionRequestT& request) const {
    return SubmitCallable(&S3Client::CreateSession, request);
  }
 
  template <typename CreateSessionRequestT = Model::CreateSessionRequest>
  void CreateSessionAsync(const CreateSessionRequestT& request, const CreateSessionResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3Client::CreateSession, request, handler, context);
  }
 
  virtual Model::DeleteBucketOutcome DeleteBucket(const Model::DeleteBucketRequest& request) const;
 
  template <typename DeleteBucketRequestT = Model::DeleteBucketRequest>
  Model::DeleteBucketOutcomeCallable DeleteBucketCallable(const DeleteBucketRequestT& request) const {
    return SubmitCallable(&S3Client::DeleteBucket, request);
  }
 
  template <typename DeleteBucketRequestT = Model::DeleteBucketRequest>
  void DeleteBucketAsync(const DeleteBucketRequestT& request, const DeleteBucketResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3Client::DeleteBucket, request, handler, context);
  }
 
  virtual Model::DeleteBucketAnalyticsConfigurationOutcome DeleteBucketAnalyticsConfiguration(
      const Model::DeleteBucketAnalyticsConfigurationRequest& request) const;
 
  template <typename DeleteBucketAnalyticsConfigurationRequestT = Model::DeleteBucketAnalyticsConfigurationRequest>
  Model::DeleteBucketAnalyticsConfigurationOutcomeCallable DeleteBucketAnalyticsConfigurationCallable(
      const DeleteBucketAnalyticsConfigurationRequestT& request) const {
    return SubmitCallable(&S3Client::DeleteBucketAnalyticsConfiguration, request);
  }
 
  template <typename DeleteBucketAnalyticsConfigurationRequestT = Model::DeleteBucketAnalyticsConfigurationRequest>
  void DeleteBucketAnalyticsConfigurationAsync(const DeleteBucketAnalyticsConfigurationRequestT& request,
                                               const DeleteBucketAnalyticsConfigurationResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3Client::DeleteBucketAnalyticsConfiguration, request, handler, context);
  }
 
  virtual Model::DeleteBucketCorsOutcome DeleteBucketCors(const Model::DeleteBucketCorsRequest& request) const;
 
  template <typename DeleteBucketCorsRequestT = Model::DeleteBucketCorsRequest>
  Model::DeleteBucketCorsOutcomeCallable DeleteBucketCorsCallable(const DeleteBucketCorsRequestT& request) const {
    return SubmitCallable(&S3Client::DeleteBucketCors, request);
  }
 
  template <typename DeleteBucketCorsRequestT = Model::DeleteBucketCorsRequest>
  void DeleteBucketCorsAsync(const DeleteBucketCorsRequestT& request, const DeleteBucketCorsResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3Client::DeleteBucketCors, request, handler, context);
  }
 
  virtual Model::DeleteBucketEncryptionOutcome DeleteBucketEncryption(const Model::DeleteBucketEncryptionRequest& request) const;
 
  template <typename DeleteBucketEncryptionRequestT = Model::DeleteBucketEncryptionRequest>
  Model::DeleteBucketEncryptionOutcomeCallable DeleteBucketEncryptionCallable(const DeleteBucketEncryptionRequestT& request) const {
    return SubmitCallable(&S3Client::DeleteBucketEncryption, request);
  }
 
  template <typename DeleteBucketEncryptionRequestT = Model::DeleteBucketEncryptionRequest>
  void DeleteBucketEncryptionAsync(const DeleteBucketEncryptionRequestT& request,
                                   const DeleteBucketEncryptionResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3Client::DeleteBucketEncryption, request, handler, context);
  }
 
  virtual Model::DeleteBucketIntelligentTieringConfigurationOutcome DeleteBucketIntelligentTieringConfiguration(
      const Model::DeleteBucketIntelligentTieringConfigurationRequest& request) const;
 
  template <typename DeleteBucketIntelligentTieringConfigurationRequestT = Model::DeleteBucketIntelligentTieringConfigurationRequest>
  Model::DeleteBucketIntelligentTieringConfigurationOutcomeCallable DeleteBucketIntelligentTieringConfigurationCallable(
      const DeleteBucketIntelligentTieringConfigurationRequestT& request) const {
    return SubmitCallable(&S3Client::DeleteBucketIntelligentTieringConfiguration, request);
  }
 
  template <typename DeleteBucketIntelligentTieringConfigurationRequestT = Model::DeleteBucketIntelligentTieringConfigurationRequest>
  void DeleteBucketIntelligentTieringConfigurationAsync(
      const DeleteBucketIntelligentTieringConfigurationRequestT& request,
      const DeleteBucketIntelligentTieringConfigurationResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3Client::DeleteBucketIntelligentTieringConfiguration, request, handler, context);
  }
 
  virtual Model::DeleteBucketInventoryConfigurationOutcome DeleteBucketInventoryConfiguration(
      const Model::DeleteBucketInventoryConfigurationRequest& request) const;
 
  template <typename DeleteBucketInventoryConfigurationRequestT = Model::DeleteBucketInventoryConfigurationRequest>
  Model::DeleteBucketInventoryConfigurationOutcomeCallable DeleteBucketInventoryConfigurationCallable(
      const DeleteBucketInventoryConfigurationRequestT& request) const {
    return SubmitCallable(&S3Client::DeleteBucketInventoryConfiguration, request);
  }
 
  template <typename DeleteBucketInventoryConfigurationRequestT = Model::DeleteBucketInventoryConfigurationRequest>
  void DeleteBucketInventoryConfigurationAsync(const DeleteBucketInventoryConfigurationRequestT& request,
                                               const DeleteBucketInventoryConfigurationResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3Client::DeleteBucketInventoryConfiguration, request, handler, context);
  }
 
  virtual Model::DeleteBucketLifecycleOutcome DeleteBucketLifecycle(const Model::DeleteBucketLifecycleRequest& request) const;
 
  template <typename DeleteBucketLifecycleRequestT = Model::DeleteBucketLifecycleRequest>
  Model::DeleteBucketLifecycleOutcomeCallable DeleteBucketLifecycleCallable(const DeleteBucketLifecycleRequestT& request) const {
    return SubmitCallable(&S3Client::DeleteBucketLifecycle, request);
  }
 
  template <typename DeleteBucketLifecycleRequestT = Model::DeleteBucketLifecycleRequest>
  void DeleteBucketLifecycleAsync(const DeleteBucketLifecycleRequestT& request, const DeleteBucketLifecycleResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3Client::DeleteBucketLifecycle, request, handler, context);
  }
 
  virtual Model::DeleteBucketMetadataConfigurationOutcome DeleteBucketMetadataConfiguration(
      const Model::DeleteBucketMetadataConfigurationRequest& request) const;
 
  template <typename DeleteBucketMetadataConfigurationRequestT = Model::DeleteBucketMetadataConfigurationRequest>
  Model::DeleteBucketMetadataConfigurationOutcomeCallable DeleteBucketMetadataConfigurationCallable(
      const DeleteBucketMetadataConfigurationRequestT& request) const {
    return SubmitCallable(&S3Client::DeleteBucketMetadataConfiguration, request);
  }
 
  template <typename DeleteBucketMetadataConfigurationRequestT = Model::DeleteBucketMetadataConfigurationRequest>
  void DeleteBucketMetadataConfigurationAsync(const DeleteBucketMetadataConfigurationRequestT& request,
                                              const DeleteBucketMetadataConfigurationResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3Client::DeleteBucketMetadataConfiguration, request, handler, context);
  }
 
  virtual Model::DeleteBucketMetadataTableConfigurationOutcome DeleteBucketMetadataTableConfiguration(
      const Model::DeleteBucketMetadataTableConfigurationRequest& request) const;
 
  template <typename DeleteBucketMetadataTableConfigurationRequestT = Model::DeleteBucketMetadataTableConfigurationRequest>
  Model::DeleteBucketMetadataTableConfigurationOutcomeCallable DeleteBucketMetadataTableConfigurationCallable(
      const DeleteBucketMetadataTableConfigurationRequestT& request) const {
    return SubmitCallable(&S3Client::DeleteBucketMetadataTableConfiguration, request);
  }
 
  template <typename DeleteBucketMetadataTableConfigurationRequestT = Model::DeleteBucketMetadataTableConfigurationRequest>
  void DeleteBucketMetadataTableConfigurationAsync(const DeleteBucketMetadataTableConfigurationRequestT& request,
                                                   const DeleteBucketMetadataTableConfigurationResponseReceivedHandler& handler,
                                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3Client::DeleteBucketMetadataTableConfiguration, request, handler, context);
  }
 
  virtual Model::DeleteBucketMetricsConfigurationOutcome DeleteBucketMetricsConfiguration(
      const Model::DeleteBucketMetricsConfigurationRequest& request) const;
 
  template <typename DeleteBucketMetricsConfigurationRequestT = Model::DeleteBucketMetricsConfigurationRequest>
  Model::DeleteBucketMetricsConfigurationOutcomeCallable DeleteBucketMetricsConfigurationCallable(
      const DeleteBucketMetricsConfigurationRequestT& request) const {
    return SubmitCallable(&S3Client::DeleteBucketMetricsConfiguration, request);
  }
 
  template <typename DeleteBucketMetricsConfigurationRequestT = Model::DeleteBucketMetricsConfigurationRequest>
  void DeleteBucketMetricsConfigurationAsync(const DeleteBucketMetricsConfigurationRequestT& request,
                                             const DeleteBucketMetricsConfigurationResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3Client::DeleteBucketMetricsConfiguration, request, handler, context);
  }
 
  virtual Model::DeleteBucketOwnershipControlsOutcome DeleteBucketOwnershipControls(
      const Model::DeleteBucketOwnershipControlsRequest& request) const;
 
  template <typename DeleteBucketOwnershipControlsRequestT = Model::DeleteBucketOwnershipControlsRequest>
  Model::DeleteBucketOwnershipControlsOutcomeCallable DeleteBucketOwnershipControlsCallable(
      const DeleteBucketOwnershipControlsRequestT& request) const {
    return SubmitCallable(&S3Client::DeleteBucketOwnershipControls, request);
  }
 
  template <typename DeleteBucketOwnershipControlsRequestT = Model::DeleteBucketOwnershipControlsRequest>
  void DeleteBucketOwnershipControlsAsync(const DeleteBucketOwnershipControlsRequestT& request,
                                          const DeleteBucketOwnershipControlsResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3Client::DeleteBucketOwnershipControls, request, handler, context);
  }
 
  virtual Model::DeleteBucketPolicyOutcome DeleteBucketPolicy(const Model::DeleteBucketPolicyRequest& request) const;
 
  template <typename DeleteBucketPolicyRequestT = Model::DeleteBucketPolicyRequest>
  Model::DeleteBucketPolicyOutcomeCallable DeleteBucketPolicyCallable(const DeleteBucketPolicyRequestT& request) const {
    return SubmitCallable(&S3Client::DeleteBucketPolicy, request);
  }
 
  template <typename DeleteBucketPolicyRequestT = Model::DeleteBucketPolicyRequest>
  void DeleteBucketPolicyAsync(const DeleteBucketPolicyRequestT& request, const DeleteBucketPolicyResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3Client::DeleteBucketPolicy, request, handler, context);
  }
 
  virtual Model::DeleteBucketReplicationOutcome DeleteBucketReplication(const Model::DeleteBucketReplicationRequest& request) const;
 
  template <typename DeleteBucketReplicationRequestT = Model::DeleteBucketReplicationRequest>
  Model::DeleteBucketReplicationOutcomeCallable DeleteBucketReplicationCallable(const DeleteBucketReplicationRequestT& request) const {
    return SubmitCallable(&S3Client::DeleteBucketReplication, request);
  }
 
  template <typename DeleteBucketReplicationRequestT = Model::DeleteBucketReplicationRequest>
  void DeleteBucketReplicationAsync(const DeleteBucketReplicationRequestT& request,
                                    const DeleteBucketReplicationResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3Client::DeleteBucketReplication, request, handler, context);
  }
 
  virtual Model::DeleteBucketTaggingOutcome DeleteBucketTagging(const Model::DeleteBucketTaggingRequest& request) const;
 
  template <typename DeleteBucketTaggingRequestT = Model::DeleteBucketTaggingRequest>
  Model::DeleteBucketTaggingOutcomeCallable DeleteBucketTaggingCallable(const DeleteBucketTaggingRequestT& request) const {
    return SubmitCallable(&S3Client::DeleteBucketTagging, request);
  }
 
  template <typename DeleteBucketTaggingRequestT = Model::DeleteBucketTaggingRequest>
  void DeleteBucketTaggingAsync(const DeleteBucketTaggingRequestT& request, const DeleteBucketTaggingResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3Client::DeleteBucketTagging, request, handler, context);
  }
 
  virtual Model::DeleteBucketWebsiteOutcome DeleteBucketWebsite(const Model::DeleteBucketWebsiteRequest& request) const;
 
  template <typename DeleteBucketWebsiteRequestT = Model::DeleteBucketWebsiteRequest>
  Model::DeleteBucketWebsiteOutcomeCallable DeleteBucketWebsiteCallable(const DeleteBucketWebsiteRequestT& request) const {
    return SubmitCallable(&S3Client::DeleteBucketWebsite, request);
  }
 
  template <typename DeleteBucketWebsiteRequestT = Model::DeleteBucketWebsiteRequest>
  void DeleteBucketWebsiteAsync(const DeleteBucketWebsiteRequestT& request, const DeleteBucketWebsiteResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3Client::DeleteBucketWebsite, request, handler, context);
  }
 
  virtual Model::DeleteObjectOutcome DeleteObject(const Model::DeleteObjectRequest& request) const;
 
  template <typename DeleteObjectRequestT = Model::DeleteObjectRequest>
  Model::DeleteObjectOutcomeCallable DeleteObjectCallable(const DeleteObjectRequestT& request) const {
    return SubmitCallable(&S3Client::DeleteObject, request);
  }
 
  template <typename DeleteObjectRequestT = Model::DeleteObjectRequest>
  void DeleteObjectAsync(const DeleteObjectRequestT& request, const DeleteObjectResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3Client::DeleteObject, request, handler, context);
  }
 
  virtual Model::DeleteObjectAnnotationOutcome DeleteObjectAnnotation(const Model::DeleteObjectAnnotationRequest& request) const;
 
  template <typename DeleteObjectAnnotationRequestT = Model::DeleteObjectAnnotationRequest>
  Model::DeleteObjectAnnotationOutcomeCallable DeleteObjectAnnotationCallable(const DeleteObjectAnnotationRequestT& request) const {
    return SubmitCallable(&S3Client::DeleteObjectAnnotation, request);
  }
 
  template <typename DeleteObjectAnnotationRequestT = Model::DeleteObjectAnnotationRequest>
  void DeleteObjectAnnotationAsync(const DeleteObjectAnnotationRequestT& request,
                                   const DeleteObjectAnnotationResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3Client::DeleteObjectAnnotation, request, handler, context);
  }
 
  virtual Model::DeleteObjectTaggingOutcome DeleteObjectTagging(const Model::DeleteObjectTaggingRequest& request) const;
 
  template <typename DeleteObjectTaggingRequestT = Model::DeleteObjectTaggingRequest>
  Model::DeleteObjectTaggingOutcomeCallable DeleteObjectTaggingCallable(const DeleteObjectTaggingRequestT& request) const {
    return SubmitCallable(&S3Client::DeleteObjectTagging, request);
  }
 
  template <typename DeleteObjectTaggingRequestT = Model::DeleteObjectTaggingRequest>
  void DeleteObjectTaggingAsync(const DeleteObjectTaggingRequestT& request, const DeleteObjectTaggingResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3Client::DeleteObjectTagging, request, handler, context);
  }
 
  virtual Model::DeleteObjectsOutcome DeleteObjects(const Model::DeleteObjectsRequest& request) const;
 
  template <typename DeleteObjectsRequestT = Model::DeleteObjectsRequest>
  Model::DeleteObjectsOutcomeCallable DeleteObjectsCallable(const DeleteObjectsRequestT& request) const {
    return SubmitCallable(&S3Client::DeleteObjects, request);
  }
 
  template <typename DeleteObjectsRequestT = Model::DeleteObjectsRequest>
  void DeleteObjectsAsync(const DeleteObjectsRequestT& request, const DeleteObjectsResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3Client::DeleteObjects, request, handler, context);
  }
 
  virtual Model::DeletePublicAccessBlockOutcome DeletePublicAccessBlock(const Model::DeletePublicAccessBlockRequest& request) const;
 
  template <typename DeletePublicAccessBlockRequestT = Model::DeletePublicAccessBlockRequest>
  Model::DeletePublicAccessBlockOutcomeCallable DeletePublicAccessBlockCallable(const DeletePublicAccessBlockRequestT& request) const {
    return SubmitCallable(&S3Client::DeletePublicAccessBlock, request);
  }
 
  template <typename DeletePublicAccessBlockRequestT = Model::DeletePublicAccessBlockRequest>
  void DeletePublicAccessBlockAsync(const DeletePublicAccessBlockRequestT& request,
                                    const DeletePublicAccessBlockResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3Client::DeletePublicAccessBlock, request, handler, context);
  }
 
  virtual Model::GetBucketAbacOutcome GetBucketAbac(const Model::GetBucketAbacRequest& request) const;
 
  template <typename GetBucketAbacRequestT = Model::GetBucketAbacRequest>
  Model::GetBucketAbacOutcomeCallable GetBucketAbacCallable(const GetBucketAbacRequestT& request) const {
    return SubmitCallable(&S3Client::GetBucketAbac, request);
  }
 
  template <typename GetBucketAbacRequestT = Model::GetBucketAbacRequest>
  void GetBucketAbacAsync(const GetBucketAbacRequestT& request, const GetBucketAbacResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3Client::GetBucketAbac, request, handler, context);
  }
 
  virtual Model::GetBucketAccelerateConfigurationOutcome GetBucketAccelerateConfiguration(
      const Model::GetBucketAccelerateConfigurationRequest& request) const;
 
  template <typename GetBucketAccelerateConfigurationRequestT = Model::GetBucketAccelerateConfigurationRequest>
  Model::GetBucketAccelerateConfigurationOutcomeCallable GetBucketAccelerateConfigurationCallable(
      const GetBucketAccelerateConfigurationRequestT& request) const {
    return SubmitCallable(&S3Client::GetBucketAccelerateConfiguration, request);
  }
 
  template <typename GetBucketAccelerateConfigurationRequestT = Model::GetBucketAccelerateConfigurationRequest>
  void GetBucketAccelerateConfigurationAsync(const GetBucketAccelerateConfigurationRequestT& request,
                                             const GetBucketAccelerateConfigurationResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3Client::GetBucketAccelerateConfiguration, request, handler, context);
  }
 
  virtual Model::GetBucketAclOutcome GetBucketAcl(const Model::GetBucketAclRequest& request) const;
 
  template <typename GetBucketAclRequestT = Model::GetBucketAclRequest>
  Model::GetBucketAclOutcomeCallable GetBucketAclCallable(const GetBucketAclRequestT& request) const {
    return SubmitCallable(&S3Client::GetBucketAcl, request);
  }
 
  template <typename GetBucketAclRequestT = Model::GetBucketAclRequest>
  void GetBucketAclAsync(const GetBucketAclRequestT& request, const GetBucketAclResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3Client::GetBucketAcl, request, handler, context);
  }
 
  virtual Model::GetBucketAnalyticsConfigurationOutcome GetBucketAnalyticsConfiguration(
      const Model::GetBucketAnalyticsConfigurationRequest& request) const;
 
  template <typename GetBucketAnalyticsConfigurationRequestT = Model::GetBucketAnalyticsConfigurationRequest>
  Model::GetBucketAnalyticsConfigurationOutcomeCallable GetBucketAnalyticsConfigurationCallable(
      const GetBucketAnalyticsConfigurationRequestT& request) const {
    return SubmitCallable(&S3Client::GetBucketAnalyticsConfiguration, request);
  }
 
  template <typename GetBucketAnalyticsConfigurationRequestT = Model::GetBucketAnalyticsConfigurationRequest>
  void GetBucketAnalyticsConfigurationAsync(const GetBucketAnalyticsConfigurationRequestT& request,
                                            const GetBucketAnalyticsConfigurationResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3Client::GetBucketAnalyticsConfiguration, request, handler, context);
  }
 
  virtual Model::GetBucketCorsOutcome GetBucketCors(const Model::GetBucketCorsRequest& request) const;
 
  template <typename GetBucketCorsRequestT = Model::GetBucketCorsRequest>
  Model::GetBucketCorsOutcomeCallable GetBucketCorsCallable(const GetBucketCorsRequestT& request) const {
    return SubmitCallable(&S3Client::GetBucketCors, request);
  }
 
  template <typename GetBucketCorsRequestT = Model::GetBucketCorsRequest>
  void GetBucketCorsAsync(const GetBucketCorsRequestT& request, const GetBucketCorsResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3Client::GetBucketCors, request, handler, context);
  }
 
  virtual Model::GetBucketEncryptionOutcome GetBucketEncryption(const Model::GetBucketEncryptionRequest& request) const;
 
  template <typename GetBucketEncryptionRequestT = Model::GetBucketEncryptionRequest>
  Model::GetBucketEncryptionOutcomeCallable GetBucketEncryptionCallable(const GetBucketEncryptionRequestT& request) const {
    return SubmitCallable(&S3Client::GetBucketEncryption, request);
  }
 
  template <typename GetBucketEncryptionRequestT = Model::GetBucketEncryptionRequest>
  void GetBucketEncryptionAsync(const GetBucketEncryptionRequestT& request, const GetBucketEncryptionResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3Client::GetBucketEncryption, request, handler, context);
  }
 
  virtual Model::GetBucketIntelligentTieringConfigurationOutcome GetBucketIntelligentTieringConfiguration(
      const Model::GetBucketIntelligentTieringConfigurationRequest& request) const;
 
  template <typename GetBucketIntelligentTieringConfigurationRequestT = Model::GetBucketIntelligentTieringConfigurationRequest>
  Model::GetBucketIntelligentTieringConfigurationOutcomeCallable GetBucketIntelligentTieringConfigurationCallable(
      const GetBucketIntelligentTieringConfigurationRequestT& request) const {
    return SubmitCallable(&S3Client::GetBucketIntelligentTieringConfiguration, request);
  }
 
  template <typename GetBucketIntelligentTieringConfigurationRequestT = Model::GetBucketIntelligentTieringConfigurationRequest>
  void GetBucketIntelligentTieringConfigurationAsync(
      const GetBucketIntelligentTieringConfigurationRequestT& request,
      const GetBucketIntelligentTieringConfigurationResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3Client::GetBucketIntelligentTieringConfiguration, request, handler, context);
  }
 
  virtual Model::GetBucketInventoryConfigurationOutcome GetBucketInventoryConfiguration(
      const Model::GetBucketInventoryConfigurationRequest& request) const;
 
  template <typename GetBucketInventoryConfigurationRequestT = Model::GetBucketInventoryConfigurationRequest>
  Model::GetBucketInventoryConfigurationOutcomeCallable GetBucketInventoryConfigurationCallable(
      const GetBucketInventoryConfigurationRequestT& request) const {
    return SubmitCallable(&S3Client::GetBucketInventoryConfiguration, request);
  }
 
  template <typename GetBucketInventoryConfigurationRequestT = Model::GetBucketInventoryConfigurationRequest>
  void GetBucketInventoryConfigurationAsync(const GetBucketInventoryConfigurationRequestT& request,
                                            const GetBucketInventoryConfigurationResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3Client::GetBucketInventoryConfiguration, request, handler, context);
  }
 
  virtual Model::GetBucketLifecycleConfigurationOutcome GetBucketLifecycleConfiguration(
      const Model::GetBucketLifecycleConfigurationRequest& request) const;
 
  template <typename GetBucketLifecycleConfigurationRequestT = Model::GetBucketLifecycleConfigurationRequest>
  Model::GetBucketLifecycleConfigurationOutcomeCallable GetBucketLifecycleConfigurationCallable(
      const GetBucketLifecycleConfigurationRequestT& request) const {
    return SubmitCallable(&S3Client::GetBucketLifecycleConfiguration, request);
  }
 
  template <typename GetBucketLifecycleConfigurationRequestT = Model::GetBucketLifecycleConfigurationRequest>
  void GetBucketLifecycleConfigurationAsync(const GetBucketLifecycleConfigurationRequestT& request,
                                            const GetBucketLifecycleConfigurationResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3Client::GetBucketLifecycleConfiguration, request, handler, context);
  }
 
  virtual Model::GetBucketLocationOutcome GetBucketLocation(const Model::GetBucketLocationRequest& request) const;
 
  template <typename GetBucketLocationRequestT = Model::GetBucketLocationRequest>
  Model::GetBucketLocationOutcomeCallable GetBucketLocationCallable(const GetBucketLocationRequestT& request) const {
    return SubmitCallable(&S3Client::GetBucketLocation, request);
  }
 
  template <typename GetBucketLocationRequestT = Model::GetBucketLocationRequest>
  void GetBucketLocationAsync(const GetBucketLocationRequestT& request, const GetBucketLocationResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3Client::GetBucketLocation, request, handler, context);
  }
 
  virtual Model::GetBucketLoggingOutcome GetBucketLogging(const Model::GetBucketLoggingRequest& request) const;
 
  template <typename GetBucketLoggingRequestT = Model::GetBucketLoggingRequest>
  Model::GetBucketLoggingOutcomeCallable GetBucketLoggingCallable(const GetBucketLoggingRequestT& request) const {
    return SubmitCallable(&S3Client::GetBucketLogging, request);
  }
 
  template <typename GetBucketLoggingRequestT = Model::GetBucketLoggingRequest>
  void GetBucketLoggingAsync(const GetBucketLoggingRequestT& request, const GetBucketLoggingResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3Client::GetBucketLogging, request, handler, context);
  }
 
  virtual Model::GetBucketMetadataConfigurationOutcome GetBucketMetadataConfiguration(
      const Model::GetBucketMetadataConfigurationRequest& request) const;
 
  template <typename GetBucketMetadataConfigurationRequestT = Model::GetBucketMetadataConfigurationRequest>
  Model::GetBucketMetadataConfigurationOutcomeCallable GetBucketMetadataConfigurationCallable(
      const GetBucketMetadataConfigurationRequestT& request) const {
    return SubmitCallable(&S3Client::GetBucketMetadataConfiguration, request);
  }
 
  template <typename GetBucketMetadataConfigurationRequestT = Model::GetBucketMetadataConfigurationRequest>
  void GetBucketMetadataConfigurationAsync(const GetBucketMetadataConfigurationRequestT& request,
                                           const GetBucketMetadataConfigurationResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3Client::GetBucketMetadataConfiguration, request, handler, context);
  }
 
  virtual Model::GetBucketMetadataTableConfigurationOutcome GetBucketMetadataTableConfiguration(
      const Model::GetBucketMetadataTableConfigurationRequest& request) const;
 
  template <typename GetBucketMetadataTableConfigurationRequestT = Model::GetBucketMetadataTableConfigurationRequest>
  Model::GetBucketMetadataTableConfigurationOutcomeCallable GetBucketMetadataTableConfigurationCallable(
      const GetBucketMetadataTableConfigurationRequestT& request) const {
    return SubmitCallable(&S3Client::GetBucketMetadataTableConfiguration, request);
  }
 
  template <typename GetBucketMetadataTableConfigurationRequestT = Model::GetBucketMetadataTableConfigurationRequest>
  void GetBucketMetadataTableConfigurationAsync(const GetBucketMetadataTableConfigurationRequestT& request,
                                                const GetBucketMetadataTableConfigurationResponseReceivedHandler& handler,
                                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3Client::GetBucketMetadataTableConfiguration, request, handler, context);
  }
 
  virtual Model::GetBucketMetricsConfigurationOutcome GetBucketMetricsConfiguration(
      const Model::GetBucketMetricsConfigurationRequest& request) const;
 
  template <typename GetBucketMetricsConfigurationRequestT = Model::GetBucketMetricsConfigurationRequest>
  Model::GetBucketMetricsConfigurationOutcomeCallable GetBucketMetricsConfigurationCallable(
      const GetBucketMetricsConfigurationRequestT& request) const {
    return SubmitCallable(&S3Client::GetBucketMetricsConfiguration, request);
  }
 
  template <typename GetBucketMetricsConfigurationRequestT = Model::GetBucketMetricsConfigurationRequest>
  void GetBucketMetricsConfigurationAsync(const GetBucketMetricsConfigurationRequestT& request,
                                          const GetBucketMetricsConfigurationResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3Client::GetBucketMetricsConfiguration, request, handler, context);
  }
 
  virtual Model::GetBucketNotificationConfigurationOutcome GetBucketNotificationConfiguration(
      const Model::GetBucketNotificationConfigurationRequest& request) const;
 
  template <typename GetBucketNotificationConfigurationRequestT = Model::GetBucketNotificationConfigurationRequest>
  Model::GetBucketNotificationConfigurationOutcomeCallable GetBucketNotificationConfigurationCallable(
      const GetBucketNotificationConfigurationRequestT& request) const {
    return SubmitCallable(&S3Client::GetBucketNotificationConfiguration, request);
  }
 
  template <typename GetBucketNotificationConfigurationRequestT = Model::GetBucketNotificationConfigurationRequest>
  void GetBucketNotificationConfigurationAsync(const GetBucketNotificationConfigurationRequestT& request,
                                               const GetBucketNotificationConfigurationResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3Client::GetBucketNotificationConfiguration, request, handler, context);
  }
 
  virtual Model::GetBucketOwnershipControlsOutcome GetBucketOwnershipControls(
      const Model::GetBucketOwnershipControlsRequest& request) const;
 
  template <typename GetBucketOwnershipControlsRequestT = Model::GetBucketOwnershipControlsRequest>
  Model::GetBucketOwnershipControlsOutcomeCallable GetBucketOwnershipControlsCallable(
      const GetBucketOwnershipControlsRequestT& request) const {
    return SubmitCallable(&S3Client::GetBucketOwnershipControls, request);
  }
 
  template <typename GetBucketOwnershipControlsRequestT = Model::GetBucketOwnershipControlsRequest>
  void GetBucketOwnershipControlsAsync(const GetBucketOwnershipControlsRequestT& request,
                                       const GetBucketOwnershipControlsResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3Client::GetBucketOwnershipControls, request, handler, context);
  }
 
  virtual Model::GetBucketPolicyOutcome GetBucketPolicy(const Model::GetBucketPolicyRequest& request) const;
 
  template <typename GetBucketPolicyRequestT = Model::GetBucketPolicyRequest>
  Model::GetBucketPolicyOutcomeCallable GetBucketPolicyCallable(const GetBucketPolicyRequestT& request) const {
    return SubmitCallable(&S3Client::GetBucketPolicy, request);
  }
 
  template <typename GetBucketPolicyRequestT = Model::GetBucketPolicyRequest>
  void GetBucketPolicyAsync(const GetBucketPolicyRequestT& request, const GetBucketPolicyResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3Client::GetBucketPolicy, request, handler, context);
  }
 
  virtual Model::GetBucketPolicyStatusOutcome GetBucketPolicyStatus(const Model::GetBucketPolicyStatusRequest& request) const;
 
  template <typename GetBucketPolicyStatusRequestT = Model::GetBucketPolicyStatusRequest>
  Model::GetBucketPolicyStatusOutcomeCallable GetBucketPolicyStatusCallable(const GetBucketPolicyStatusRequestT& request) const {
    return SubmitCallable(&S3Client::GetBucketPolicyStatus, request);
  }
 
  template <typename GetBucketPolicyStatusRequestT = Model::GetBucketPolicyStatusRequest>
  void GetBucketPolicyStatusAsync(const GetBucketPolicyStatusRequestT& request, const GetBucketPolicyStatusResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3Client::GetBucketPolicyStatus, request, handler, context);
  }
 
  virtual Model::GetBucketReplicationOutcome GetBucketReplication(const Model::GetBucketReplicationRequest& request) const;
 
  template <typename GetBucketReplicationRequestT = Model::GetBucketReplicationRequest>
  Model::GetBucketReplicationOutcomeCallable GetBucketReplicationCallable(const GetBucketReplicationRequestT& request) const {
    return SubmitCallable(&S3Client::GetBucketReplication, request);
  }
 
  template <typename GetBucketReplicationRequestT = Model::GetBucketReplicationRequest>
  void GetBucketReplicationAsync(const GetBucketReplicationRequestT& request, const GetBucketReplicationResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3Client::GetBucketReplication, request, handler, context);
  }
 
  virtual Model::GetBucketRequestPaymentOutcome GetBucketRequestPayment(const Model::GetBucketRequestPaymentRequest& request) const;
 
  template <typename GetBucketRequestPaymentRequestT = Model::GetBucketRequestPaymentRequest>
  Model::GetBucketRequestPaymentOutcomeCallable GetBucketRequestPaymentCallable(const GetBucketRequestPaymentRequestT& request) const {
    return SubmitCallable(&S3Client::GetBucketRequestPayment, request);
  }
 
  template <typename GetBucketRequestPaymentRequestT = Model::GetBucketRequestPaymentRequest>
  void GetBucketRequestPaymentAsync(const GetBucketRequestPaymentRequestT& request,
                                    const GetBucketRequestPaymentResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3Client::GetBucketRequestPayment, request, handler, context);
  }
 
  virtual Model::GetBucketTaggingOutcome GetBucketTagging(const Model::GetBucketTaggingRequest& request) const;
 
  template <typename GetBucketTaggingRequestT = Model::GetBucketTaggingRequest>
  Model::GetBucketTaggingOutcomeCallable GetBucketTaggingCallable(const GetBucketTaggingRequestT& request) const {
    return SubmitCallable(&S3Client::GetBucketTagging, request);
  }
 
  template <typename GetBucketTaggingRequestT = Model::GetBucketTaggingRequest>
  void GetBucketTaggingAsync(const GetBucketTaggingRequestT& request, const GetBucketTaggingResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3Client::GetBucketTagging, request, handler, context);
  }
 
  virtual Model::GetBucketVersioningOutcome GetBucketVersioning(const Model::GetBucketVersioningRequest& request) const;
 
  template <typename GetBucketVersioningRequestT = Model::GetBucketVersioningRequest>
  Model::GetBucketVersioningOutcomeCallable GetBucketVersioningCallable(const GetBucketVersioningRequestT& request) const {
    return SubmitCallable(&S3Client::GetBucketVersioning, request);
  }
 
  template <typename GetBucketVersioningRequestT = Model::GetBucketVersioningRequest>
  void GetBucketVersioningAsync(const GetBucketVersioningRequestT& request, const GetBucketVersioningResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3Client::GetBucketVersioning, request, handler, context);
  }
 
  virtual Model::GetBucketWebsiteOutcome GetBucketWebsite(const Model::GetBucketWebsiteRequest& request) const;
 
  template <typename GetBucketWebsiteRequestT = Model::GetBucketWebsiteRequest>
  Model::GetBucketWebsiteOutcomeCallable GetBucketWebsiteCallable(const GetBucketWebsiteRequestT& request) const {
    return SubmitCallable(&S3Client::GetBucketWebsite, request);
  }
 
  template <typename GetBucketWebsiteRequestT = Model::GetBucketWebsiteRequest>
  void GetBucketWebsiteAsync(const GetBucketWebsiteRequestT& request, const GetBucketWebsiteResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3Client::GetBucketWebsite, request, handler, context);
  }
 
  virtual Model::GetObjectOutcome GetObject(const Model::GetObjectRequest& request) const;
 
  virtual Model::GetObjectOutcomeCallable GetObjectCallable(const Model::GetObjectRequest& request) const;
 
  virtual void GetObjectAsync(const Model::GetObjectRequest& request, const GetObjectResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
 
  virtual Model::GetObjectAclOutcome GetObjectAcl(const Model::GetObjectAclRequest& request) const;
 
  template <typename GetObjectAclRequestT = Model::GetObjectAclRequest>
  Model::GetObjectAclOutcomeCallable GetObjectAclCallable(const GetObjectAclRequestT& request) const {
    return SubmitCallable(&S3Client::GetObjectAcl, request);
  }
 
  template <typename GetObjectAclRequestT = Model::GetObjectAclRequest>
  void GetObjectAclAsync(const GetObjectAclRequestT& request, const GetObjectAclResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3Client::GetObjectAcl, request, handler, context);
  }
 
  virtual Model::GetObjectAnnotationOutcome GetObjectAnnotation(const Model::GetObjectAnnotationRequest& request) const;
 
  template <typename GetObjectAnnotationRequestT = Model::GetObjectAnnotationRequest>
  Model::GetObjectAnnotationOutcomeCallable GetObjectAnnotationCallable(const GetObjectAnnotationRequestT& request) const {
    return SubmitCallable(&S3Client::GetObjectAnnotation, request);
  }
 
  template <typename GetObjectAnnotationRequestT = Model::GetObjectAnnotationRequest>
  void GetObjectAnnotationAsync(const GetObjectAnnotationRequestT& request, const GetObjectAnnotationResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3Client::GetObjectAnnotation, request, handler, context);
  }
 
  virtual Model::GetObjectAttributesOutcome GetObjectAttributes(const Model::GetObjectAttributesRequest& request) const;
 
  template <typename GetObjectAttributesRequestT = Model::GetObjectAttributesRequest>
  Model::GetObjectAttributesOutcomeCallable GetObjectAttributesCallable(const GetObjectAttributesRequestT& request) const {
    return SubmitCallable(&S3Client::GetObjectAttributes, request);
  }
 
  template <typename GetObjectAttributesRequestT = Model::GetObjectAttributesRequest>
  void GetObjectAttributesAsync(const GetObjectAttributesRequestT& request, const GetObjectAttributesResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3Client::GetObjectAttributes, request, handler, context);
  }
 
  virtual Model::GetObjectLegalHoldOutcome GetObjectLegalHold(const Model::GetObjectLegalHoldRequest& request) const;
 
  template <typename GetObjectLegalHoldRequestT = Model::GetObjectLegalHoldRequest>
  Model::GetObjectLegalHoldOutcomeCallable GetObjectLegalHoldCallable(const GetObjectLegalHoldRequestT& request) const {
    return SubmitCallable(&S3Client::GetObjectLegalHold, request);
  }
 
  template <typename GetObjectLegalHoldRequestT = Model::GetObjectLegalHoldRequest>
  void GetObjectLegalHoldAsync(const GetObjectLegalHoldRequestT& request, const GetObjectLegalHoldResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3Client::GetObjectLegalHold, request, handler, context);
  }
 
  virtual Model::GetObjectLockConfigurationOutcome GetObjectLockConfiguration(
      const Model::GetObjectLockConfigurationRequest& request) const;
 
  template <typename GetObjectLockConfigurationRequestT = Model::GetObjectLockConfigurationRequest>
  Model::GetObjectLockConfigurationOutcomeCallable GetObjectLockConfigurationCallable(
      const GetObjectLockConfigurationRequestT& request) const {
    return SubmitCallable(&S3Client::GetObjectLockConfiguration, request);
  }
 
  template <typename GetObjectLockConfigurationRequestT = Model::GetObjectLockConfigurationRequest>
  void GetObjectLockConfigurationAsync(const GetObjectLockConfigurationRequestT& request,
                                       const GetObjectLockConfigurationResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3Client::GetObjectLockConfiguration, request, handler, context);
  }
 
  virtual Model::GetObjectRetentionOutcome GetObjectRetention(const Model::GetObjectRetentionRequest& request) const;
 
  template <typename GetObjectRetentionRequestT = Model::GetObjectRetentionRequest>
  Model::GetObjectRetentionOutcomeCallable GetObjectRetentionCallable(const GetObjectRetentionRequestT& request) const {
    return SubmitCallable(&S3Client::GetObjectRetention, request);
  }
 
  template <typename GetObjectRetentionRequestT = Model::GetObjectRetentionRequest>
  void GetObjectRetentionAsync(const GetObjectRetentionRequestT& request, const GetObjectRetentionResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3Client::GetObjectRetention, request, handler, context);
  }
 
  virtual Model::GetObjectTaggingOutcome GetObjectTagging(const Model::GetObjectTaggingRequest& request) const;
 
  template <typename GetObjectTaggingRequestT = Model::GetObjectTaggingRequest>
  Model::GetObjectTaggingOutcomeCallable GetObjectTaggingCallable(const GetObjectTaggingRequestT& request) const {
    return SubmitCallable(&S3Client::GetObjectTagging, request);
  }
 
  template <typename GetObjectTaggingRequestT = Model::GetObjectTaggingRequest>
  void GetObjectTaggingAsync(const GetObjectTaggingRequestT& request, const GetObjectTaggingResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3Client::GetObjectTagging, request, handler, context);
  }
 
  virtual Model::GetObjectTorrentOutcome GetObjectTorrent(const Model::GetObjectTorrentRequest& request) const;
 
  template <typename GetObjectTorrentRequestT = Model::GetObjectTorrentRequest>
  Model::GetObjectTorrentOutcomeCallable GetObjectTorrentCallable(const GetObjectTorrentRequestT& request) const {
    return SubmitCallable(&S3Client::GetObjectTorrent, request);
  }
 
  template <typename GetObjectTorrentRequestT = Model::GetObjectTorrentRequest>
  void GetObjectTorrentAsync(const GetObjectTorrentRequestT& request, const GetObjectTorrentResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3Client::GetObjectTorrent, request, handler, context);
  }
 
  virtual Model::GetPublicAccessBlockOutcome GetPublicAccessBlock(const Model::GetPublicAccessBlockRequest& request) const;
 
  template <typename GetPublicAccessBlockRequestT = Model::GetPublicAccessBlockRequest>
  Model::GetPublicAccessBlockOutcomeCallable GetPublicAccessBlockCallable(const GetPublicAccessBlockRequestT& request) const {
    return SubmitCallable(&S3Client::GetPublicAccessBlock, request);
  }
 
  template <typename GetPublicAccessBlockRequestT = Model::GetPublicAccessBlockRequest>
  void GetPublicAccessBlockAsync(const GetPublicAccessBlockRequestT& request, const GetPublicAccessBlockResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3Client::GetPublicAccessBlock, request, handler, context);
  }
 
  virtual Model::HeadBucketOutcome HeadBucket(const Model::HeadBucketRequest& request) const;
 
  template <typename HeadBucketRequestT = Model::HeadBucketRequest>
  Model::HeadBucketOutcomeCallable HeadBucketCallable(const HeadBucketRequestT& request) const {
    return SubmitCallable(&S3Client::HeadBucket, request);
  }
 
  template <typename HeadBucketRequestT = Model::HeadBucketRequest>
  void HeadBucketAsync(const HeadBucketRequestT& request, const HeadBucketResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3Client::HeadBucket, request, handler, context);
  }
 
  virtual Model::HeadObjectOutcome HeadObject(const Model::HeadObjectRequest& request) const;
 
  template <typename HeadObjectRequestT = Model::HeadObjectRequest>
  Model::HeadObjectOutcomeCallable HeadObjectCallable(const HeadObjectRequestT& request) const {
    return SubmitCallable(&S3Client::HeadObject, request);
  }
 
  template <typename HeadObjectRequestT = Model::HeadObjectRequest>
  void HeadObjectAsync(const HeadObjectRequestT& request, const HeadObjectResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3Client::HeadObject, request, handler, context);
  }
 
  virtual Model::ListBucketAnalyticsConfigurationsOutcome ListBucketAnalyticsConfigurations(
      const Model::ListBucketAnalyticsConfigurationsRequest& request) const;
 
  template <typename ListBucketAnalyticsConfigurationsRequestT = Model::ListBucketAnalyticsConfigurationsRequest>
  Model::ListBucketAnalyticsConfigurationsOutcomeCallable ListBucketAnalyticsConfigurationsCallable(
      const ListBucketAnalyticsConfigurationsRequestT& request) const {
    return SubmitCallable(&S3Client::ListBucketAnalyticsConfigurations, request);
  }
 
  template <typename ListBucketAnalyticsConfigurationsRequestT = Model::ListBucketAnalyticsConfigurationsRequest>
  void ListBucketAnalyticsConfigurationsAsync(const ListBucketAnalyticsConfigurationsRequestT& request,
                                              const ListBucketAnalyticsConfigurationsResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3Client::ListBucketAnalyticsConfigurations, request, handler, context);
  }
 
  virtual Model::ListBucketIntelligentTieringConfigurationsOutcome ListBucketIntelligentTieringConfigurations(
      const Model::ListBucketIntelligentTieringConfigurationsRequest& request) const;
 
  template <typename ListBucketIntelligentTieringConfigurationsRequestT = Model::ListBucketIntelligentTieringConfigurationsRequest>
  Model::ListBucketIntelligentTieringConfigurationsOutcomeCallable ListBucketIntelligentTieringConfigurationsCallable(
      const ListBucketIntelligentTieringConfigurationsRequestT& request) const {
    return SubmitCallable(&S3Client::ListBucketIntelligentTieringConfigurations, request);
  }
 
  template <typename ListBucketIntelligentTieringConfigurationsRequestT = Model::ListBucketIntelligentTieringConfigurationsRequest>
  void ListBucketIntelligentTieringConfigurationsAsync(
      const ListBucketIntelligentTieringConfigurationsRequestT& request,
      const ListBucketIntelligentTieringConfigurationsResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3Client::ListBucketIntelligentTieringConfigurations, request, handler, context);
  }
 
  virtual Model::ListBucketInventoryConfigurationsOutcome ListBucketInventoryConfigurations(
      const Model::ListBucketInventoryConfigurationsRequest& request) const;
 
  template <typename ListBucketInventoryConfigurationsRequestT = Model::ListBucketInventoryConfigurationsRequest>
  Model::ListBucketInventoryConfigurationsOutcomeCallable ListBucketInventoryConfigurationsCallable(
      const ListBucketInventoryConfigurationsRequestT& request) const {
    return SubmitCallable(&S3Client::ListBucketInventoryConfigurations, request);
  }
 
  template <typename ListBucketInventoryConfigurationsRequestT = Model::ListBucketInventoryConfigurationsRequest>
  void ListBucketInventoryConfigurationsAsync(const ListBucketInventoryConfigurationsRequestT& request,
                                              const ListBucketInventoryConfigurationsResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3Client::ListBucketInventoryConfigurations, request, handler, context);
  }
 
  virtual Model::ListBucketMetricsConfigurationsOutcome ListBucketMetricsConfigurations(
      const Model::ListBucketMetricsConfigurationsRequest& request) const;
 
  template <typename ListBucketMetricsConfigurationsRequestT = Model::ListBucketMetricsConfigurationsRequest>
  Model::ListBucketMetricsConfigurationsOutcomeCallable ListBucketMetricsConfigurationsCallable(
      const ListBucketMetricsConfigurationsRequestT& request) const {
    return SubmitCallable(&S3Client::ListBucketMetricsConfigurations, request);
  }
 
  template <typename ListBucketMetricsConfigurationsRequestT = Model::ListBucketMetricsConfigurationsRequest>
  void ListBucketMetricsConfigurationsAsync(const ListBucketMetricsConfigurationsRequestT& request,
                                            const ListBucketMetricsConfigurationsResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3Client::ListBucketMetricsConfigurations, request, handler, context);
  }
 
  virtual Model::ListBucketsOutcome ListBuckets(const Model::ListBucketsRequest& request = {}) const;
 
  template <typename ListBucketsRequestT = Model::ListBucketsRequest>
  Model::ListBucketsOutcomeCallable ListBucketsCallable(const ListBucketsRequestT& request = {}) const {
    return SubmitCallable(&S3Client::ListBuckets, request);
  }
 
  template <typename ListBucketsRequestT = Model::ListBucketsRequest>
  void ListBucketsAsync(const ListBucketsResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                        const ListBucketsRequestT& request = {}) const {
    return SubmitAsync(&S3Client::ListBuckets, request, handler, context);
  }
 
  virtual Model::ListDirectoryBucketsOutcome ListDirectoryBuckets(const Model::ListDirectoryBucketsRequest& request = {}) const;
 
  template <typename ListDirectoryBucketsRequestT = Model::ListDirectoryBucketsRequest>
  Model::ListDirectoryBucketsOutcomeCallable ListDirectoryBucketsCallable(const ListDirectoryBucketsRequestT& request = {}) const {
    return SubmitCallable(&S3Client::ListDirectoryBuckets, request);
  }
 
  template <typename ListDirectoryBucketsRequestT = Model::ListDirectoryBucketsRequest>
  void ListDirectoryBucketsAsync(const ListDirectoryBucketsResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                 const ListDirectoryBucketsRequestT& request = {}) const {
    return SubmitAsync(&S3Client::ListDirectoryBuckets, request, handler, context);
  }
 
  virtual Model::ListMultipartUploadsOutcome ListMultipartUploads(const Model::ListMultipartUploadsRequest& request) const;
 
  template <typename ListMultipartUploadsRequestT = Model::ListMultipartUploadsRequest>
  Model::ListMultipartUploadsOutcomeCallable ListMultipartUploadsCallable(const ListMultipartUploadsRequestT& request) const {
    return SubmitCallable(&S3Client::ListMultipartUploads, request);
  }
 
  template <typename ListMultipartUploadsRequestT = Model::ListMultipartUploadsRequest>
  void ListMultipartUploadsAsync(const ListMultipartUploadsRequestT& request, const ListMultipartUploadsResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3Client::ListMultipartUploads, request, handler, context);
  }
 
  virtual Model::ListObjectAnnotationsOutcome ListObjectAnnotations(const Model::ListObjectAnnotationsRequest& request) const;
 
  template <typename ListObjectAnnotationsRequestT = Model::ListObjectAnnotationsRequest>
  Model::ListObjectAnnotationsOutcomeCallable ListObjectAnnotationsCallable(const ListObjectAnnotationsRequestT& request) const {
    return SubmitCallable(&S3Client::ListObjectAnnotations, request);
  }
 
  template <typename ListObjectAnnotationsRequestT = Model::ListObjectAnnotationsRequest>
  void ListObjectAnnotationsAsync(const ListObjectAnnotationsRequestT& request, const ListObjectAnnotationsResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3Client::ListObjectAnnotations, request, handler, context);
  }
 
  virtual Model::ListObjectVersionsOutcome ListObjectVersions(const Model::ListObjectVersionsRequest& request) const;
 
  template <typename ListObjectVersionsRequestT = Model::ListObjectVersionsRequest>
  Model::ListObjectVersionsOutcomeCallable ListObjectVersionsCallable(const ListObjectVersionsRequestT& request) const {
    return SubmitCallable(&S3Client::ListObjectVersions, request);
  }
 
  template <typename ListObjectVersionsRequestT = Model::ListObjectVersionsRequest>
  void ListObjectVersionsAsync(const ListObjectVersionsRequestT& request, const ListObjectVersionsResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3Client::ListObjectVersions, request, handler, context);
  }
 
  virtual Model::ListObjectsOutcome ListObjects(const Model::ListObjectsRequest& request) const;
 
  template <typename ListObjectsRequestT = Model::ListObjectsRequest>
  Model::ListObjectsOutcomeCallable ListObjectsCallable(const ListObjectsRequestT& request) const {
    return SubmitCallable(&S3Client::ListObjects, request);
  }
 
  template <typename ListObjectsRequestT = Model::ListObjectsRequest>
  void ListObjectsAsync(const ListObjectsRequestT& request, const ListObjectsResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3Client::ListObjects, request, handler, context);
  }
 
  virtual Model::ListObjectsV2Outcome ListObjectsV2(const Model::ListObjectsV2Request& request) const;
 
  template <typename ListObjectsV2RequestT = Model::ListObjectsV2Request>
  Model::ListObjectsV2OutcomeCallable ListObjectsV2Callable(const ListObjectsV2RequestT& request) const {
    return SubmitCallable(&S3Client::ListObjectsV2, request);
  }
 
  template <typename ListObjectsV2RequestT = Model::ListObjectsV2Request>
  void ListObjectsV2Async(const ListObjectsV2RequestT& request, const ListObjectsV2ResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3Client::ListObjectsV2, request, handler, context);
  }
 
  virtual Model::ListPartsOutcome ListParts(const Model::ListPartsRequest& request) const;
 
  template <typename ListPartsRequestT = Model::ListPartsRequest>
  Model::ListPartsOutcomeCallable ListPartsCallable(const ListPartsRequestT& request) const {
    return SubmitCallable(&S3Client::ListParts, request);
  }
 
  template <typename ListPartsRequestT = Model::ListPartsRequest>
  void ListPartsAsync(const ListPartsRequestT& request, const ListPartsResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3Client::ListParts, request, handler, context);
  }
 
  virtual Model::PutBucketAbacOutcome PutBucketAbac(const Model::PutBucketAbacRequest& request) const;
 
  template <typename PutBucketAbacRequestT = Model::PutBucketAbacRequest>
  Model::PutBucketAbacOutcomeCallable PutBucketAbacCallable(const PutBucketAbacRequestT& request) const {
    return SubmitCallable(&S3Client::PutBucketAbac, request);
  }
 
  template <typename PutBucketAbacRequestT = Model::PutBucketAbacRequest>
  void PutBucketAbacAsync(const PutBucketAbacRequestT& request, const PutBucketAbacResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3Client::PutBucketAbac, request, handler, context);
  }
 
  virtual Model::PutBucketAccelerateConfigurationOutcome PutBucketAccelerateConfiguration(
      const Model::PutBucketAccelerateConfigurationRequest& request) const;
 
  template <typename PutBucketAccelerateConfigurationRequestT = Model::PutBucketAccelerateConfigurationRequest>
  Model::PutBucketAccelerateConfigurationOutcomeCallable PutBucketAccelerateConfigurationCallable(
      const PutBucketAccelerateConfigurationRequestT& request) const {
    return SubmitCallable(&S3Client::PutBucketAccelerateConfiguration, request);
  }
 
  template <typename PutBucketAccelerateConfigurationRequestT = Model::PutBucketAccelerateConfigurationRequest>
  void PutBucketAccelerateConfigurationAsync(const PutBucketAccelerateConfigurationRequestT& request,
                                             const PutBucketAccelerateConfigurationResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3Client::PutBucketAccelerateConfiguration, request, handler, context);
  }
 
  virtual Model::PutBucketAclOutcome PutBucketAcl(const Model::PutBucketAclRequest& request) const;
 
  template <typename PutBucketAclRequestT = Model::PutBucketAclRequest>
  Model::PutBucketAclOutcomeCallable PutBucketAclCallable(const PutBucketAclRequestT& request) const {
    return SubmitCallable(&S3Client::PutBucketAcl, request);
  }
 
  template <typename PutBucketAclRequestT = Model::PutBucketAclRequest>
  void PutBucketAclAsync(const PutBucketAclRequestT& request, const PutBucketAclResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3Client::PutBucketAcl, request, handler, context);
  }
 
  virtual Model::PutBucketAnalyticsConfigurationOutcome PutBucketAnalyticsConfiguration(
      const Model::PutBucketAnalyticsConfigurationRequest& request) const;
 
  template <typename PutBucketAnalyticsConfigurationRequestT = Model::PutBucketAnalyticsConfigurationRequest>
  Model::PutBucketAnalyticsConfigurationOutcomeCallable PutBucketAnalyticsConfigurationCallable(
      const PutBucketAnalyticsConfigurationRequestT& request) const {
    return SubmitCallable(&S3Client::PutBucketAnalyticsConfiguration, request);
  }
 
  template <typename PutBucketAnalyticsConfigurationRequestT = Model::PutBucketAnalyticsConfigurationRequest>
  void PutBucketAnalyticsConfigurationAsync(const PutBucketAnalyticsConfigurationRequestT& request,
                                            const PutBucketAnalyticsConfigurationResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3Client::PutBucketAnalyticsConfiguration, request, handler, context);
  }
 
  virtual Model::PutBucketCorsOutcome PutBucketCors(const Model::PutBucketCorsRequest& request) const;
 
  template <typename PutBucketCorsRequestT = Model::PutBucketCorsRequest>
  Model::PutBucketCorsOutcomeCallable PutBucketCorsCallable(const PutBucketCorsRequestT& request) const {
    return SubmitCallable(&S3Client::PutBucketCors, request);
  }
 
  template <typename PutBucketCorsRequestT = Model::PutBucketCorsRequest>
  void PutBucketCorsAsync(const PutBucketCorsRequestT& request, const PutBucketCorsResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3Client::PutBucketCors, request, handler, context);
  }
 
  virtual Model::PutBucketEncryptionOutcome PutBucketEncryption(const Model::PutBucketEncryptionRequest& request) const;
 
  template <typename PutBucketEncryptionRequestT = Model::PutBucketEncryptionRequest>
  Model::PutBucketEncryptionOutcomeCallable PutBucketEncryptionCallable(const PutBucketEncryptionRequestT& request) const {
    return SubmitCallable(&S3Client::PutBucketEncryption, request);
  }
 
  template <typename PutBucketEncryptionRequestT = Model::PutBucketEncryptionRequest>
  void PutBucketEncryptionAsync(const PutBucketEncryptionRequestT& request, const PutBucketEncryptionResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3Client::PutBucketEncryption, request, handler, context);
  }
 
  virtual Model::PutBucketIntelligentTieringConfigurationOutcome PutBucketIntelligentTieringConfiguration(
      const Model::PutBucketIntelligentTieringConfigurationRequest& request) const;
 
  template <typename PutBucketIntelligentTieringConfigurationRequestT = Model::PutBucketIntelligentTieringConfigurationRequest>
  Model::PutBucketIntelligentTieringConfigurationOutcomeCallable PutBucketIntelligentTieringConfigurationCallable(
      const PutBucketIntelligentTieringConfigurationRequestT& request) const {
    return SubmitCallable(&S3Client::PutBucketIntelligentTieringConfiguration, request);
  }
 
  template <typename PutBucketIntelligentTieringConfigurationRequestT = Model::PutBucketIntelligentTieringConfigurationRequest>
  void PutBucketIntelligentTieringConfigurationAsync(
      const PutBucketIntelligentTieringConfigurationRequestT& request,
      const PutBucketIntelligentTieringConfigurationResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3Client::PutBucketIntelligentTieringConfiguration, request, handler, context);
  }
 
  virtual Model::PutBucketInventoryConfigurationOutcome PutBucketInventoryConfiguration(
      const Model::PutBucketInventoryConfigurationRequest& request) const;
 
  template <typename PutBucketInventoryConfigurationRequestT = Model::PutBucketInventoryConfigurationRequest>
  Model::PutBucketInventoryConfigurationOutcomeCallable PutBucketInventoryConfigurationCallable(
      const PutBucketInventoryConfigurationRequestT& request) const {
    return SubmitCallable(&S3Client::PutBucketInventoryConfiguration, request);
  }
 
  template <typename PutBucketInventoryConfigurationRequestT = Model::PutBucketInventoryConfigurationRequest>
  void PutBucketInventoryConfigurationAsync(const PutBucketInventoryConfigurationRequestT& request,
                                            const PutBucketInventoryConfigurationResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3Client::PutBucketInventoryConfiguration, request, handler, context);
  }
 
  virtual Model::PutBucketLifecycleConfigurationOutcome PutBucketLifecycleConfiguration(
      const Model::PutBucketLifecycleConfigurationRequest& request) const;
 
  template <typename PutBucketLifecycleConfigurationRequestT = Model::PutBucketLifecycleConfigurationRequest>
  Model::PutBucketLifecycleConfigurationOutcomeCallable PutBucketLifecycleConfigurationCallable(
      const PutBucketLifecycleConfigurationRequestT& request) const {
    return SubmitCallable(&S3Client::PutBucketLifecycleConfiguration, request);
  }
 
  template <typename PutBucketLifecycleConfigurationRequestT = Model::PutBucketLifecycleConfigurationRequest>
  void PutBucketLifecycleConfigurationAsync(const PutBucketLifecycleConfigurationRequestT& request,
                                            const PutBucketLifecycleConfigurationResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3Client::PutBucketLifecycleConfiguration, request, handler, context);
  }
 
  virtual Model::PutBucketLoggingOutcome PutBucketLogging(const Model::PutBucketLoggingRequest& request) const;
 
  template <typename PutBucketLoggingRequestT = Model::PutBucketLoggingRequest>
  Model::PutBucketLoggingOutcomeCallable PutBucketLoggingCallable(const PutBucketLoggingRequestT& request) const {
    return SubmitCallable(&S3Client::PutBucketLogging, request);
  }
 
  template <typename PutBucketLoggingRequestT = Model::PutBucketLoggingRequest>
  void PutBucketLoggingAsync(const PutBucketLoggingRequestT& request, const PutBucketLoggingResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3Client::PutBucketLogging, request, handler, context);
  }
 
  virtual Model::PutBucketMetricsConfigurationOutcome PutBucketMetricsConfiguration(
      const Model::PutBucketMetricsConfigurationRequest& request) const;
 
  template <typename PutBucketMetricsConfigurationRequestT = Model::PutBucketMetricsConfigurationRequest>
  Model::PutBucketMetricsConfigurationOutcomeCallable PutBucketMetricsConfigurationCallable(
      const PutBucketMetricsConfigurationRequestT& request) const {
    return SubmitCallable(&S3Client::PutBucketMetricsConfiguration, request);
  }
 
  template <typename PutBucketMetricsConfigurationRequestT = Model::PutBucketMetricsConfigurationRequest>
  void PutBucketMetricsConfigurationAsync(const PutBucketMetricsConfigurationRequestT& request,
                                          const PutBucketMetricsConfigurationResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3Client::PutBucketMetricsConfiguration, request, handler, context);
  }
 
  virtual Model::PutBucketNotificationConfigurationOutcome PutBucketNotificationConfiguration(
      const Model::PutBucketNotificationConfigurationRequest& request) const;
 
  template <typename PutBucketNotificationConfigurationRequestT = Model::PutBucketNotificationConfigurationRequest>
  Model::PutBucketNotificationConfigurationOutcomeCallable PutBucketNotificationConfigurationCallable(
      const PutBucketNotificationConfigurationRequestT& request) const {
    return SubmitCallable(&S3Client::PutBucketNotificationConfiguration, request);
  }
 
  template <typename PutBucketNotificationConfigurationRequestT = Model::PutBucketNotificationConfigurationRequest>
  void PutBucketNotificationConfigurationAsync(const PutBucketNotificationConfigurationRequestT& request,
                                               const PutBucketNotificationConfigurationResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3Client::PutBucketNotificationConfiguration, request, handler, context);
  }
 
  virtual Model::PutBucketOwnershipControlsOutcome PutBucketOwnershipControls(
      const Model::PutBucketOwnershipControlsRequest& request) const;
 
  template <typename PutBucketOwnershipControlsRequestT = Model::PutBucketOwnershipControlsRequest>
  Model::PutBucketOwnershipControlsOutcomeCallable PutBucketOwnershipControlsCallable(
      const PutBucketOwnershipControlsRequestT& request) const {
    return SubmitCallable(&S3Client::PutBucketOwnershipControls, request);
  }
 
  template <typename PutBucketOwnershipControlsRequestT = Model::PutBucketOwnershipControlsRequest>
  void PutBucketOwnershipControlsAsync(const PutBucketOwnershipControlsRequestT& request,
                                       const PutBucketOwnershipControlsResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3Client::PutBucketOwnershipControls, request, handler, context);
  }
 
  virtual Model::PutBucketPolicyOutcome PutBucketPolicy(const Model::PutBucketPolicyRequest& request) const;
 
  template <typename PutBucketPolicyRequestT = Model::PutBucketPolicyRequest>
  Model::PutBucketPolicyOutcomeCallable PutBucketPolicyCallable(const PutBucketPolicyRequestT& request) const {
    return SubmitCallable(&S3Client::PutBucketPolicy, request);
  }
 
  template <typename PutBucketPolicyRequestT = Model::PutBucketPolicyRequest>
  void PutBucketPolicyAsync(const PutBucketPolicyRequestT& request, const PutBucketPolicyResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3Client::PutBucketPolicy, request, handler, context);
  }
 
  virtual Model::PutBucketReplicationOutcome PutBucketReplication(const Model::PutBucketReplicationRequest& request) const;
 
  template <typename PutBucketReplicationRequestT = Model::PutBucketReplicationRequest>
  Model::PutBucketReplicationOutcomeCallable PutBucketReplicationCallable(const PutBucketReplicationRequestT& request) const {
    return SubmitCallable(&S3Client::PutBucketReplication, request);
  }
 
  template <typename PutBucketReplicationRequestT = Model::PutBucketReplicationRequest>
  void PutBucketReplicationAsync(const PutBucketReplicationRequestT& request, const PutBucketReplicationResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3Client::PutBucketReplication, request, handler, context);
  }
 
  virtual Model::PutBucketRequestPaymentOutcome PutBucketRequestPayment(const Model::PutBucketRequestPaymentRequest& request) const;
 
  template <typename PutBucketRequestPaymentRequestT = Model::PutBucketRequestPaymentRequest>
  Model::PutBucketRequestPaymentOutcomeCallable PutBucketRequestPaymentCallable(const PutBucketRequestPaymentRequestT& request) const {
    return SubmitCallable(&S3Client::PutBucketRequestPayment, request);
  }
 
  template <typename PutBucketRequestPaymentRequestT = Model::PutBucketRequestPaymentRequest>
  void PutBucketRequestPaymentAsync(const PutBucketRequestPaymentRequestT& request,
                                    const PutBucketRequestPaymentResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3Client::PutBucketRequestPayment, request, handler, context);
  }
 
  virtual Model::PutBucketTaggingOutcome PutBucketTagging(const Model::PutBucketTaggingRequest& request) const;
 
  template <typename PutBucketTaggingRequestT = Model::PutBucketTaggingRequest>
  Model::PutBucketTaggingOutcomeCallable PutBucketTaggingCallable(const PutBucketTaggingRequestT& request) const {
    return SubmitCallable(&S3Client::PutBucketTagging, request);
  }
 
  template <typename PutBucketTaggingRequestT = Model::PutBucketTaggingRequest>
  void PutBucketTaggingAsync(const PutBucketTaggingRequestT& request, const PutBucketTaggingResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3Client::PutBucketTagging, request, handler, context);
  }
 
  virtual Model::PutBucketVersioningOutcome PutBucketVersioning(const Model::PutBucketVersioningRequest& request) const;
 
  template <typename PutBucketVersioningRequestT = Model::PutBucketVersioningRequest>
  Model::PutBucketVersioningOutcomeCallable PutBucketVersioningCallable(const PutBucketVersioningRequestT& request) const {
    return SubmitCallable(&S3Client::PutBucketVersioning, request);
  }
 
  template <typename PutBucketVersioningRequestT = Model::PutBucketVersioningRequest>
  void PutBucketVersioningAsync(const PutBucketVersioningRequestT& request, const PutBucketVersioningResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3Client::PutBucketVersioning, request, handler, context);
  }
 
  virtual Model::PutBucketWebsiteOutcome PutBucketWebsite(const Model::PutBucketWebsiteRequest& request) const;
 
  template <typename PutBucketWebsiteRequestT = Model::PutBucketWebsiteRequest>
  Model::PutBucketWebsiteOutcomeCallable PutBucketWebsiteCallable(const PutBucketWebsiteRequestT& request) const {
    return SubmitCallable(&S3Client::PutBucketWebsite, request);
  }
 
  template <typename PutBucketWebsiteRequestT = Model::PutBucketWebsiteRequest>
  void PutBucketWebsiteAsync(const PutBucketWebsiteRequestT& request, const PutBucketWebsiteResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3Client::PutBucketWebsite, request, handler, context);
  }
 
  virtual Model::PutObjectOutcome PutObject(const Model::PutObjectRequest& request) const;
 
  virtual Model::PutObjectOutcomeCallable PutObjectCallable(const Model::PutObjectRequest& request) const;
 
  virtual void PutObjectAsync(const Model::PutObjectRequest& request, const PutObjectResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
 
  virtual Model::PutObjectAclOutcome PutObjectAcl(const Model::PutObjectAclRequest& request) const;
 
  template <typename PutObjectAclRequestT = Model::PutObjectAclRequest>
  Model::PutObjectAclOutcomeCallable PutObjectAclCallable(const PutObjectAclRequestT& request) const {
    return SubmitCallable(&S3Client::PutObjectAcl, request);
  }
 
  template <typename PutObjectAclRequestT = Model::PutObjectAclRequest>
  void PutObjectAclAsync(const PutObjectAclRequestT& request, const PutObjectAclResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3Client::PutObjectAcl, request, handler, context);
  }
 
  virtual Model::PutObjectAnnotationOutcome PutObjectAnnotation(const Model::PutObjectAnnotationRequest& request) const;
 
  template <typename PutObjectAnnotationRequestT = Model::PutObjectAnnotationRequest>
  Model::PutObjectAnnotationOutcomeCallable PutObjectAnnotationCallable(const PutObjectAnnotationRequestT& request) const {
    return SubmitCallable(&S3Client::PutObjectAnnotation, request);
  }
 
  template <typename PutObjectAnnotationRequestT = Model::PutObjectAnnotationRequest>
  void PutObjectAnnotationAsync(const PutObjectAnnotationRequestT& request, const PutObjectAnnotationResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3Client::PutObjectAnnotation, request, handler, context);
  }
 
  virtual Model::PutObjectLegalHoldOutcome PutObjectLegalHold(const Model::PutObjectLegalHoldRequest& request) const;
 
  template <typename PutObjectLegalHoldRequestT = Model::PutObjectLegalHoldRequest>
  Model::PutObjectLegalHoldOutcomeCallable PutObjectLegalHoldCallable(const PutObjectLegalHoldRequestT& request) const {
    return SubmitCallable(&S3Client::PutObjectLegalHold, request);
  }
 
  template <typename PutObjectLegalHoldRequestT = Model::PutObjectLegalHoldRequest>
  void PutObjectLegalHoldAsync(const PutObjectLegalHoldRequestT& request, const PutObjectLegalHoldResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3Client::PutObjectLegalHold, request, handler, context);
  }
 
  virtual Model::PutObjectLockConfigurationOutcome PutObjectLockConfiguration(
      const Model::PutObjectLockConfigurationRequest& request) const;
 
  template <typename PutObjectLockConfigurationRequestT = Model::PutObjectLockConfigurationRequest>
  Model::PutObjectLockConfigurationOutcomeCallable PutObjectLockConfigurationCallable(
      const PutObjectLockConfigurationRequestT& request) const {
    return SubmitCallable(&S3Client::PutObjectLockConfiguration, request);
  }
 
  template <typename PutObjectLockConfigurationRequestT = Model::PutObjectLockConfigurationRequest>
  void PutObjectLockConfigurationAsync(const PutObjectLockConfigurationRequestT& request,
                                       const PutObjectLockConfigurationResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3Client::PutObjectLockConfiguration, request, handler, context);
  }
 
  virtual Model::PutObjectRetentionOutcome PutObjectRetention(const Model::PutObjectRetentionRequest& request) const;
 
  template <typename PutObjectRetentionRequestT = Model::PutObjectRetentionRequest>
  Model::PutObjectRetentionOutcomeCallable PutObjectRetentionCallable(const PutObjectRetentionRequestT& request) const {
    return SubmitCallable(&S3Client::PutObjectRetention, request);
  }
 
  template <typename PutObjectRetentionRequestT = Model::PutObjectRetentionRequest>
  void PutObjectRetentionAsync(const PutObjectRetentionRequestT& request, const PutObjectRetentionResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3Client::PutObjectRetention, request, handler, context);
  }
 
  virtual Model::PutObjectTaggingOutcome PutObjectTagging(const Model::PutObjectTaggingRequest& request) const;
 
  template <typename PutObjectTaggingRequestT = Model::PutObjectTaggingRequest>
  Model::PutObjectTaggingOutcomeCallable PutObjectTaggingCallable(const PutObjectTaggingRequestT& request) const {
    return SubmitCallable(&S3Client::PutObjectTagging, request);
  }
 
  template <typename PutObjectTaggingRequestT = Model::PutObjectTaggingRequest>
  void PutObjectTaggingAsync(const PutObjectTaggingRequestT& request, const PutObjectTaggingResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3Client::PutObjectTagging, request, handler, context);
  }
 
  virtual Model::PutPublicAccessBlockOutcome PutPublicAccessBlock(const Model::PutPublicAccessBlockRequest& request) const;
 
  template <typename PutPublicAccessBlockRequestT = Model::PutPublicAccessBlockRequest>
  Model::PutPublicAccessBlockOutcomeCallable PutPublicAccessBlockCallable(const PutPublicAccessBlockRequestT& request) const {
    return SubmitCallable(&S3Client::PutPublicAccessBlock, request);
  }
 
  template <typename PutPublicAccessBlockRequestT = Model::PutPublicAccessBlockRequest>
  void PutPublicAccessBlockAsync(const PutPublicAccessBlockRequestT& request, const PutPublicAccessBlockResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3Client::PutPublicAccessBlock, request, handler, context);
  }
 
  virtual Model::RenameObjectOutcome RenameObject(const Model::RenameObjectRequest& request) const;
 
  template <typename RenameObjectRequestT = Model::RenameObjectRequest>
  Model::RenameObjectOutcomeCallable RenameObjectCallable(const RenameObjectRequestT& request) const {
    return SubmitCallable(&S3Client::RenameObject, request);
  }
 
  template <typename RenameObjectRequestT = Model::RenameObjectRequest>
  void RenameObjectAsync(const RenameObjectRequestT& request, const RenameObjectResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3Client::RenameObject, request, handler, context);
  }
 
  virtual Model::RestoreObjectOutcome RestoreObject(const Model::RestoreObjectRequest& request) const;
 
  template <typename RestoreObjectRequestT = Model::RestoreObjectRequest>
  Model::RestoreObjectOutcomeCallable RestoreObjectCallable(const RestoreObjectRequestT& request) const {
    return SubmitCallable(&S3Client::RestoreObject, request);
  }
 
  template <typename RestoreObjectRequestT = Model::RestoreObjectRequest>
  void RestoreObjectAsync(const RestoreObjectRequestT& request, const RestoreObjectResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3Client::RestoreObject, request, handler, context);
  }
 
  virtual Model::SelectObjectContentOutcome SelectObjectContent(Model::SelectObjectContentRequest& request) const;
 
  template <typename SelectObjectContentRequestT = Model::SelectObjectContentRequest>
  Model::SelectObjectContentOutcomeCallable SelectObjectContentCallable(SelectObjectContentRequestT& request) const {
    return SubmitCallable(&S3Client::SelectObjectContent, request);
  }
 
  template <typename SelectObjectContentRequestT = Model::SelectObjectContentRequest>
  void SelectObjectContentAsync(SelectObjectContentRequestT& request, const SelectObjectContentResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3Client::SelectObjectContent, request, handler, context);
  }
 
  virtual Model::UpdateBucketMetadataAnnotationTableConfigurationOutcome UpdateBucketMetadataAnnotationTableConfiguration(
      const Model::UpdateBucketMetadataAnnotationTableConfigurationRequest& request) const;
 
  template <
      typename UpdateBucketMetadataAnnotationTableConfigurationRequestT = Model::UpdateBucketMetadataAnnotationTableConfigurationRequest>
  Model::UpdateBucketMetadataAnnotationTableConfigurationOutcomeCallable UpdateBucketMetadataAnnotationTableConfigurationCallable(
      const UpdateBucketMetadataAnnotationTableConfigurationRequestT& request) const {
    return SubmitCallable(&S3Client::UpdateBucketMetadataAnnotationTableConfiguration, request);
  }
 
  template <
      typename UpdateBucketMetadataAnnotationTableConfigurationRequestT = Model::UpdateBucketMetadataAnnotationTableConfigurationRequest>
  void UpdateBucketMetadataAnnotationTableConfigurationAsync(
      const UpdateBucketMetadataAnnotationTableConfigurationRequestT& request,
      const UpdateBucketMetadataAnnotationTableConfigurationResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3Client::UpdateBucketMetadataAnnotationTableConfiguration, request, handler, context);
  }
 
  virtual Model::UpdateBucketMetadataInventoryTableConfigurationOutcome UpdateBucketMetadataInventoryTableConfiguration(
      const Model::UpdateBucketMetadataInventoryTableConfigurationRequest& request) const;
 
  template <
      typename UpdateBucketMetadataInventoryTableConfigurationRequestT = Model::UpdateBucketMetadataInventoryTableConfigurationRequest>
  Model::UpdateBucketMetadataInventoryTableConfigurationOutcomeCallable UpdateBucketMetadataInventoryTableConfigurationCallable(
      const UpdateBucketMetadataInventoryTableConfigurationRequestT& request) const {
    return SubmitCallable(&S3Client::UpdateBucketMetadataInventoryTableConfiguration, request);
  }
 
  template <
      typename UpdateBucketMetadataInventoryTableConfigurationRequestT = Model::UpdateBucketMetadataInventoryTableConfigurationRequest>
  void UpdateBucketMetadataInventoryTableConfigurationAsync(
      const UpdateBucketMetadataInventoryTableConfigurationRequestT& request,
      const UpdateBucketMetadataInventoryTableConfigurationResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3Client::UpdateBucketMetadataInventoryTableConfiguration, request, handler, context);
  }
 
  virtual Model::UpdateBucketMetadataJournalTableConfigurationOutcome UpdateBucketMetadataJournalTableConfiguration(
      const Model::UpdateBucketMetadataJournalTableConfigurationRequest& request) const;
 
  template <typename UpdateBucketMetadataJournalTableConfigurationRequestT = Model::UpdateBucketMetadataJournalTableConfigurationRequest>
  Model::UpdateBucketMetadataJournalTableConfigurationOutcomeCallable UpdateBucketMetadataJournalTableConfigurationCallable(
      const UpdateBucketMetadataJournalTableConfigurationRequestT& request) const {
    return SubmitCallable(&S3Client::UpdateBucketMetadataJournalTableConfiguration, request);
  }
 
  template <typename UpdateBucketMetadataJournalTableConfigurationRequestT = Model::UpdateBucketMetadataJournalTableConfigurationRequest>
  void UpdateBucketMetadataJournalTableConfigurationAsync(
      const UpdateBucketMetadataJournalTableConfigurationRequestT& request,
      const UpdateBucketMetadataJournalTableConfigurationResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3Client::UpdateBucketMetadataJournalTableConfiguration, request, handler, context);
  }
 
  virtual Model::UpdateObjectEncryptionOutcome UpdateObjectEncryption(const Model::UpdateObjectEncryptionRequest& request) const;
 
  template <typename UpdateObjectEncryptionRequestT = Model::UpdateObjectEncryptionRequest>
  Model::UpdateObjectEncryptionOutcomeCallable UpdateObjectEncryptionCallable(const UpdateObjectEncryptionRequestT& request) const {
    return SubmitCallable(&S3Client::UpdateObjectEncryption, request);
  }
 
  template <typename UpdateObjectEncryptionRequestT = Model::UpdateObjectEncryptionRequest>
  void UpdateObjectEncryptionAsync(const UpdateObjectEncryptionRequestT& request,
                                   const UpdateObjectEncryptionResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3Client::UpdateObjectEncryption, request, handler, context);
  }
 
  virtual Model::UploadPartOutcome UploadPart(const Model::UploadPartRequest& request) const;
 
  template <typename UploadPartRequestT = Model::UploadPartRequest>
  Model::UploadPartOutcomeCallable UploadPartCallable(const UploadPartRequestT& request) const {
    return SubmitCallable(&S3Client::UploadPart, request);
  }
 
  template <typename UploadPartRequestT = Model::UploadPartRequest>
  void UploadPartAsync(const UploadPartRequestT& request, const UploadPartResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3Client::UploadPart, request, handler, context);
  }
 
  virtual Model::UploadPartCopyOutcome UploadPartCopy(const Model::UploadPartCopyRequest& request) const;
 
  template <typename UploadPartCopyRequestT = Model::UploadPartCopyRequest>
  Model::UploadPartCopyOutcomeCallable UploadPartCopyCallable(const UploadPartCopyRequestT& request) const {
    return SubmitCallable(&S3Client::UploadPartCopy, request);
  }
 
  template <typename UploadPartCopyRequestT = Model::UploadPartCopyRequest>
  void UploadPartCopyAsync(const UploadPartCopyRequestT& request, const UploadPartCopyResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3Client::UploadPartCopy, request, handler, context);
  }
 
  virtual Model::WriteGetObjectResponseOutcome WriteGetObjectResponse(const Model::WriteGetObjectResponseRequest& request) const;
 
  template <typename WriteGetObjectResponseRequestT = Model::WriteGetObjectResponseRequest>
  Model::WriteGetObjectResponseOutcomeCallable WriteGetObjectResponseCallable(const WriteGetObjectResponseRequestT& request) const {
    return SubmitCallable(&S3Client::WriteGetObjectResponse, request);
  }
 
  template <typename WriteGetObjectResponseRequestT = Model::WriteGetObjectResponseRequest>
  void WriteGetObjectResponseAsync(const WriteGetObjectResponseRequestT& request,
                                   const WriteGetObjectResponseResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3Client::WriteGetObjectResponse, request, handler, context);
  }
 
  virtual Aws::String GeneratePresignedUrl(const Aws::String& bucket, const Aws::String& key, Aws::Http::HttpMethod method,
                                           uint64_t expirationInSeconds = MAX_EXPIRATION_SECONDS);
 
  virtual Aws::String GeneratePresignedUrl(const Aws::String& bucket, const Aws::String& key, Aws::Http::HttpMethod method,
                                           const Http::HeaderValueCollection& customizedHeaders,
                                           uint64_t expirationInSeconds = MAX_EXPIRATION_SECONDS);
 
  virtual Aws::String GeneratePresignedUrlWithSSES3(const Aws::String& bucket, const Aws::String& key, Aws::Http::HttpMethod method,
                                                    uint64_t expirationInSeconds = MAX_EXPIRATION_SECONDS);
  virtual Aws::String GeneratePresignedUrlWithSSES3(const Aws::String& bucket, const Aws::String& key, Aws::Http::HttpMethod method,
                                                    Http::HeaderValueCollection customizedHeaders,
                                                    uint64_t expirationInSeconds = MAX_EXPIRATION_SECONDS);
 
  virtual Aws::String GeneratePresignedUrlWithSSEKMS(const Aws::String& bucket, const Aws::String& key, Aws::Http::HttpMethod method,
                                                     const Aws::String& kmsMasterKeyId = "",
                                                     uint64_t expirationInSeconds = MAX_EXPIRATION_SECONDS);
  virtual Aws::String GeneratePresignedUrlWithSSEKMS(const Aws::String& bucket, const Aws::String& key, Aws::Http::HttpMethod method,
                                                     Http::HeaderValueCollection customizedHeaders, const Aws::String& kmsMasterKeyId = "",
                                                     uint64_t expirationInSeconds = MAX_EXPIRATION_SECONDS);
 
  virtual Aws::String GeneratePresignedUrlWithSSEC(const Aws::String& bucket, const Aws::String& key, Aws::Http::HttpMethod method,
                                                   const Aws::String& base64EncodedAES256Key,
                                                   uint64_t expirationInSeconds = MAX_EXPIRATION_SECONDS);
  virtual Aws::String GeneratePresignedUrlWithSSEC(const Aws::String& bucket, const Aws::String& key, Aws::Http::HttpMethod method,
                                                   Http::HeaderValueCollection customizedHeaders, const Aws::String& base64EncodedAES256Key,
                                                   uint64_t expirationInSeconds = MAX_EXPIRATION_SECONDS);
 
  virtual bool MultipartUploadSupported() const;
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<S3EndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<S3Client>;
  void init(const S3ClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, S3Error> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request,
                                                const std::function<void(Aws::Endpoint::ResolveEndpointOutcome&)>& resolveUri,
                                                Aws::String bucketName, Aws::Http::HttpMethod httpMethod) const;
 
  S3ClientConfiguration m_clientConfiguration;
  std::shared_ptr<S3EndpointProviderBase> m_endpointProvider;
};
 
}  // namespace S3
}  // namespace Aws