S3CrtClient.h

 
#pragma once
#include <aws/core/auth/AWSAuthSigner.h>
#include <aws/core/auth/AWSCredentialsProviderChain.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/crypto/Factories.h>
#include <aws/core/utils/xml/XmlSerializer.h>
#include <aws/crt/auth/Sigv4Signing.h>
#include <aws/crt/http/HttpRequestResponse.h>
#include <aws/s3-crt/ClientConfiguration.h>
#include <aws/s3-crt/S3CrtErrorMarshaller.h>
#include <aws/s3-crt/S3CrtIdentityProviderAdapter.h>
#include <aws/s3-crt/S3CrtPaginationBase.h>
#include <aws/s3-crt/S3CrtServiceClientModel.h>
#include <aws/s3-crt/S3CrtWaiter.h>
#include <aws/s3-crt/S3Crt_EXPORTS.h>
#include <aws/s3-crt/S3ExpressIdentityProvider.h>
#include <aws/s3/s3_client.h>
 
struct aws_s3_client;
// TODO: temporary fix for naming conflicts on Windows.
#ifdef _WIN32
#ifdef GetObject
#undef GetObject
#endif
#endif
 
namespace Aws {
namespace S3Crt {
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 S3ExpressIdentityProvider;
 
class AWS_S3CRT_API S3CrtClient : public Aws::Client::AWSXMLClient,
                                  public Aws::Client::ClientWithAsyncTemplateMethods<S3CrtClient>,
                                  public S3CrtPaginationBase<S3CrtClient>,
                                  public S3CrtWaiter<S3CrtClient> {
 public:
  typedef Aws::Client::AWSXMLClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef S3CrtClientConfiguration ClientConfigurationType;
  typedef S3CrtEndpointProvider EndpointProviderType;
 
  S3CrtClient(const S3CrtClient& rhs);
 
  S3CrtClient& operator=(const S3CrtClient& rhs);
 
  S3CrtClient(S3CrtClient&& rhs) noexcept;
 
  S3CrtClient& operator=(S3CrtClient&& rhs) noexcept;
 
  /* Legacy constructors due deprecation */
  S3CrtClient(const Aws::S3Crt::ClientConfiguration& clientConfiguration = Aws::S3Crt::ClientConfiguration(),
              Aws::Client::AWSAuthV4Signer::PayloadSigningPolicy signPayloads = Aws::Client::AWSAuthV4Signer::PayloadSigningPolicy::Never,
              bool useVirtualAddressing = true,
              Aws::S3Crt::US_EAST_1_REGIONAL_ENDPOINT_OPTION USEast1RegionalEndPointOption =
                  Aws::S3Crt::US_EAST_1_REGIONAL_ENDPOINT_OPTION::NOT_SET,
              const Aws::Auth::DefaultAWSCredentialsProviderChain& credentialsProvider = Aws::Auth::DefaultAWSCredentialsProviderChain());
 
  S3CrtClient(const Aws::Auth::AWSCredentials& credentials,
              const Aws::S3Crt::ClientConfiguration& clientConfiguration = Aws::S3Crt::ClientConfiguration(),
              Aws::Client::AWSAuthV4Signer::PayloadSigningPolicy signPayloads = Aws::Client::AWSAuthV4Signer::PayloadSigningPolicy::Never,
              bool useVirtualAddressing = true,
              Aws::S3Crt::US_EAST_1_REGIONAL_ENDPOINT_OPTION USEast1RegionalEndPointOption =
                  Aws::S3Crt::US_EAST_1_REGIONAL_ENDPOINT_OPTION::NOT_SET);
 
  S3CrtClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
              const Aws::S3Crt::ClientConfiguration& clientConfiguration = Aws::S3Crt::ClientConfiguration(),
              Aws::Client::AWSAuthV4Signer::PayloadSigningPolicy signPayloads = Aws::Client::AWSAuthV4Signer::PayloadSigningPolicy::Never,
              bool useVirtualAddressing = true,
              Aws::S3Crt::US_EAST_1_REGIONAL_ENDPOINT_OPTION USEast1RegionalEndPointOption =
                  Aws::S3Crt::US_EAST_1_REGIONAL_ENDPOINT_OPTION::NOT_SET);
 
  /* End of legacy constructors due deprecation */
  virtual ~S3CrtClient();
 
  virtual Model::AbortMultipartUploadOutcome AbortMultipartUpload(const Model::AbortMultipartUploadRequest& request) const;
 
  template <typename AbortMultipartUploadRequestT = Model::AbortMultipartUploadRequest>
  Model::AbortMultipartUploadOutcomeCallable AbortMultipartUploadCallable(const AbortMultipartUploadRequestT& request) const {
    return SubmitCallable(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::CompleteMultipartUpload, request, handler, context);
  }
 
