S3ControlClient.h

 
#pragma once
#include <aws/core/auth/AWSAuthSigner.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/utils/DNS.h>
#include <aws/core/utils/xml/XmlSerializer.h>
#include <aws/s3control/S3ControlEndpointProvider.h>
#include <aws/s3control/S3ControlServiceClientModel.h>
#include <aws/s3control/S3Control_EXPORTS.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::DeleteAccessPointScopeOutcome DeleteAccessPointScope(const Model::DeleteAccessPointScopeRequest& request) const;
 
  template <typename DeleteAccessPointScopeRequestT = Model::DeleteAccessPointScopeRequest>
  Model::DeleteAccessPointScopeOutcomeCallable DeleteAccessPointScopeCallable(const DeleteAccessPointScopeRequestT& request) const {
    return SubmitCallable(&S3ControlClient::DeleteAccessPointScope, request);
  }
 
  template <typename DeleteAccessPointScopeRequestT = Model::DeleteAccessPointScopeRequest>
  void DeleteAccessPointScopeAsync(const DeleteAccessPointScopeRequestT& request,
                                   const DeleteAccessPointScopeResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3ControlClient::DeleteAccessPointScope, 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::GetAccessPointScopeOutcome GetAccessPointScope(const Model::GetAccessPointScopeRequest& request) const;
 
  template <typename GetAccessPointScopeRequestT = Model::GetAccessPointScopeRequest>
  Model::GetAccessPointScopeOutcomeCallable GetAccessPointScopeCallable(const GetAccessPointScopeRequestT& request) const {
    return SubmitCallable(&S3ControlClient::GetAccessPointScope, request);
  }
 
  template <typename GetAccessPointScopeRequestT = Model::GetAccessPointScopeRequest>
  void GetAccessPointScopeAsync(const GetAccessPointScopeRequestT& request, const GetAccessPointScopeResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3ControlClient::GetAccessPointScope, 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::ListAccessPointsForDirectoryBucketsOutcome ListAccessPointsForDirectoryBuckets(
      const Model::ListAccessPointsForDirectoryBucketsRequest& request) const;
 
  template <typename ListAccessPointsForDirectoryBucketsRequestT = Model::ListAccessPointsForDirectoryBucketsRequest>
  Model::ListAccessPointsForDirectoryBucketsOutcomeCallable ListAccessPointsForDirectoryBucketsCallable(
      const ListAccessPointsForDirectoryBucketsRequestT& request) const {
    return SubmitCallable(&S3ControlClient::ListAccessPointsForDirectoryBuckets, request);
  }
 
  template <typename ListAccessPointsForDirectoryBucketsRequestT = Model::ListAccessPointsForDirectoryBucketsRequest>
  void ListAccessPointsForDirectoryBucketsAsync(const ListAccessPointsForDirectoryBucketsRequestT& request,
                                                const ListAccessPointsForDirectoryBucketsResponseReceivedHandler& handler,
                                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3ControlClient::ListAccessPointsForDirectoryBuckets, 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::PutAccessPointScopeOutcome PutAccessPointScope(const Model::PutAccessPointScopeRequest& request) const;
 
  template <typename PutAccessPointScopeRequestT = Model::PutAccessPointScopeRequest>
  Model::PutAccessPointScopeOutcomeCallable PutAccessPointScopeCallable(const PutAccessPointScopeRequestT& request) const {
    return SubmitCallable(&S3ControlClient::PutAccessPointScope, request);
  }
 
  template <typename PutAccessPointScopeRequestT = Model::PutAccessPointScopeRequest>
  void PutAccessPointScopeAsync(const PutAccessPointScopeRequestT& request, const PutAccessPointScopeResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3ControlClient::PutAccessPointScope, 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