S3CrtClient.h

 
#pragma once
#include <aws/s3-crt/S3Crt_EXPORTS.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/auth/AWSCredentialsProviderChain.h>
#include <aws/core/utils/crypto/Factories.h>
#include <aws/s3-crt/ClientConfiguration.h>
#include <aws/s3-crt/S3CrtErrorMarshaller.h>
#include <aws/s3/s3_client.h>
#include <aws/crt/auth/Sigv4Signing.h>
#include <aws/crt/http/HttpRequestResponse.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/auth/AWSAuthSigner.h>
#include <aws/core/utils/xml/XmlSerializer.h>
#include <aws/core/utils/DNS.h>
#include <aws/s3-crt/S3CrtServiceClientModel.h>
#include <aws/s3-crt/S3ExpressIdentityProvider.h>
#include <aws/s3-crt/S3CrtIdentityProviderAdapter.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";
    } // SS3Headers
 
    //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:
        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::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::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::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::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::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::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::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);
        }
 
 
        Aws::String GeneratePresignedUrl(const Aws::String& bucket,
                                         const Aws::String& key,
                                         Aws::Http::HttpMethod method,
                                         uint64_t expirationInSeconds = MAX_EXPIRATION_SECONDS);
 
        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);
 
        Aws::String GeneratePresignedUrlWithSSES3(const Aws::String& bucket,
                                                  const Aws::String& key,
                                                  Aws::Http::HttpMethod method,
                                                  uint64_t expirationInSeconds = MAX_EXPIRATION_SECONDS);
        Aws::String GeneratePresignedUrlWithSSES3(const Aws::String& bucket,
                                                  const Aws::String& key,
                                                  Aws::Http::HttpMethod method,
                                                  Http::HeaderValueCollection customizedHeaders,
                                                  uint64_t expirationInSeconds = MAX_EXPIRATION_SECONDS);
 
        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);
        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);
 
        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);
        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;
 
        void OverrideEndpoint(const Aws::String& endpoint);
        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;
 
    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) {
          auto *wrappedData = static_cast<CrtClientShutdownCallbackDataWrapper*>(data);
          if (wrappedData->fn)
          {
            wrappedData->fn(wrappedData->data);
          }
          wrappedData->clientShutdownSem->Release();
        }
 
        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;
        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