  virtual Model::CopyObjectOutcome CopyObject(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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::DeleteObject, 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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::GetBucketWebsite, request, handler, context);
  }
 
  virtual Model::GetObjectOutcome GetObject(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(&S3CrtClient::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(&S3CrtClient::GetObjectAcl, 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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::ListMultipartUploads, 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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::PutBucketWebsite, request, handler, context);
  }
 
  virtual Model::PutObjectOutcome PutObject(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(&S3CrtClient::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(&S3CrtClient::PutObjectAcl, 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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::SelectObjectContent, 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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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(&S3CrtClient::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<S3CrtEndpointProviderBase>& accessEndpointProvider();
 
  struct CrtRequestCallbackUserData {
    const S3CrtClient* s3CrtClient;
    GetObjectResponseReceivedHandler getResponseHandler;
    PutObjectResponseReceivedHandler putResponseHandler;
    CopyObjectResponseReceivedHandler copyResponseHandler;
    std::shared_ptr<const Aws::Client::AsyncCallerContext> asyncCallerContext;
    const Aws::AmazonWebServiceRequest* originalRequest;
    std::shared_ptr<Aws::Http::HttpRequest> request;
    std::shared_ptr<Aws::Http::HttpResponse> response;
    std::shared_ptr<Aws::Crt::Http::HttpRequest> crtHttpRequest;
    Aws::UniquePtr<struct aws_s3_checksum_config> checksumConfig;
  };
 
  Aws::Client::XmlOutcome GenerateXmlOutcome(const std::shared_ptr<Http::HttpResponse>& response) const;
  Aws::Client::StreamOutcome GenerateStreamOutcome(const std::shared_ptr<Http::HttpResponse>& response) const;
 
 protected:
  void AddContentLengthToRequest(const std::shared_ptr<Aws::Http::HttpRequest>& httpRequest, const std::shared_ptr<Aws::IOStream>& body,
                                 bool isChunked) const override;
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<S3CrtClient>;
  void init(const S3Crt::ClientConfiguration& clientConfiguration,
            const std::shared_ptr<Aws::Auth::AWSCredentialsProvider> credentialsProvider);
 
  struct CrtClientShutdownCallbackDataWrapper {
    void* data;
    std::function<void(void*)> fn;
    std::shared_ptr<Aws::Utils::Threading::Semaphore> clientShutdownSem;
  };
 
  static void CrtClientShutdownCallback(void* data);
  void CancelCrtRequest(aws_s3_meta_request* meta_request) const;
  static int S3CrtRequestHeadersCallback(aws_s3_meta_request* meta_request, const struct aws_http_headers* headers, int response_status,
                                         void* user_data);
  static int S3CrtRequestGetBodyCallback(struct aws_s3_meta_request* meta_request, const struct aws_byte_cursor* body, uint64_t range_start,
                                         void* user_data);
  static void S3CrtRequestProgressCallback(struct aws_s3_meta_request* meta_request, const struct aws_s3_meta_request_progress* progress,
                                           void* user_data);
  static void S3CrtRequestFinishCallback(struct aws_s3_meta_request* meta_request,
                                         const struct aws_s3_meta_request_result* meta_request_result, void* user_data);
 
  void InitCrtEndpointFromUri(aws_uri& endpoint_uri, const Aws::Http::URI& uri) const;
 
  void InitCommonCrtRequestOption(CrtRequestCallbackUserData* userData, aws_s3_meta_request_options* options,
                                  const Aws::AmazonWebServiceRequest* request, const Aws::Http::URI& uri,
                                  Aws::Http::HttpMethod method) const;
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, S3CrtError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request,
                                                const std::function<void(Aws::Endpoint::ResolveEndpointOutcome&)>& resolveUri,
                                                Aws::String bucketName, Aws::Http::HttpMethod httpMethod) const;
 
  S3Crt::ClientConfiguration m_clientConfiguration;
  struct aws_s3_client* m_s3CrtClient = {};
  struct aws_signing_config_aws m_s3CrtSigningConfig = {};
  struct CrtClientShutdownCallbackDataWrapper m_wrappedData = {};
  std::shared_ptr<Aws::Utils::Threading::Semaphore> m_clientShutdownSem;
  std::shared_ptr<Aws::Auth::AWSCredentialsProvider> m_credProvider;
  std::shared_ptr<Aws::Crt::Auth::ICredentialsProvider> m_crtCredProvider;
  std::shared_ptr<S3CrtEndpointProviderBase> m_endpointProvider;
  std::shared_ptr<S3ExpressIdentityProvider> m_identityProvider;
  S3CrtIdentityProviderUserData m_identityProviderUserData{m_identityProvider};
};
 
}  // namespace S3Crt
}  // namespace Aws