S3ControlClient.h

 
#pragma once
#include <aws/s3control/S3Control_EXPORTS.h>
#include <aws/s3control/S3ControlEndpointProvider.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/s3control/S3ControlServiceClientModel.h>
 
namespace Aws
{
namespace S3Control
{
 
    class AWS_S3CONTROL_API S3ControlClient : public Aws::Client::AWSXMLClient, public Aws::Client::ClientWithAsyncTemplateMethods<S3ControlClient>
    {
    public:
        typedef Aws::Client::AWSXMLClient BASECLASS;
        static const char* GetServiceName();
        static const char* GetAllocationTag();
 
      typedef S3ControlClientConfiguration ClientConfigurationType;
      typedef S3ControlEndpointProvider EndpointProviderType;
 
        S3ControlClient(const Aws::S3Control::S3ControlClientConfiguration& clientConfiguration = Aws::S3Control::S3ControlClientConfiguration(),
                        std::shared_ptr<S3ControlEndpointProviderBase> endpointProvider = nullptr);
 
        S3ControlClient(const Aws::Auth::AWSCredentials& credentials,
                        std::shared_ptr<S3ControlEndpointProviderBase> endpointProvider = nullptr,
                        const Aws::S3Control::S3ControlClientConfiguration& clientConfiguration = Aws::S3Control::S3ControlClientConfiguration());
 
        S3ControlClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                        std::shared_ptr<S3ControlEndpointProviderBase> endpointProvider = nullptr,
                        const Aws::S3Control::S3ControlClientConfiguration& clientConfiguration = Aws::S3Control::S3ControlClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        S3ControlClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        S3ControlClient(const Aws::Auth::AWSCredentials& credentials,
                        const Aws::Client::ClientConfiguration& clientConfiguration);
 
        S3ControlClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                        const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~S3ControlClient();
 
        virtual Model::AssociateAccessGrantsIdentityCenterOutcome AssociateAccessGrantsIdentityCenter(const Model::AssociateAccessGrantsIdentityCenterRequest& request) const;
 
        template<typename AssociateAccessGrantsIdentityCenterRequestT = Model::AssociateAccessGrantsIdentityCenterRequest>
        Model::AssociateAccessGrantsIdentityCenterOutcomeCallable AssociateAccessGrantsIdentityCenterCallable(const AssociateAccessGrantsIdentityCenterRequestT& request) const
        {
            return SubmitCallable(&S3ControlClient::AssociateAccessGrantsIdentityCenter, request);
        }
 
        template<typename AssociateAccessGrantsIdentityCenterRequestT = Model::AssociateAccessGrantsIdentityCenterRequest>
        void AssociateAccessGrantsIdentityCenterAsync(const AssociateAccessGrantsIdentityCenterRequestT& request, const AssociateAccessGrantsIdentityCenterResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&S3ControlClient::AssociateAccessGrantsIdentityCenter, request, handler, context);
        }
 
        virtual Model::CreateAccessGrantOutcome CreateAccessGrant(const Model::CreateAccessGrantRequest& request) const;
 
        template<typename CreateAccessGrantRequestT = Model::CreateAccessGrantRequest>
        Model::CreateAccessGrantOutcomeCallable CreateAccessGrantCallable(const CreateAccessGrantRequestT& request) const
        {
            return SubmitCallable(&S3ControlClient::CreateAccessGrant, request);
        }
 
        template<typename CreateAccessGrantRequestT = Model::CreateAccessGrantRequest>
        void CreateAccessGrantAsync(const CreateAccessGrantRequestT& request, const CreateAccessGrantResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&S3ControlClient::CreateAccessGrant, request, handler, context);
        }
 
        virtual Model::CreateAccessGrantsInstanceOutcome CreateAccessGrantsInstance(const Model::CreateAccessGrantsInstanceRequest& request) const;
 
        template<typename CreateAccessGrantsInstanceRequestT = Model::CreateAccessGrantsInstanceRequest>
        Model::CreateAccessGrantsInstanceOutcomeCallable CreateAccessGrantsInstanceCallable(const CreateAccessGrantsInstanceRequestT& request) const
        {
            return SubmitCallable(&S3ControlClient::CreateAccessGrantsInstance, request);
        }
 
        template<typename CreateAccessGrantsInstanceRequestT = Model::CreateAccessGrantsInstanceRequest>
        void CreateAccessGrantsInstanceAsync(const CreateAccessGrantsInstanceRequestT& request, const CreateAccessGrantsInstanceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&S3ControlClient::CreateAccessGrantsInstance, request, handler, context);
        }
 
        virtual Model::CreateAccessGrantsLocationOutcome CreateAccessGrantsLocation(const Model::CreateAccessGrantsLocationRequest& request) const;
 
        template<typename CreateAccessGrantsLocationRequestT = Model::CreateAccessGrantsLocationRequest>
        Model::CreateAccessGrantsLocationOutcomeCallable CreateAccessGrantsLocationCallable(const CreateAccessGrantsLocationRequestT& request) const
        {
            return SubmitCallable(&S3ControlClient::CreateAccessGrantsLocation, request);
        }
 
        template<typename CreateAccessGrantsLocationRequestT = Model::CreateAccessGrantsLocationRequest>
        void CreateAccessGrantsLocationAsync(const CreateAccessGrantsLocationRequestT& request, const CreateAccessGrantsLocationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&S3ControlClient::CreateAccessGrantsLocation, request, handler, context);
        }
 
        virtual Model::CreateAccessPointOutcome CreateAccessPoint(const Model::CreateAccessPointRequest& request) const;
 
        template<typename CreateAccessPointRequestT = Model::CreateAccessPointRequest>
        Model::CreateAccessPointOutcomeCallable CreateAccessPointCallable(const CreateAccessPointRequestT& request) const
        {
            return SubmitCallable(&S3ControlClient::CreateAccessPoint, request);
        }
 
        template<typename CreateAccessPointRequestT = Model::CreateAccessPointRequest>
        void CreateAccessPointAsync(const CreateAccessPointRequestT& request, const CreateAccessPointResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&S3ControlClient::CreateAccessPoint, request, handler, context);
        }
 
        virtual Model::CreateAccessPointForObjectLambdaOutcome CreateAccessPointForObjectLambda(const Model::CreateAccessPointForObjectLambdaRequest& request) const;
 
        template<typename CreateAccessPointForObjectLambdaRequestT = Model::CreateAccessPointForObjectLambdaRequest>
        Model::CreateAccessPointForObjectLambdaOutcomeCallable CreateAccessPointForObjectLambdaCallable(const CreateAccessPointForObjectLambdaRequestT& request) const
        {
            return SubmitCallable(&S3ControlClient::CreateAccessPointForObjectLambda, request);
        }
 
        template<typename CreateAccessPointForObjectLambdaRequestT = Model::CreateAccessPointForObjectLambdaRequest>
        void CreateAccessPointForObjectLambdaAsync(const CreateAccessPointForObjectLambdaRequestT& request, const CreateAccessPointForObjectLambdaResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&S3ControlClient::CreateAccessPointForObjectLambda, request, handler, context);
        }
 
        virtual Model::CreateBucketOutcome CreateBucket(const Model::CreateBucketRequest& request) const;
 
        template<typename CreateBucketRequestT = Model::CreateBucketRequest>
        Model::CreateBucketOutcomeCallable CreateBucketCallable(const CreateBucketRequestT& request) const
        {
            return SubmitCallable(&S3ControlClient::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(&S3ControlClient::CreateBucket, request, handler, context);
        }
 
        virtual Model::CreateJobOutcome CreateJob(const Model::CreateJobRequest& request) const;
 
        template<typename CreateJobRequestT = Model::CreateJobRequest>
        Model::CreateJobOutcomeCallable CreateJobCallable(const CreateJobRequestT& request) const
        {
            return SubmitCallable(&S3ControlClient::CreateJob, request);
        }
 
        template<typename CreateJobRequestT = Model::CreateJobRequest>
        void CreateJobAsync(const CreateJobRequestT& request, const CreateJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&S3ControlClient::CreateJob, request, handler, context);
        }
 
        virtual Model::CreateMultiRegionAccessPointOutcome CreateMultiRegionAccessPoint(const Model::CreateMultiRegionAccessPointRequest& request) const;
 
        template<typename CreateMultiRegionAccessPointRequestT = Model::CreateMultiRegionAccessPointRequest>
        Model::CreateMultiRegionAccessPointOutcomeCallable CreateMultiRegionAccessPointCallable(const CreateMultiRegionAccessPointRequestT& request) const
        {
            return SubmitCallable(&S3ControlClient::CreateMultiRegionAccessPoint, request);
        }
 
        template<typename CreateMultiRegionAccessPointRequestT = Model::CreateMultiRegionAccessPointRequest>
        void CreateMultiRegionAccessPointAsync(const CreateMultiRegionAccessPointRequestT& request, const CreateMultiRegionAccessPointResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&S3ControlClient::CreateMultiRegionAccessPoint, request, handler, context);
        }
 
        virtual Model::CreateStorageLensGroupOutcome CreateStorageLensGroup(const Model::CreateStorageLensGroupRequest& request) const;
 
        template<typename CreateStorageLensGroupRequestT = Model::CreateStorageLensGroupRequest>
        Model::CreateStorageLensGroupOutcomeCallable CreateStorageLensGroupCallable(const CreateStorageLensGroupRequestT& request) const
        {
            return SubmitCallable(&S3ControlClient::CreateStorageLensGroup, request);
        }
 
        template<typename CreateStorageLensGroupRequestT = Model::CreateStorageLensGroupRequest>
        void CreateStorageLensGroupAsync(const CreateStorageLensGroupRequestT& request, const CreateStorageLensGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&S3ControlClient::CreateStorageLensGroup, request, handler, context);
        }
 
        virtual Model::DeleteAccessGrantOutcome DeleteAccessGrant(const Model::DeleteAccessGrantRequest& request) const;
 
        template<typename DeleteAccessGrantRequestT = Model::DeleteAccessGrantRequest>
        Model::DeleteAccessGrantOutcomeCallable DeleteAccessGrantCallable(const DeleteAccessGrantRequestT& request) const
        {
            return SubmitCallable(&S3ControlClient::DeleteAccessGrant, request);
        }
 
        template<typename DeleteAccessGrantRequestT = Model::DeleteAccessGrantRequest>
        void DeleteAccessGrantAsync(const DeleteAccessGrantRequestT& request, const DeleteAccessGrantResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&S3ControlClient::DeleteAccessGrant, request, handler, context);
        }
 
        virtual Model::DeleteAccessGrantsInstanceOutcome DeleteAccessGrantsInstance(const Model::DeleteAccessGrantsInstanceRequest& request) const;
 
        template<typename DeleteAccessGrantsInstanceRequestT = Model::DeleteAccessGrantsInstanceRequest>
        Model::DeleteAccessGrantsInstanceOutcomeCallable DeleteAccessGrantsInstanceCallable(const DeleteAccessGrantsInstanceRequestT& request) const
        {
            return SubmitCallable(&S3ControlClient::DeleteAccessGrantsInstance, request);
        }
 
        template<typename DeleteAccessGrantsInstanceRequestT = Model::DeleteAccessGrantsInstanceRequest>
        void DeleteAccessGrantsInstanceAsync(const DeleteAccessGrantsInstanceRequestT& request, const DeleteAccessGrantsInstanceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&S3ControlClient::DeleteAccessGrantsInstance, request, handler, context);
        }
 
        virtual Model::DeleteAccessGrantsInstanceResourcePolicyOutcome DeleteAccessGrantsInstanceResourcePolicy(const Model::DeleteAccessGrantsInstanceResourcePolicyRequest& request) const;
 
        template<typename DeleteAccessGrantsInstanceResourcePolicyRequestT = Model::DeleteAccessGrantsInstanceResourcePolicyRequest>
        Model::DeleteAccessGrantsInstanceResourcePolicyOutcomeCallable DeleteAccessGrantsInstanceResourcePolicyCallable(const DeleteAccessGrantsInstanceResourcePolicyRequestT& request) const
        {
            return SubmitCallable(&S3ControlClient::DeleteAccessGrantsInstanceResourcePolicy, request);
        }
 
        template<typename DeleteAccessGrantsInstanceResourcePolicyRequestT = Model::DeleteAccessGrantsInstanceResourcePolicyRequest>
        void DeleteAccessGrantsInstanceResourcePolicyAsync(const DeleteAccessGrantsInstanceResourcePolicyRequestT& request, const DeleteAccessGrantsInstanceResourcePolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&S3ControlClient::DeleteAccessGrantsInstanceResourcePolicy, request, handler, context);
        }
 
        virtual Model::DeleteAccessGrantsLocationOutcome DeleteAccessGrantsLocation(const Model::DeleteAccessGrantsLocationRequest& request) const;
 
        template<typename DeleteAccessGrantsLocationRequestT = Model::DeleteAccessGrantsLocationRequest>
        Model::DeleteAccessGrantsLocationOutcomeCallable DeleteAccessGrantsLocationCallable(const DeleteAccessGrantsLocationRequestT& request) const
        {
            return SubmitCallable(&S3ControlClient::DeleteAccessGrantsLocation, request);
        }
 
        template<typename DeleteAccessGrantsLocationRequestT = Model::DeleteAccessGrantsLocationRequest>
        void DeleteAccessGrantsLocationAsync(const DeleteAccessGrantsLocationRequestT& request, const DeleteAccessGrantsLocationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&S3ControlClient::DeleteAccessGrantsLocation, request, handler, context);
        }
 
        virtual Model::DeleteAccessPointOutcome DeleteAccessPoint(const Model::DeleteAccessPointRequest& request) const;
 
        template<typename DeleteAccessPointRequestT = Model::DeleteAccessPointRequest>
        Model::DeleteAccessPointOutcomeCallable DeleteAccessPointCallable(const DeleteAccessPointRequestT& request) const
        {
            return SubmitCallable(&S3ControlClient::DeleteAccessPoint, request);
        }
 
        template<typename DeleteAccessPointRequestT = Model::DeleteAccessPointRequest>
        void DeleteAccessPointAsync(const DeleteAccessPointRequestT& request, const DeleteAccessPointResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&S3ControlClient::DeleteAccessPoint, request, handler, context);
        }
 
        virtual Model::DeleteAccessPointForObjectLambdaOutcome DeleteAccessPointForObjectLambda(const Model::DeleteAccessPointForObjectLambdaRequest& request) const;
 
        template<typename DeleteAccessPointForObjectLambdaRequestT = Model::DeleteAccessPointForObjectLambdaRequest>
        Model::DeleteAccessPointForObjectLambdaOutcomeCallable DeleteAccessPointForObjectLambdaCallable(const DeleteAccessPointForObjectLambdaRequestT& request) const
        {
            return SubmitCallable(&S3ControlClient::DeleteAccessPointForObjectLambda, request);
        }
 
        template<typename DeleteAccessPointForObjectLambdaRequestT = Model::DeleteAccessPointForObjectLambdaRequest>
        void DeleteAccessPointForObjectLambdaAsync(const DeleteAccessPointForObjectLambdaRequestT& request, const DeleteAccessPointForObjectLambdaResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&S3ControlClient::DeleteAccessPointForObjectLambda, request, handler, context);
        }
 
        virtual Model::DeleteAccessPointPolicyOutcome DeleteAccessPointPolicy(const Model::DeleteAccessPointPolicyRequest& request) const;
 
        template<typename DeleteAccessPointPolicyRequestT = Model::DeleteAccessPointPolicyRequest>
        Model::DeleteAccessPointPolicyOutcomeCallable DeleteAccessPointPolicyCallable(const DeleteAccessPointPolicyRequestT& request) const
        {
            return SubmitCallable(&S3ControlClient::DeleteAccessPointPolicy, request);
        }
 
        template<typename DeleteAccessPointPolicyRequestT = Model::DeleteAccessPointPolicyRequest>
        void DeleteAccessPointPolicyAsync(const DeleteAccessPointPolicyRequestT& request, const DeleteAccessPointPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&S3ControlClient::DeleteAccessPointPolicy, request, handler, context);
        }
 
        virtual Model::DeleteAccessPointPolicyForObjectLambdaOutcome DeleteAccessPointPolicyForObjectLambda(const Model::DeleteAccessPointPolicyForObjectLambdaRequest& request) const;
 
        template<typename DeleteAccessPointPolicyForObjectLambdaRequestT = Model::DeleteAccessPointPolicyForObjectLambdaRequest>
        Model::DeleteAccessPointPolicyForObjectLambdaOutcomeCallable DeleteAccessPointPolicyForObjectLambdaCallable(const DeleteAccessPointPolicyForObjectLambdaRequestT& request) const
        {
            return SubmitCallable(&S3ControlClient::DeleteAccessPointPolicyForObjectLambda, request);
        }
 
        template<typename DeleteAccessPointPolicyForObjectLambdaRequestT = Model::DeleteAccessPointPolicyForObjectLambdaRequest>
        void DeleteAccessPointPolicyForObjectLambdaAsync(const DeleteAccessPointPolicyForObjectLambdaRequestT& request, const DeleteAccessPointPolicyForObjectLambdaResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&S3ControlClient::DeleteAccessPointPolicyForObjectLambda, 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(&S3ControlClient::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(&S3ControlClient::DeleteBucket, request, handler, context);
        }
 
        virtual Model::DeleteBucketLifecycleConfigurationOutcome DeleteBucketLifecycleConfiguration(const Model::DeleteBucketLifecycleConfigurationRequest& request) const;
 
        template<typename DeleteBucketLifecycleConfigurationRequestT = Model::DeleteBucketLifecycleConfigurationRequest>
        Model::DeleteBucketLifecycleConfigurationOutcomeCallable DeleteBucketLifecycleConfigurationCallable(const DeleteBucketLifecycleConfigurationRequestT& request) const
        {
            return SubmitCallable(&S3ControlClient::DeleteBucketLifecycleConfiguration, request);
        }
 
        template<typename DeleteBucketLifecycleConfigurationRequestT = Model::DeleteBucketLifecycleConfigurationRequest>
        void DeleteBucketLifecycleConfigurationAsync(const DeleteBucketLifecycleConfigurationRequestT& request, const DeleteBucketLifecycleConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&S3ControlClient::DeleteBucketLifecycleConfiguration, 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(&S3ControlClient::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(&S3ControlClient::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(&S3ControlClient::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(&S3ControlClient::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(&S3ControlClient::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(&S3ControlClient::DeleteBucketTagging, request, handler, context);
        }
 
        virtual Model::DeleteJobTaggingOutcome DeleteJobTagging(const Model::DeleteJobTaggingRequest& request) const;
 
        template<typename DeleteJobTaggingRequestT = Model::DeleteJobTaggingRequest>
        Model::DeleteJobTaggingOutcomeCallable DeleteJobTaggingCallable(const DeleteJobTaggingRequestT& request) const
        {
            return SubmitCallable(&S3ControlClient::DeleteJobTagging, request);
        }
 
        template<typename DeleteJobTaggingRequestT = Model::DeleteJobTaggingRequest>
        void DeleteJobTaggingAsync(const DeleteJobTaggingRequestT& request, const DeleteJobTaggingResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&S3ControlClient::DeleteJobTagging, request, handler, context);
        }
 
        virtual Model::DeleteMultiRegionAccessPointOutcome DeleteMultiRegionAccessPoint(const Model::DeleteMultiRegionAccessPointRequest& request) const;
 
        template<typename DeleteMultiRegionAccessPointRequestT = Model::DeleteMultiRegionAccessPointRequest>
        Model::DeleteMultiRegionAccessPointOutcomeCallable DeleteMultiRegionAccessPointCallable(const DeleteMultiRegionAccessPointRequestT& request) const
        {
            return SubmitCallable(&S3ControlClient::DeleteMultiRegionAccessPoint, request);
        }
 
        template<typename DeleteMultiRegionAccessPointRequestT = Model::DeleteMultiRegionAccessPointRequest>
        void DeleteMultiRegionAccessPointAsync(const DeleteMultiRegionAccessPointRequestT& request, const DeleteMultiRegionAccessPointResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&S3ControlClient::DeleteMultiRegionAccessPoint, 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(&S3ControlClient::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(&S3ControlClient::DeletePublicAccessBlock, request, handler, context);
        }
 
        virtual Model::DeleteStorageLensConfigurationOutcome DeleteStorageLensConfiguration(const Model::DeleteStorageLensConfigurationRequest& request) const;
 
        template<typename DeleteStorageLensConfigurationRequestT = Model::DeleteStorageLensConfigurationRequest>
        Model::DeleteStorageLensConfigurationOutcomeCallable DeleteStorageLensConfigurationCallable(const DeleteStorageLensConfigurationRequestT& request) const
        {
            return SubmitCallable(&S3ControlClient::DeleteStorageLensConfiguration, request);
        }
 
        template<typename DeleteStorageLensConfigurationRequestT = Model::DeleteStorageLensConfigurationRequest>
        void DeleteStorageLensConfigurationAsync(const DeleteStorageLensConfigurationRequestT& request, const DeleteStorageLensConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&S3ControlClient::DeleteStorageLensConfiguration, request, handler, context);
        }
 
        virtual Model::DeleteStorageLensConfigurationTaggingOutcome DeleteStorageLensConfigurationTagging(const Model::DeleteStorageLensConfigurationTaggingRequest& request) const;
 
        template<typename DeleteStorageLensConfigurationTaggingRequestT = Model::DeleteStorageLensConfigurationTaggingRequest>
        Model::DeleteStorageLensConfigurationTaggingOutcomeCallable DeleteStorageLensConfigurationTaggingCallable(const DeleteStorageLensConfigurationTaggingRequestT& request) const
        {
            return SubmitCallable(&S3ControlClient::DeleteStorageLensConfigurationTagging, request);
        }
 
        template<typename DeleteStorageLensConfigurationTaggingRequestT = Model::DeleteStorageLensConfigurationTaggingRequest>
        void DeleteStorageLensConfigurationTaggingAsync(const DeleteStorageLensConfigurationTaggingRequestT& request, const DeleteStorageLensConfigurationTaggingResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&S3ControlClient::DeleteStorageLensConfigurationTagging, request, handler, context);
        }
 
        virtual Model::DeleteStorageLensGroupOutcome DeleteStorageLensGroup(const Model::DeleteStorageLensGroupRequest& request) const;
 
        template<typename DeleteStorageLensGroupRequestT = Model::DeleteStorageLensGroupRequest>
        Model::DeleteStorageLensGroupOutcomeCallable DeleteStorageLensGroupCallable(const DeleteStorageLensGroupRequestT& request) const
        {
            return SubmitCallable(&S3ControlClient::DeleteStorageLensGroup, request);
        }
 
        template<typename DeleteStorageLensGroupRequestT = Model::DeleteStorageLensGroupRequest>
        void DeleteStorageLensGroupAsync(const DeleteStorageLensGroupRequestT& request, const DeleteStorageLensGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&S3ControlClient::DeleteStorageLensGroup, request, handler, context);
        }
 
        virtual Model::DescribeJobOutcome DescribeJob(const Model::DescribeJobRequest& request) const;
 
        template<typename DescribeJobRequestT = Model::DescribeJobRequest>
        Model::DescribeJobOutcomeCallable DescribeJobCallable(const DescribeJobRequestT& request) const
        {
            return SubmitCallable(&S3ControlClient::DescribeJob, request);
        }
 
        template<typename DescribeJobRequestT = Model::DescribeJobRequest>
        void DescribeJobAsync(const DescribeJobRequestT& request, const DescribeJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&S3ControlClient::DescribeJob, request, handler, context);
        }
 
        virtual Model::DescribeMultiRegionAccessPointOperationOutcome DescribeMultiRegionAccessPointOperation(const Model::DescribeMultiRegionAccessPointOperationRequest& request) const;
 
        template<typename DescribeMultiRegionAccessPointOperationRequestT = Model::DescribeMultiRegionAccessPointOperationRequest>
        Model::DescribeMultiRegionAccessPointOperationOutcomeCallable DescribeMultiRegionAccessPointOperationCallable(const DescribeMultiRegionAccessPointOperationRequestT& request) const
        {
            return SubmitCallable(&S3ControlClient::DescribeMultiRegionAccessPointOperation, request);
        }
 
        template<typename DescribeMultiRegionAccessPointOperationRequestT = Model::DescribeMultiRegionAccessPointOperationRequest>
        void DescribeMultiRegionAccessPointOperationAsync(const DescribeMultiRegionAccessPointOperationRequestT& request, const DescribeMultiRegionAccessPointOperationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&S3ControlClient::DescribeMultiRegionAccessPointOperation, request, handler, context);
        }
 
        virtual Model::DissociateAccessGrantsIdentityCenterOutcome DissociateAccessGrantsIdentityCenter(const Model::DissociateAccessGrantsIdentityCenterRequest& request) const;
 
        template<typename DissociateAccessGrantsIdentityCenterRequestT = Model::DissociateAccessGrantsIdentityCenterRequest>
        Model::DissociateAccessGrantsIdentityCenterOutcomeCallable DissociateAccessGrantsIdentityCenterCallable(const DissociateAccessGrantsIdentityCenterRequestT& request) const
        {
            return SubmitCallable(&S3ControlClient::DissociateAccessGrantsIdentityCenter, request);
        }
 
        template<typename DissociateAccessGrantsIdentityCenterRequestT = Model::DissociateAccessGrantsIdentityCenterRequest>
        void DissociateAccessGrantsIdentityCenterAsync(const DissociateAccessGrantsIdentityCenterRequestT& request, const DissociateAccessGrantsIdentityCenterResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&S3ControlClient::DissociateAccessGrantsIdentityCenter, request, handler, context);
        }
 
        virtual Model::GetAccessGrantOutcome GetAccessGrant(const Model::GetAccessGrantRequest& request) const;
 
        template<typename GetAccessGrantRequestT = Model::GetAccessGrantRequest>
        Model::GetAccessGrantOutcomeCallable GetAccessGrantCallable(const GetAccessGrantRequestT& request) const
        {
            return SubmitCallable(&S3ControlClient::GetAccessGrant, request);
        }
 
        template<typename GetAccessGrantRequestT = Model::GetAccessGrantRequest>
        void GetAccessGrantAsync(const GetAccessGrantRequestT& request, const GetAccessGrantResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&S3ControlClient::GetAccessGrant, request, handler, context);
        }
 
        virtual Model::GetAccessGrantsInstanceOutcome GetAccessGrantsInstance(const Model::GetAccessGrantsInstanceRequest& request) const;
 
        template<typename GetAccessGrantsInstanceRequestT = Model::GetAccessGrantsInstanceRequest>
        Model::GetAccessGrantsInstanceOutcomeCallable GetAccessGrantsInstanceCallable(const GetAccessGrantsInstanceRequestT& request) const
        {
            return SubmitCallable(&S3ControlClient::GetAccessGrantsInstance, request);
        }
 
        template<typename GetAccessGrantsInstanceRequestT = Model::GetAccessGrantsInstanceRequest>
        void GetAccessGrantsInstanceAsync(const GetAccessGrantsInstanceRequestT& request, const GetAccessGrantsInstanceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&S3ControlClient::GetAccessGrantsInstance, request, handler, context);
        }
 
        virtual Model::GetAccessGrantsInstanceForPrefixOutcome GetAccessGrantsInstanceForPrefix(const Model::GetAccessGrantsInstanceForPrefixRequest& request) const;
 
        template<typename GetAccessGrantsInstanceForPrefixRequestT = Model::GetAccessGrantsInstanceForPrefixRequest>
        Model::GetAccessGrantsInstanceForPrefixOutcomeCallable GetAccessGrantsInstanceForPrefixCallable(const GetAccessGrantsInstanceForPrefixRequestT& request) const
        {
            return SubmitCallable(&S3ControlClient::GetAccessGrantsInstanceForPrefix, request);
        }
 
        template<typename GetAccessGrantsInstanceForPrefixRequestT = Model::GetAccessGrantsInstanceForPrefixRequest>
        void GetAccessGrantsInstanceForPrefixAsync(const GetAccessGrantsInstanceForPrefixRequestT& request, const GetAccessGrantsInstanceForPrefixResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&S3ControlClient::GetAccessGrantsInstanceForPrefix, request, handler, context);
        }
 
        virtual Model::GetAccessGrantsInstanceResourcePolicyOutcome GetAccessGrantsInstanceResourcePolicy(const Model::GetAccessGrantsInstanceResourcePolicyRequest& request) const;
 
        template<typename GetAccessGrantsInstanceResourcePolicyRequestT = Model::GetAccessGrantsInstanceResourcePolicyRequest>
        Model::GetAccessGrantsInstanceResourcePolicyOutcomeCallable GetAccessGrantsInstanceResourcePolicyCallable(const GetAccessGrantsInstanceResourcePolicyRequestT& request) const
        {
            return SubmitCallable(&S3ControlClient::GetAccessGrantsInstanceResourcePolicy, request);
        }
 
        template<typename GetAccessGrantsInstanceResourcePolicyRequestT = Model::GetAccessGrantsInstanceResourcePolicyRequest>
        void GetAccessGrantsInstanceResourcePolicyAsync(const GetAccessGrantsInstanceResourcePolicyRequestT& request, const GetAccessGrantsInstanceResourcePolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&S3ControlClient::GetAccessGrantsInstanceResourcePolicy, request, handler, context);
        }
 
        virtual Model::GetAccessGrantsLocationOutcome GetAccessGrantsLocation(const Model::GetAccessGrantsLocationRequest& request) const;
 
        template<typename GetAccessGrantsLocationRequestT = Model::GetAccessGrantsLocationRequest>
        Model::GetAccessGrantsLocationOutcomeCallable GetAccessGrantsLocationCallable(const GetAccessGrantsLocationRequestT& request) const
        {
            return SubmitCallable(&S3ControlClient::GetAccessGrantsLocation, request);
        }
 
        template<typename GetAccessGrantsLocationRequestT = Model::GetAccessGrantsLocationRequest>
        void GetAccessGrantsLocationAsync(const GetAccessGrantsLocationRequestT& request, const GetAccessGrantsLocationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&S3ControlClient::GetAccessGrantsLocation, request, handler, context);
        }
 
        virtual Model::GetAccessPointOutcome GetAccessPoint(const Model::GetAccessPointRequest& request) const;
 
        template<typename GetAccessPointRequestT = Model::GetAccessPointRequest>
        Model::GetAccessPointOutcomeCallable GetAccessPointCallable(const GetAccessPointRequestT& request) const
        {
            return SubmitCallable(&S3ControlClient::GetAccessPoint, request);
        }
 
        template<typename GetAccessPointRequestT = Model::GetAccessPointRequest>
        void GetAccessPointAsync(const GetAccessPointRequestT& request, const GetAccessPointResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&S3ControlClient::GetAccessPoint, request, handler, context);
        }
 
        virtual Model::GetAccessPointConfigurationForObjectLambdaOutcome GetAccessPointConfigurationForObjectLambda(const Model::GetAccessPointConfigurationForObjectLambdaRequest& request) const;
 
        template<typename GetAccessPointConfigurationForObjectLambdaRequestT = Model::GetAccessPointConfigurationForObjectLambdaRequest>
        Model::GetAccessPointConfigurationForObjectLambdaOutcomeCallable GetAccessPointConfigurationForObjectLambdaCallable(const GetAccessPointConfigurationForObjectLambdaRequestT& request) const
        {
            return SubmitCallable(&S3ControlClient::GetAccessPointConfigurationForObjectLambda, request);
        }
 
        template<typename GetAccessPointConfigurationForObjectLambdaRequestT = Model::GetAccessPointConfigurationForObjectLambdaRequest>
        void GetAccessPointConfigurationForObjectLambdaAsync(const GetAccessPointConfigurationForObjectLambdaRequestT& request, const GetAccessPointConfigurationForObjectLambdaResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&S3ControlClient::GetAccessPointConfigurationForObjectLambda, request, handler, context);
        }
 
        virtual Model::GetAccessPointForObjectLambdaOutcome GetAccessPointForObjectLambda(const Model::GetAccessPointForObjectLambdaRequest& request) const;
 
        template<typename GetAccessPointForObjectLambdaRequestT = Model::GetAccessPointForObjectLambdaRequest>
        Model::GetAccessPointForObjectLambdaOutcomeCallable GetAccessPointForObjectLambdaCallable(const GetAccessPointForObjectLambdaRequestT& request) const
        {
            return SubmitCallable(&S3ControlClient::GetAccessPointForObjectLambda, request);
        }
 
        template<typename GetAccessPointForObjectLambdaRequestT = Model::GetAccessPointForObjectLambdaRequest>
        void GetAccessPointForObjectLambdaAsync(const GetAccessPointForObjectLambdaRequestT& request, const GetAccessPointForObjectLambdaResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&S3ControlClient::GetAccessPointForObjectLambda, request, handler, context);
        }
 
        virtual Model::GetAccessPointPolicyOutcome GetAccessPointPolicy(const Model::GetAccessPointPolicyRequest& request) const;
 
        template<typename GetAccessPointPolicyRequestT = Model::GetAccessPointPolicyRequest>
        Model::GetAccessPointPolicyOutcomeCallable GetAccessPointPolicyCallable(const GetAccessPointPolicyRequestT& request) const
        {
            return SubmitCallable(&S3ControlClient::GetAccessPointPolicy, request);
        }
 
        template<typename GetAccessPointPolicyRequestT = Model::GetAccessPointPolicyRequest>
        void GetAccessPointPolicyAsync(const GetAccessPointPolicyRequestT& request, const GetAccessPointPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&S3ControlClient::GetAccessPointPolicy, request, handler, context);
        }
 
        virtual Model::GetAccessPointPolicyForObjectLambdaOutcome GetAccessPointPolicyForObjectLambda(const Model::GetAccessPointPolicyForObjectLambdaRequest& request) const;
 
        template<typename GetAccessPointPolicyForObjectLambdaRequestT = Model::GetAccessPointPolicyForObjectLambdaRequest>
        Model::GetAccessPointPolicyForObjectLambdaOutcomeCallable GetAccessPointPolicyForObjectLambdaCallable(const GetAccessPointPolicyForObjectLambdaRequestT& request) const
        {
            return SubmitCallable(&S3ControlClient::GetAccessPointPolicyForObjectLambda, request);
        }
 
        template<typename GetAccessPointPolicyForObjectLambdaRequestT = Model::GetAccessPointPolicyForObjectLambdaRequest>
        void GetAccessPointPolicyForObjectLambdaAsync(const GetAccessPointPolicyForObjectLambdaRequestT& request, const GetAccessPointPolicyForObjectLambdaResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&S3ControlClient::GetAccessPointPolicyForObjectLambda, request, handler, context);
        }
 
        virtual Model::GetAccessPointPolicyStatusOutcome GetAccessPointPolicyStatus(const Model::GetAccessPointPolicyStatusRequest& request) const;
 
        template<typename GetAccessPointPolicyStatusRequestT = Model::GetAccessPointPolicyStatusRequest>
        Model::GetAccessPointPolicyStatusOutcomeCallable GetAccessPointPolicyStatusCallable(const GetAccessPointPolicyStatusRequestT& request) const
        {
            return SubmitCallable(&S3ControlClient::GetAccessPointPolicyStatus, request);
        }
 
        template<typename GetAccessPointPolicyStatusRequestT = Model::GetAccessPointPolicyStatusRequest>
        void GetAccessPointPolicyStatusAsync(const GetAccessPointPolicyStatusRequestT& request, const GetAccessPointPolicyStatusResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&S3ControlClient::GetAccessPointPolicyStatus, request, handler, context);
        }
 
        virtual Model::GetAccessPointPolicyStatusForObjectLambdaOutcome GetAccessPointPolicyStatusForObjectLambda(const Model::GetAccessPointPolicyStatusForObjectLambdaRequest& request) const;
 
        template<typename GetAccessPointPolicyStatusForObjectLambdaRequestT = Model::GetAccessPointPolicyStatusForObjectLambdaRequest>
        Model::GetAccessPointPolicyStatusForObjectLambdaOutcomeCallable GetAccessPointPolicyStatusForObjectLambdaCallable(const GetAccessPointPolicyStatusForObjectLambdaRequestT& request) const
        {
            return SubmitCallable(&S3ControlClient::GetAccessPointPolicyStatusForObjectLambda, request);
        }
 
        template<typename GetAccessPointPolicyStatusForObjectLambdaRequestT = Model::GetAccessPointPolicyStatusForObjectLambdaRequest>
        void GetAccessPointPolicyStatusForObjectLambdaAsync(const GetAccessPointPolicyStatusForObjectLambdaRequestT& request, const GetAccessPointPolicyStatusForObjectLambdaResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&S3ControlClient::GetAccessPointPolicyStatusForObjectLambda, request, handler, context);
        }
 
        virtual Model::GetBucketOutcome GetBucket(const Model::GetBucketRequest& request) const;
 
        template<typename GetBucketRequestT = Model::GetBucketRequest>
        Model::GetBucketOutcomeCallable GetBucketCallable(const GetBucketRequestT& request) const
        {
            return SubmitCallable(&S3ControlClient::GetBucket, request);
        }
 
        template<typename GetBucketRequestT = Model::GetBucketRequest>
        void GetBucketAsync(const GetBucketRequestT& request, const GetBucketResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&S3ControlClient::GetBucket, 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(&S3ControlClient::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(&S3ControlClient::GetBucketLifecycleConfiguration, 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(&S3ControlClient::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(&S3ControlClient::GetBucketPolicy, 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(&S3ControlClient::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(&S3ControlClient::GetBucketReplication, 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(&S3ControlClient::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(&S3ControlClient::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(&S3ControlClient::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(&S3ControlClient::GetBucketVersioning, request, handler, context);
        }
 
        virtual Model::GetDataAccessOutcome GetDataAccess(const Model::GetDataAccessRequest& request) const;
 
        template<typename GetDataAccessRequestT = Model::GetDataAccessRequest>
        Model::GetDataAccessOutcomeCallable GetDataAccessCallable(const GetDataAccessRequestT& request) const
        {
            return SubmitCallable(&S3ControlClient::GetDataAccess, request);
        }
 
        template<typename GetDataAccessRequestT = Model::GetDataAccessRequest>
        void GetDataAccessAsync(const GetDataAccessRequestT& request, const GetDataAccessResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&S3ControlClient::GetDataAccess, request, handler, context);
        }
 
        virtual Model::GetJobTaggingOutcome GetJobTagging(const Model::GetJobTaggingRequest& request) const;
 
        template<typename GetJobTaggingRequestT = Model::GetJobTaggingRequest>
        Model::GetJobTaggingOutcomeCallable GetJobTaggingCallable(const GetJobTaggingRequestT& request) const
        {
            return SubmitCallable(&S3ControlClient::GetJobTagging, request);
        }
 
        template<typename GetJobTaggingRequestT = Model::GetJobTaggingRequest>
        void GetJobTaggingAsync(const GetJobTaggingRequestT& request, const GetJobTaggingResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&S3ControlClient::GetJobTagging, request, handler, context);
        }
 
        virtual Model::GetMultiRegionAccessPointOutcome GetMultiRegionAccessPoint(const Model::GetMultiRegionAccessPointRequest& request) const;
 
        template<typename GetMultiRegionAccessPointRequestT = Model::GetMultiRegionAccessPointRequest>
        Model::GetMultiRegionAccessPointOutcomeCallable GetMultiRegionAccessPointCallable(const GetMultiRegionAccessPointRequestT& request) const
        {
            return SubmitCallable(&S3ControlClient::GetMultiRegionAccessPoint, request);
        }
 
        template<typename GetMultiRegionAccessPointRequestT = Model::GetMultiRegionAccessPointRequest>
        void GetMultiRegionAccessPointAsync(const GetMultiRegionAccessPointRequestT& request, const GetMultiRegionAccessPointResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&S3ControlClient::GetMultiRegionAccessPoint, request, handler, context);
        }
 
        virtual Model::GetMultiRegionAccessPointPolicyOutcome GetMultiRegionAccessPointPolicy(const Model::GetMultiRegionAccessPointPolicyRequest& request) const;
 
        template<typename GetMultiRegionAccessPointPolicyRequestT = Model::GetMultiRegionAccessPointPolicyRequest>
        Model::GetMultiRegionAccessPointPolicyOutcomeCallable GetMultiRegionAccessPointPolicyCallable(const GetMultiRegionAccessPointPolicyRequestT& request) const
        {
            return SubmitCallable(&S3ControlClient::GetMultiRegionAccessPointPolicy, request);
        }
 
        template<typename GetMultiRegionAccessPointPolicyRequestT = Model::GetMultiRegionAccessPointPolicyRequest>
        void GetMultiRegionAccessPointPolicyAsync(const GetMultiRegionAccessPointPolicyRequestT& request, const GetMultiRegionAccessPointPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&S3ControlClient::GetMultiRegionAccessPointPolicy, request, handler, context);
        }
 
        virtual Model::GetMultiRegionAccessPointPolicyStatusOutcome GetMultiRegionAccessPointPolicyStatus(const Model::GetMultiRegionAccessPointPolicyStatusRequest& request) const;
 
        template<typename GetMultiRegionAccessPointPolicyStatusRequestT = Model::GetMultiRegionAccessPointPolicyStatusRequest>
        Model::GetMultiRegionAccessPointPolicyStatusOutcomeCallable GetMultiRegionAccessPointPolicyStatusCallable(const GetMultiRegionAccessPointPolicyStatusRequestT& request) const
        {
            return SubmitCallable(&S3ControlClient::GetMultiRegionAccessPointPolicyStatus, request);
        }
 
        template<typename GetMultiRegionAccessPointPolicyStatusRequestT = Model::GetMultiRegionAccessPointPolicyStatusRequest>
        void GetMultiRegionAccessPointPolicyStatusAsync(const GetMultiRegionAccessPointPolicyStatusRequestT& request, const GetMultiRegionAccessPointPolicyStatusResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&S3ControlClient::GetMultiRegionAccessPointPolicyStatus, request, handler, context);
        }
 
        virtual Model::GetMultiRegionAccessPointRoutesOutcome GetMultiRegionAccessPointRoutes(const Model::GetMultiRegionAccessPointRoutesRequest& request) const;
 
        template<typename GetMultiRegionAccessPointRoutesRequestT = Model::GetMultiRegionAccessPointRoutesRequest>
        Model::GetMultiRegionAccessPointRoutesOutcomeCallable GetMultiRegionAccessPointRoutesCallable(const GetMultiRegionAccessPointRoutesRequestT& request) const
        {
            return SubmitCallable(&S3ControlClient::GetMultiRegionAccessPointRoutes, request);
        }
 
        template<typename GetMultiRegionAccessPointRoutesRequestT = Model::GetMultiRegionAccessPointRoutesRequest>
        void GetMultiRegionAccessPointRoutesAsync(const GetMultiRegionAccessPointRoutesRequestT& request, const GetMultiRegionAccessPointRoutesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&S3ControlClient::GetMultiRegionAccessPointRoutes, 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(&S3ControlClient::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(&S3ControlClient::GetPublicAccessBlock, request, handler, context);
        }
 
        virtual Model::GetStorageLensConfigurationOutcome GetStorageLensConfiguration(const Model::GetStorageLensConfigurationRequest& request) const;
 
        template<typename GetStorageLensConfigurationRequestT = Model::GetStorageLensConfigurationRequest>
        Model::GetStorageLensConfigurationOutcomeCallable GetStorageLensConfigurationCallable(const GetStorageLensConfigurationRequestT& request) const
        {
            return SubmitCallable(&S3ControlClient::GetStorageLensConfiguration, request);
        }
 
        template<typename GetStorageLensConfigurationRequestT = Model::GetStorageLensConfigurationRequest>
        void GetStorageLensConfigurationAsync(const GetStorageLensConfigurationRequestT& request, const GetStorageLensConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&S3ControlClient::GetStorageLensConfiguration, request, handler, context);
        }
 
        virtual Model::GetStorageLensConfigurationTaggingOutcome GetStorageLensConfigurationTagging(const Model::GetStorageLensConfigurationTaggingRequest& request) const;
 
        template<typename GetStorageLensConfigurationTaggingRequestT = Model::GetStorageLensConfigurationTaggingRequest>
        Model::GetStorageLensConfigurationTaggingOutcomeCallable GetStorageLensConfigurationTaggingCallable(const GetStorageLensConfigurationTaggingRequestT& request) const
        {
            return SubmitCallable(&S3ControlClient::GetStorageLensConfigurationTagging, request);
        }
 
        template<typename GetStorageLensConfigurationTaggingRequestT = Model::GetStorageLensConfigurationTaggingRequest>
        void GetStorageLensConfigurationTaggingAsync(const GetStorageLensConfigurationTaggingRequestT& request, const GetStorageLensConfigurationTaggingResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&S3ControlClient::GetStorageLensConfigurationTagging, request, handler, context);
        }
 
        virtual Model::GetStorageLensGroupOutcome GetStorageLensGroup(const Model::GetStorageLensGroupRequest& request) const;
 
        template<typename GetStorageLensGroupRequestT = Model::GetStorageLensGroupRequest>
        Model::GetStorageLensGroupOutcomeCallable GetStorageLensGroupCallable(const GetStorageLensGroupRequestT& request) const
        {
            return SubmitCallable(&S3ControlClient::GetStorageLensGroup, request);
        }
 
        template<typename GetStorageLensGroupRequestT = Model::GetStorageLensGroupRequest>
        void GetStorageLensGroupAsync(const GetStorageLensGroupRequestT& request, const GetStorageLensGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&S3ControlClient::GetStorageLensGroup, request, handler, context);
        }
 
        virtual Model::ListAccessGrantsOutcome ListAccessGrants(const Model::ListAccessGrantsRequest& request) const;
 
        template<typename ListAccessGrantsRequestT = Model::ListAccessGrantsRequest>
        Model::ListAccessGrantsOutcomeCallable ListAccessGrantsCallable(const ListAccessGrantsRequestT& request) const
        {
            return SubmitCallable(&S3ControlClient::ListAccessGrants, request);
        }
 
        template<typename ListAccessGrantsRequestT = Model::ListAccessGrantsRequest>
        void ListAccessGrantsAsync(const ListAccessGrantsRequestT& request, const ListAccessGrantsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&S3ControlClient::ListAccessGrants, request, handler, context);
        }
 
        virtual Model::ListAccessGrantsInstancesOutcome ListAccessGrantsInstances(const Model::ListAccessGrantsInstancesRequest& request) const;
 
        template<typename ListAccessGrantsInstancesRequestT = Model::ListAccessGrantsInstancesRequest>
        Model::ListAccessGrantsInstancesOutcomeCallable ListAccessGrantsInstancesCallable(const ListAccessGrantsInstancesRequestT& request) const
        {
            return SubmitCallable(&S3ControlClient::ListAccessGrantsInstances, request);
        }
 
        template<typename ListAccessGrantsInstancesRequestT = Model::ListAccessGrantsInstancesRequest>
        void ListAccessGrantsInstancesAsync(const ListAccessGrantsInstancesRequestT& request, const ListAccessGrantsInstancesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&S3ControlClient::ListAccessGrantsInstances, request, handler, context);
        }
 
        virtual Model::ListAccessGrantsLocationsOutcome ListAccessGrantsLocations(const Model::ListAccessGrantsLocationsRequest& request) const;
 
        template<typename ListAccessGrantsLocationsRequestT = Model::ListAccessGrantsLocationsRequest>
        Model::ListAccessGrantsLocationsOutcomeCallable ListAccessGrantsLocationsCallable(const ListAccessGrantsLocationsRequestT& request) const
        {
            return SubmitCallable(&S3ControlClient::ListAccessGrantsLocations, request);
        }
 
        template<typename ListAccessGrantsLocationsRequestT = Model::ListAccessGrantsLocationsRequest>
        void ListAccessGrantsLocationsAsync(const ListAccessGrantsLocationsRequestT& request, const ListAccessGrantsLocationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&S3ControlClient::ListAccessGrantsLocations, request, handler, context);
        }
 
        virtual Model::ListAccessPointsOutcome ListAccessPoints(const Model::ListAccessPointsRequest& request) const;
 
        template<typename ListAccessPointsRequestT = Model::ListAccessPointsRequest>
        Model::ListAccessPointsOutcomeCallable ListAccessPointsCallable(const ListAccessPointsRequestT& request) const
        {
            return SubmitCallable(&S3ControlClient::ListAccessPoints, request);
        }
 
        template<typename ListAccessPointsRequestT = Model::ListAccessPointsRequest>
        void ListAccessPointsAsync(const ListAccessPointsRequestT& request, const ListAccessPointsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&S3ControlClient::ListAccessPoints, request, handler, context);
        }
 
        virtual Model::ListAccessPointsForObjectLambdaOutcome ListAccessPointsForObjectLambda(const Model::ListAccessPointsForObjectLambdaRequest& request) const;
 
        template<typename ListAccessPointsForObjectLambdaRequestT = Model::ListAccessPointsForObjectLambdaRequest>
        Model::ListAccessPointsForObjectLambdaOutcomeCallable ListAccessPointsForObjectLambdaCallable(const ListAccessPointsForObjectLambdaRequestT& request) const
        {
            return SubmitCallable(&S3ControlClient::ListAccessPointsForObjectLambda, request);
        }
 
        template<typename ListAccessPointsForObjectLambdaRequestT = Model::ListAccessPointsForObjectLambdaRequest>
        void ListAccessPointsForObjectLambdaAsync(const ListAccessPointsForObjectLambdaRequestT& request, const ListAccessPointsForObjectLambdaResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&S3ControlClient::ListAccessPointsForObjectLambda, request, handler, context);
        }
 
        virtual Model::ListCallerAccessGrantsOutcome ListCallerAccessGrants(const Model::ListCallerAccessGrantsRequest& request) const;
 
        template<typename ListCallerAccessGrantsRequestT = Model::ListCallerAccessGrantsRequest>
        Model::ListCallerAccessGrantsOutcomeCallable ListCallerAccessGrantsCallable(const ListCallerAccessGrantsRequestT& request) const
        {
            return SubmitCallable(&S3ControlClient::ListCallerAccessGrants, request);
        }
 
        template<typename ListCallerAccessGrantsRequestT = Model::ListCallerAccessGrantsRequest>
        void ListCallerAccessGrantsAsync(const ListCallerAccessGrantsRequestT& request, const ListCallerAccessGrantsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&S3ControlClient::ListCallerAccessGrants, request, handler, context);
        }
 
        virtual Model::ListJobsOutcome ListJobs(const Model::ListJobsRequest& request) const;
 
        template<typename ListJobsRequestT = Model::ListJobsRequest>
        Model::ListJobsOutcomeCallable ListJobsCallable(const ListJobsRequestT& request) const
        {
            return SubmitCallable(&S3ControlClient::ListJobs, request);
        }
 
        template<typename ListJobsRequestT = Model::ListJobsRequest>
        void ListJobsAsync(const ListJobsRequestT& request, const ListJobsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&S3ControlClient::ListJobs, request, handler, context);
        }
 
        virtual Model::ListMultiRegionAccessPointsOutcome ListMultiRegionAccessPoints(const Model::ListMultiRegionAccessPointsRequest& request) const;
 
        template<typename ListMultiRegionAccessPointsRequestT = Model::ListMultiRegionAccessPointsRequest>
        Model::ListMultiRegionAccessPointsOutcomeCallable ListMultiRegionAccessPointsCallable(const ListMultiRegionAccessPointsRequestT& request) const
        {
            return SubmitCallable(&S3ControlClient::ListMultiRegionAccessPoints, request);
        }
 
        template<typename ListMultiRegionAccessPointsRequestT = Model::ListMultiRegionAccessPointsRequest>
        void ListMultiRegionAccessPointsAsync(const ListMultiRegionAccessPointsRequestT& request, const ListMultiRegionAccessPointsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&S3ControlClient::ListMultiRegionAccessPoints, request, handler, context);
        }
 
        virtual Model::ListRegionalBucketsOutcome ListRegionalBuckets(const Model::ListRegionalBucketsRequest& request) const;
 
        template<typename ListRegionalBucketsRequestT = Model::ListRegionalBucketsRequest>
        Model::ListRegionalBucketsOutcomeCallable ListRegionalBucketsCallable(const ListRegionalBucketsRequestT& request) const
        {
            return SubmitCallable(&S3ControlClient::ListRegionalBuckets, request);
        }
 
        template<typename ListRegionalBucketsRequestT = Model::ListRegionalBucketsRequest>
        void ListRegionalBucketsAsync(const ListRegionalBucketsRequestT& request, const ListRegionalBucketsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&S3ControlClient::ListRegionalBuckets, request, handler, context);
        }
 
        virtual Model::ListStorageLensConfigurationsOutcome ListStorageLensConfigurations(const Model::ListStorageLensConfigurationsRequest& request) const;
 
        template<typename ListStorageLensConfigurationsRequestT = Model::ListStorageLensConfigurationsRequest>
        Model::ListStorageLensConfigurationsOutcomeCallable ListStorageLensConfigurationsCallable(const ListStorageLensConfigurationsRequestT& request) const
        {
            return SubmitCallable(&S3ControlClient::ListStorageLensConfigurations, request);
        }
 
        template<typename ListStorageLensConfigurationsRequestT = Model::ListStorageLensConfigurationsRequest>
        void ListStorageLensConfigurationsAsync(const ListStorageLensConfigurationsRequestT& request, const ListStorageLensConfigurationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&S3ControlClient::ListStorageLensConfigurations, request, handler, context);
        }
 
        virtual Model::ListStorageLensGroupsOutcome ListStorageLensGroups(const Model::ListStorageLensGroupsRequest& request) const;
 
        template<typename ListStorageLensGroupsRequestT = Model::ListStorageLensGroupsRequest>
        Model::ListStorageLensGroupsOutcomeCallable ListStorageLensGroupsCallable(const ListStorageLensGroupsRequestT& request) const
        {
            return SubmitCallable(&S3ControlClient::ListStorageLensGroups, request);
        }
 
        template<typename ListStorageLensGroupsRequestT = Model::ListStorageLensGroupsRequest>
        void ListStorageLensGroupsAsync(const ListStorageLensGroupsRequestT& request, const ListStorageLensGroupsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&S3ControlClient::ListStorageLensGroups, request, handler, context);
        }
 
        virtual Model::ListTagsForResourceOutcome ListTagsForResource(const Model::ListTagsForResourceRequest& request) const;
 
        template<typename ListTagsForResourceRequestT = Model::ListTagsForResourceRequest>
        Model::ListTagsForResourceOutcomeCallable ListTagsForResourceCallable(const ListTagsForResourceRequestT& request) const
        {
            return SubmitCallable(&S3ControlClient::ListTagsForResource, request);
        }
 
        template<typename ListTagsForResourceRequestT = Model::ListTagsForResourceRequest>
        void ListTagsForResourceAsync(const ListTagsForResourceRequestT& request, const ListTagsForResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&S3ControlClient::ListTagsForResource, request, handler, context);
        }
 
        virtual Model::PutAccessGrantsInstanceResourcePolicyOutcome PutAccessGrantsInstanceResourcePolicy(const Model::PutAccessGrantsInstanceResourcePolicyRequest& request) const;
 
        template<typename PutAccessGrantsInstanceResourcePolicyRequestT = Model::PutAccessGrantsInstanceResourcePolicyRequest>
        Model::PutAccessGrantsInstanceResourcePolicyOutcomeCallable PutAccessGrantsInstanceResourcePolicyCallable(const PutAccessGrantsInstanceResourcePolicyRequestT& request) const
        {
            return SubmitCallable(&S3ControlClient::PutAccessGrantsInstanceResourcePolicy, request);
        }
 
        template<typename PutAccessGrantsInstanceResourcePolicyRequestT = Model::PutAccessGrantsInstanceResourcePolicyRequest>
        void PutAccessGrantsInstanceResourcePolicyAsync(const PutAccessGrantsInstanceResourcePolicyRequestT& request, const PutAccessGrantsInstanceResourcePolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&S3ControlClient::PutAccessGrantsInstanceResourcePolicy, request, handler, context);
        }
 
        virtual Model::PutAccessPointConfigurationForObjectLambdaOutcome PutAccessPointConfigurationForObjectLambda(const Model::PutAccessPointConfigurationForObjectLambdaRequest& request) const;
 
        template<typename PutAccessPointConfigurationForObjectLambdaRequestT = Model::PutAccessPointConfigurationForObjectLambdaRequest>
        Model::PutAccessPointConfigurationForObjectLambdaOutcomeCallable PutAccessPointConfigurationForObjectLambdaCallable(const PutAccessPointConfigurationForObjectLambdaRequestT& request) const
        {
            return SubmitCallable(&S3ControlClient::PutAccessPointConfigurationForObjectLambda, request);
        }
 
        template<typename PutAccessPointConfigurationForObjectLambdaRequestT = Model::PutAccessPointConfigurationForObjectLambdaRequest>
        void PutAccessPointConfigurationForObjectLambdaAsync(const PutAccessPointConfigurationForObjectLambdaRequestT& request, const PutAccessPointConfigurationForObjectLambdaResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&S3ControlClient::PutAccessPointConfigurationForObjectLambda, request, handler, context);
        }
 
        virtual Model::PutAccessPointPolicyOutcome PutAccessPointPolicy(const Model::PutAccessPointPolicyRequest& request) const;
 
        template<typename PutAccessPointPolicyRequestT = Model::PutAccessPointPolicyRequest>
        Model::PutAccessPointPolicyOutcomeCallable PutAccessPointPolicyCallable(const PutAccessPointPolicyRequestT& request) const
        {
            return SubmitCallable(&S3ControlClient::PutAccessPointPolicy, request);
        }
 
        template<typename PutAccessPointPolicyRequestT = Model::PutAccessPointPolicyRequest>
        void PutAccessPointPolicyAsync(const PutAccessPointPolicyRequestT& request, const PutAccessPointPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&S3ControlClient::PutAccessPointPolicy, request, handler, context);
        }
 
        virtual Model::PutAccessPointPolicyForObjectLambdaOutcome PutAccessPointPolicyForObjectLambda(const Model::PutAccessPointPolicyForObjectLambdaRequest& request) const;
 
        template<typename PutAccessPointPolicyForObjectLambdaRequestT = Model::PutAccessPointPolicyForObjectLambdaRequest>
        Model::PutAccessPointPolicyForObjectLambdaOutcomeCallable PutAccessPointPolicyForObjectLambdaCallable(const PutAccessPointPolicyForObjectLambdaRequestT& request) const
        {
            return SubmitCallable(&S3ControlClient::PutAccessPointPolicyForObjectLambda, request);
        }
 
        template<typename PutAccessPointPolicyForObjectLambdaRequestT = Model::PutAccessPointPolicyForObjectLambdaRequest>
        void PutAccessPointPolicyForObjectLambdaAsync(const PutAccessPointPolicyForObjectLambdaRequestT& request, const PutAccessPointPolicyForObjectLambdaResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&S3ControlClient::PutAccessPointPolicyForObjectLambda, 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(&S3ControlClient::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(&S3ControlClient::PutBucketLifecycleConfiguration, 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(&S3ControlClient::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(&S3ControlClient::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(&S3ControlClient::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(&S3ControlClient::PutBucketReplication, 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(&S3ControlClient::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(&S3ControlClient::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(&S3ControlClient::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(&S3ControlClient::PutBucketVersioning, request, handler, context);
        }
 
        virtual Model::PutJobTaggingOutcome PutJobTagging(const Model::PutJobTaggingRequest& request) const;
 
        template<typename PutJobTaggingRequestT = Model::PutJobTaggingRequest>
        Model::PutJobTaggingOutcomeCallable PutJobTaggingCallable(const PutJobTaggingRequestT& request) const
        {
            return SubmitCallable(&S3ControlClient::PutJobTagging, request);
        }
 
        template<typename PutJobTaggingRequestT = Model::PutJobTaggingRequest>
        void PutJobTaggingAsync(const PutJobTaggingRequestT& request, const PutJobTaggingResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&S3ControlClient::PutJobTagging, request, handler, context);
        }
 
        virtual Model::PutMultiRegionAccessPointPolicyOutcome PutMultiRegionAccessPointPolicy(const Model::PutMultiRegionAccessPointPolicyRequest& request) const;
 
        template<typename PutMultiRegionAccessPointPolicyRequestT = Model::PutMultiRegionAccessPointPolicyRequest>
        Model::PutMultiRegionAccessPointPolicyOutcomeCallable PutMultiRegionAccessPointPolicyCallable(const PutMultiRegionAccessPointPolicyRequestT& request) const
        {
            return SubmitCallable(&S3ControlClient::PutMultiRegionAccessPointPolicy, request);
        }
 
        template<typename PutMultiRegionAccessPointPolicyRequestT = Model::PutMultiRegionAccessPointPolicyRequest>
        void PutMultiRegionAccessPointPolicyAsync(const PutMultiRegionAccessPointPolicyRequestT& request, const PutMultiRegionAccessPointPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&S3ControlClient::PutMultiRegionAccessPointPolicy, 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(&S3ControlClient::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(&S3ControlClient::PutPublicAccessBlock, request, handler, context);
        }
 
        virtual Model::PutStorageLensConfigurationOutcome PutStorageLensConfiguration(const Model::PutStorageLensConfigurationRequest& request) const;
 
        template<typename PutStorageLensConfigurationRequestT = Model::PutStorageLensConfigurationRequest>
        Model::PutStorageLensConfigurationOutcomeCallable PutStorageLensConfigurationCallable(const PutStorageLensConfigurationRequestT& request) const
        {
            return SubmitCallable(&S3ControlClient::PutStorageLensConfiguration, request);
        }
 
        template<typename PutStorageLensConfigurationRequestT = Model::PutStorageLensConfigurationRequest>
        void PutStorageLensConfigurationAsync(const PutStorageLensConfigurationRequestT& request, const PutStorageLensConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&S3ControlClient::PutStorageLensConfiguration, request, handler, context);
        }
 
        virtual Model::PutStorageLensConfigurationTaggingOutcome PutStorageLensConfigurationTagging(const Model::PutStorageLensConfigurationTaggingRequest& request) const;
 
        template<typename PutStorageLensConfigurationTaggingRequestT = Model::PutStorageLensConfigurationTaggingRequest>
        Model::PutStorageLensConfigurationTaggingOutcomeCallable PutStorageLensConfigurationTaggingCallable(const PutStorageLensConfigurationTaggingRequestT& request) const
        {
            return SubmitCallable(&S3ControlClient::PutStorageLensConfigurationTagging, request);
        }
 
        template<typename PutStorageLensConfigurationTaggingRequestT = Model::PutStorageLensConfigurationTaggingRequest>
        void PutStorageLensConfigurationTaggingAsync(const PutStorageLensConfigurationTaggingRequestT& request, const PutStorageLensConfigurationTaggingResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&S3ControlClient::PutStorageLensConfigurationTagging, request, handler, context);
        }
 
        virtual Model::SubmitMultiRegionAccessPointRoutesOutcome SubmitMultiRegionAccessPointRoutes(const Model::SubmitMultiRegionAccessPointRoutesRequest& request) const;
 
        template<typename SubmitMultiRegionAccessPointRoutesRequestT = Model::SubmitMultiRegionAccessPointRoutesRequest>
        Model::SubmitMultiRegionAccessPointRoutesOutcomeCallable SubmitMultiRegionAccessPointRoutesCallable(const SubmitMultiRegionAccessPointRoutesRequestT& request) const
        {
            return SubmitCallable(&S3ControlClient::SubmitMultiRegionAccessPointRoutes, request);
        }
 
        template<typename SubmitMultiRegionAccessPointRoutesRequestT = Model::SubmitMultiRegionAccessPointRoutesRequest>
        void SubmitMultiRegionAccessPointRoutesAsync(const SubmitMultiRegionAccessPointRoutesRequestT& request, const SubmitMultiRegionAccessPointRoutesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&S3ControlClient::SubmitMultiRegionAccessPointRoutes, request, handler, context);
        }
 
        virtual Model::TagResourceOutcome TagResource(const Model::TagResourceRequest& request) const;
 
        template<typename TagResourceRequestT = Model::TagResourceRequest>
        Model::TagResourceOutcomeCallable TagResourceCallable(const TagResourceRequestT& request) const
        {
            return SubmitCallable(&S3ControlClient::TagResource, request);
        }
 
        template<typename TagResourceRequestT = Model::TagResourceRequest>
        void TagResourceAsync(const TagResourceRequestT& request, const TagResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&S3ControlClient::TagResource, request, handler, context);
        }
 
        virtual Model::UntagResourceOutcome UntagResource(const Model::UntagResourceRequest& request) const;
 
        template<typename UntagResourceRequestT = Model::UntagResourceRequest>
        Model::UntagResourceOutcomeCallable UntagResourceCallable(const UntagResourceRequestT& request) const
        {
            return SubmitCallable(&S3ControlClient::UntagResource, request);
        }
 
        template<typename UntagResourceRequestT = Model::UntagResourceRequest>
        void UntagResourceAsync(const UntagResourceRequestT& request, const UntagResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&S3ControlClient::UntagResource, request, handler, context);
        }
 
        virtual Model::UpdateAccessGrantsLocationOutcome UpdateAccessGrantsLocation(const Model::UpdateAccessGrantsLocationRequest& request) const;
 
        template<typename UpdateAccessGrantsLocationRequestT = Model::UpdateAccessGrantsLocationRequest>
        Model::UpdateAccessGrantsLocationOutcomeCallable UpdateAccessGrantsLocationCallable(const UpdateAccessGrantsLocationRequestT& request) const
        {
            return SubmitCallable(&S3ControlClient::UpdateAccessGrantsLocation, request);
        }
 
        template<typename UpdateAccessGrantsLocationRequestT = Model::UpdateAccessGrantsLocationRequest>
        void UpdateAccessGrantsLocationAsync(const UpdateAccessGrantsLocationRequestT& request, const UpdateAccessGrantsLocationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&S3ControlClient::UpdateAccessGrantsLocation, request, handler, context);
        }
 
        virtual Model::UpdateJobPriorityOutcome UpdateJobPriority(const Model::UpdateJobPriorityRequest& request) const;
 
        template<typename UpdateJobPriorityRequestT = Model::UpdateJobPriorityRequest>
        Model::UpdateJobPriorityOutcomeCallable UpdateJobPriorityCallable(const UpdateJobPriorityRequestT& request) const
        {
            return SubmitCallable(&S3ControlClient::UpdateJobPriority, request);
        }
 
        template<typename UpdateJobPriorityRequestT = Model::UpdateJobPriorityRequest>
        void UpdateJobPriorityAsync(const UpdateJobPriorityRequestT& request, const UpdateJobPriorityResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&S3ControlClient::UpdateJobPriority, request, handler, context);
        }
 
        virtual Model::UpdateJobStatusOutcome UpdateJobStatus(const Model::UpdateJobStatusRequest& request) const;
 
        template<typename UpdateJobStatusRequestT = Model::UpdateJobStatusRequest>
        Model::UpdateJobStatusOutcomeCallable UpdateJobStatusCallable(const UpdateJobStatusRequestT& request) const
        {
            return SubmitCallable(&S3ControlClient::UpdateJobStatus, request);
        }
 
        template<typename UpdateJobStatusRequestT = Model::UpdateJobStatusRequest>
        void UpdateJobStatusAsync(const UpdateJobStatusRequestT& request, const UpdateJobStatusResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&S3ControlClient::UpdateJobStatus, request, handler, context);
        }
 
        virtual Model::UpdateStorageLensGroupOutcome UpdateStorageLensGroup(const Model::UpdateStorageLensGroupRequest& request) const;
 
        template<typename UpdateStorageLensGroupRequestT = Model::UpdateStorageLensGroupRequest>
        Model::UpdateStorageLensGroupOutcomeCallable UpdateStorageLensGroupCallable(const UpdateStorageLensGroupRequestT& request) const
        {
            return SubmitCallable(&S3ControlClient::UpdateStorageLensGroup, request);
        }
 
        template<typename UpdateStorageLensGroupRequestT = Model::UpdateStorageLensGroupRequest>
        void UpdateStorageLensGroupAsync(const UpdateStorageLensGroupRequestT& request, const UpdateStorageLensGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&S3ControlClient::UpdateStorageLensGroup, request, handler, context);
        }
 
 
        void OverrideEndpoint(const Aws::String& endpoint);
        std::shared_ptr<S3ControlEndpointProviderBase>& accessEndpointProvider();
    private:
        friend class Aws::Client::ClientWithAsyncTemplateMethods<S3ControlClient>;
        void init(const S3ControlClientConfiguration& clientConfiguration);
        S3ControlClientConfiguration m_clientConfiguration;
        std::shared_ptr<S3ControlEndpointProviderBase> m_endpointProvider;
    };
 
  } // namespace S3Control
} // namespace Aws