Macie2Client.h

 
#pragma once
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/macie2/Macie2ServiceClientModel.h>
#include <aws/macie2/Macie2_EXPORTS.h>
 
namespace Aws {
namespace Macie2 {
class AWS_MACIE2_API Macie2Client : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<Macie2Client> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef Macie2ClientConfiguration ClientConfigurationType;
  typedef Macie2EndpointProvider EndpointProviderType;
 
  Macie2Client(const Aws::Macie2::Macie2ClientConfiguration& clientConfiguration = Aws::Macie2::Macie2ClientConfiguration(),
               std::shared_ptr<Macie2EndpointProviderBase> endpointProvider = nullptr);
 
  Macie2Client(const Aws::Auth::AWSCredentials& credentials, std::shared_ptr<Macie2EndpointProviderBase> endpointProvider = nullptr,
               const Aws::Macie2::Macie2ClientConfiguration& clientConfiguration = Aws::Macie2::Macie2ClientConfiguration());
 
  Macie2Client(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
               std::shared_ptr<Macie2EndpointProviderBase> endpointProvider = nullptr,
               const Aws::Macie2::Macie2ClientConfiguration& clientConfiguration = Aws::Macie2::Macie2ClientConfiguration());
 
  /* Legacy constructors due deprecation */
  Macie2Client(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  Macie2Client(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  Macie2Client(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
               const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~Macie2Client();
 
  virtual Model::AcceptInvitationOutcome AcceptInvitation(const Model::AcceptInvitationRequest& request) const;
 
  template <typename AcceptInvitationRequestT = Model::AcceptInvitationRequest>
  Model::AcceptInvitationOutcomeCallable AcceptInvitationCallable(const AcceptInvitationRequestT& request) const {
    return SubmitCallable(&Macie2Client::AcceptInvitation, request);
  }
 
  template <typename AcceptInvitationRequestT = Model::AcceptInvitationRequest>
  void AcceptInvitationAsync(const AcceptInvitationRequestT& request, const AcceptInvitationResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Macie2Client::AcceptInvitation, request, handler, context);
  }
 
  virtual Model::BatchGetCustomDataIdentifiersOutcome BatchGetCustomDataIdentifiers(
      const Model::BatchGetCustomDataIdentifiersRequest& request = {}) const;
 
  template <typename BatchGetCustomDataIdentifiersRequestT = Model::BatchGetCustomDataIdentifiersRequest>
  Model::BatchGetCustomDataIdentifiersOutcomeCallable BatchGetCustomDataIdentifiersCallable(
      const BatchGetCustomDataIdentifiersRequestT& request = {}) const {
    return SubmitCallable(&Macie2Client::BatchGetCustomDataIdentifiers, request);
  }
 
  template <typename BatchGetCustomDataIdentifiersRequestT = Model::BatchGetCustomDataIdentifiersRequest>
  void BatchGetCustomDataIdentifiersAsync(const BatchGetCustomDataIdentifiersResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                          const BatchGetCustomDataIdentifiersRequestT& request = {}) const {
    return SubmitAsync(&Macie2Client::BatchGetCustomDataIdentifiers, request, handler, context);
  }
 
  virtual Model::BatchUpdateAutomatedDiscoveryAccountsOutcome BatchUpdateAutomatedDiscoveryAccounts(
      const Model::BatchUpdateAutomatedDiscoveryAccountsRequest& request = {}) const;
 
  template <typename BatchUpdateAutomatedDiscoveryAccountsRequestT = Model::BatchUpdateAutomatedDiscoveryAccountsRequest>
  Model::BatchUpdateAutomatedDiscoveryAccountsOutcomeCallable BatchUpdateAutomatedDiscoveryAccountsCallable(
      const BatchUpdateAutomatedDiscoveryAccountsRequestT& request = {}) const {
    return SubmitCallable(&Macie2Client::BatchUpdateAutomatedDiscoveryAccounts, request);
  }
 
  template <typename BatchUpdateAutomatedDiscoveryAccountsRequestT = Model::BatchUpdateAutomatedDiscoveryAccountsRequest>
  void BatchUpdateAutomatedDiscoveryAccountsAsync(const BatchUpdateAutomatedDiscoveryAccountsResponseReceivedHandler& handler,
                                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                                  const BatchUpdateAutomatedDiscoveryAccountsRequestT& request = {}) const {
    return SubmitAsync(&Macie2Client::BatchUpdateAutomatedDiscoveryAccounts, request, handler, context);
  }
 
  virtual Model::CreateAllowListOutcome CreateAllowList(const Model::CreateAllowListRequest& request) const;
 
  template <typename CreateAllowListRequestT = Model::CreateAllowListRequest>
  Model::CreateAllowListOutcomeCallable CreateAllowListCallable(const CreateAllowListRequestT& request) const {
    return SubmitCallable(&Macie2Client::CreateAllowList, request);
  }
 
  template <typename CreateAllowListRequestT = Model::CreateAllowListRequest>
  void CreateAllowListAsync(const CreateAllowListRequestT& request, const CreateAllowListResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Macie2Client::CreateAllowList, request, handler, context);
  }
 
  virtual Model::CreateClassificationJobOutcome CreateClassificationJob(const Model::CreateClassificationJobRequest& request) const;
 
  template <typename CreateClassificationJobRequestT = Model::CreateClassificationJobRequest>
  Model::CreateClassificationJobOutcomeCallable CreateClassificationJobCallable(const CreateClassificationJobRequestT& request) const {
    return SubmitCallable(&Macie2Client::CreateClassificationJob, request);
  }
 
  template <typename CreateClassificationJobRequestT = Model::CreateClassificationJobRequest>
  void CreateClassificationJobAsync(const CreateClassificationJobRequestT& request,
                                    const CreateClassificationJobResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Macie2Client::CreateClassificationJob, request, handler, context);
  }
 
  virtual Model::CreateCustomDataIdentifierOutcome CreateCustomDataIdentifier(
      const Model::CreateCustomDataIdentifierRequest& request) const;
 
  template <typename CreateCustomDataIdentifierRequestT = Model::CreateCustomDataIdentifierRequest>
  Model::CreateCustomDataIdentifierOutcomeCallable CreateCustomDataIdentifierCallable(
      const CreateCustomDataIdentifierRequestT& request) const {
    return SubmitCallable(&Macie2Client::CreateCustomDataIdentifier, request);
  }
 
  template <typename CreateCustomDataIdentifierRequestT = Model::CreateCustomDataIdentifierRequest>
  void CreateCustomDataIdentifierAsync(const CreateCustomDataIdentifierRequestT& request,
                                       const CreateCustomDataIdentifierResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Macie2Client::CreateCustomDataIdentifier, request, handler, context);
  }
 
  virtual Model::CreateFindingsFilterOutcome CreateFindingsFilter(const Model::CreateFindingsFilterRequest& request) const;
 
  template <typename CreateFindingsFilterRequestT = Model::CreateFindingsFilterRequest>
  Model::CreateFindingsFilterOutcomeCallable CreateFindingsFilterCallable(const CreateFindingsFilterRequestT& request) const {
    return SubmitCallable(&Macie2Client::CreateFindingsFilter, request);
  }
 
  template <typename CreateFindingsFilterRequestT = Model::CreateFindingsFilterRequest>
  void CreateFindingsFilterAsync(const CreateFindingsFilterRequestT& request, const CreateFindingsFilterResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Macie2Client::CreateFindingsFilter, request, handler, context);
  }
 
  virtual Model::CreateInvitationsOutcome CreateInvitations(const Model::CreateInvitationsRequest& request) const;
 
  template <typename CreateInvitationsRequestT = Model::CreateInvitationsRequest>
  Model::CreateInvitationsOutcomeCallable CreateInvitationsCallable(const CreateInvitationsRequestT& request) const {
    return SubmitCallable(&Macie2Client::CreateInvitations, request);
  }
 
  template <typename CreateInvitationsRequestT = Model::CreateInvitationsRequest>
  void CreateInvitationsAsync(const CreateInvitationsRequestT& request, const CreateInvitationsResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Macie2Client::CreateInvitations, request, handler, context);
  }
 
  virtual Model::CreateMemberOutcome CreateMember(const Model::CreateMemberRequest& request) const;
 
  template <typename CreateMemberRequestT = Model::CreateMemberRequest>
  Model::CreateMemberOutcomeCallable CreateMemberCallable(const CreateMemberRequestT& request) const {
    return SubmitCallable(&Macie2Client::CreateMember, request);
  }
 
  template <typename CreateMemberRequestT = Model::CreateMemberRequest>
  void CreateMemberAsync(const CreateMemberRequestT& request, const CreateMemberResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Macie2Client::CreateMember, request, handler, context);
  }
 
  virtual Model::CreateSampleFindingsOutcome CreateSampleFindings(const Model::CreateSampleFindingsRequest& request = {}) const;
 
  template <typename CreateSampleFindingsRequestT = Model::CreateSampleFindingsRequest>
  Model::CreateSampleFindingsOutcomeCallable CreateSampleFindingsCallable(const CreateSampleFindingsRequestT& request = {}) const {
    return SubmitCallable(&Macie2Client::CreateSampleFindings, request);
  }
 
  template <typename CreateSampleFindingsRequestT = Model::CreateSampleFindingsRequest>
  void CreateSampleFindingsAsync(const CreateSampleFindingsResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                 const CreateSampleFindingsRequestT& request = {}) const {
    return SubmitAsync(&Macie2Client::CreateSampleFindings, request, handler, context);
  }
 
  virtual Model::DeclineInvitationsOutcome DeclineInvitations(const Model::DeclineInvitationsRequest& request) const;
 
  template <typename DeclineInvitationsRequestT = Model::DeclineInvitationsRequest>
  Model::DeclineInvitationsOutcomeCallable DeclineInvitationsCallable(const DeclineInvitationsRequestT& request) const {
    return SubmitCallable(&Macie2Client::DeclineInvitations, request);
  }
 
  template <typename DeclineInvitationsRequestT = Model::DeclineInvitationsRequest>
  void DeclineInvitationsAsync(const DeclineInvitationsRequestT& request, const DeclineInvitationsResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Macie2Client::DeclineInvitations, request, handler, context);
  }
 
  virtual Model::DeleteAllowListOutcome DeleteAllowList(const Model::DeleteAllowListRequest& request) const;
 
  template <typename DeleteAllowListRequestT = Model::DeleteAllowListRequest>
  Model::DeleteAllowListOutcomeCallable DeleteAllowListCallable(const DeleteAllowListRequestT& request) const {
    return SubmitCallable(&Macie2Client::DeleteAllowList, request);
  }
 
  template <typename DeleteAllowListRequestT = Model::DeleteAllowListRequest>
  void DeleteAllowListAsync(const DeleteAllowListRequestT& request, const DeleteAllowListResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Macie2Client::DeleteAllowList, request, handler, context);
  }
 
  virtual Model::DeleteCustomDataIdentifierOutcome DeleteCustomDataIdentifier(
      const Model::DeleteCustomDataIdentifierRequest& request) const;
 
  template <typename DeleteCustomDataIdentifierRequestT = Model::DeleteCustomDataIdentifierRequest>
  Model::DeleteCustomDataIdentifierOutcomeCallable DeleteCustomDataIdentifierCallable(
      const DeleteCustomDataIdentifierRequestT& request) const {
    return SubmitCallable(&Macie2Client::DeleteCustomDataIdentifier, request);
  }
 
  template <typename DeleteCustomDataIdentifierRequestT = Model::DeleteCustomDataIdentifierRequest>
  void DeleteCustomDataIdentifierAsync(const DeleteCustomDataIdentifierRequestT& request,
                                       const DeleteCustomDataIdentifierResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Macie2Client::DeleteCustomDataIdentifier, request, handler, context);
  }
 
  virtual Model::DeleteFindingsFilterOutcome DeleteFindingsFilter(const Model::DeleteFindingsFilterRequest& request) const;
 
  template <typename DeleteFindingsFilterRequestT = Model::DeleteFindingsFilterRequest>
  Model::DeleteFindingsFilterOutcomeCallable DeleteFindingsFilterCallable(const DeleteFindingsFilterRequestT& request) const {
    return SubmitCallable(&Macie2Client::DeleteFindingsFilter, request);
  }
 
  template <typename DeleteFindingsFilterRequestT = Model::DeleteFindingsFilterRequest>
  void DeleteFindingsFilterAsync(const DeleteFindingsFilterRequestT& request, const DeleteFindingsFilterResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Macie2Client::DeleteFindingsFilter, request, handler, context);
  }
 
  virtual Model::DeleteInvitationsOutcome DeleteInvitations(const Model::DeleteInvitationsRequest& request) const;
 
  template <typename DeleteInvitationsRequestT = Model::DeleteInvitationsRequest>
  Model::DeleteInvitationsOutcomeCallable DeleteInvitationsCallable(const DeleteInvitationsRequestT& request) const {
    return SubmitCallable(&Macie2Client::DeleteInvitations, request);
  }
 
  template <typename DeleteInvitationsRequestT = Model::DeleteInvitationsRequest>
  void DeleteInvitationsAsync(const DeleteInvitationsRequestT& request, const DeleteInvitationsResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Macie2Client::DeleteInvitations, request, handler, context);
  }
 
  virtual Model::DeleteMemberOutcome DeleteMember(const Model::DeleteMemberRequest& request) const;
 
  template <typename DeleteMemberRequestT = Model::DeleteMemberRequest>
  Model::DeleteMemberOutcomeCallable DeleteMemberCallable(const DeleteMemberRequestT& request) const {
    return SubmitCallable(&Macie2Client::DeleteMember, request);
  }
 
  template <typename DeleteMemberRequestT = Model::DeleteMemberRequest>
  void DeleteMemberAsync(const DeleteMemberRequestT& request, const DeleteMemberResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Macie2Client::DeleteMember, request, handler, context);
  }
 
  virtual Model::DescribeBucketsOutcome DescribeBuckets(const Model::DescribeBucketsRequest& request = {}) const;
 
  template <typename DescribeBucketsRequestT = Model::DescribeBucketsRequest>
  Model::DescribeBucketsOutcomeCallable DescribeBucketsCallable(const DescribeBucketsRequestT& request = {}) const {
    return SubmitCallable(&Macie2Client::DescribeBuckets, request);
  }
 
  template <typename DescribeBucketsRequestT = Model::DescribeBucketsRequest>
  void DescribeBucketsAsync(const DescribeBucketsResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                            const DescribeBucketsRequestT& request = {}) const {
    return SubmitAsync(&Macie2Client::DescribeBuckets, request, handler, context);
  }
 
  virtual Model::DescribeClassificationJobOutcome DescribeClassificationJob(const Model::DescribeClassificationJobRequest& request) const;
 
  template <typename DescribeClassificationJobRequestT = Model::DescribeClassificationJobRequest>
  Model::DescribeClassificationJobOutcomeCallable DescribeClassificationJobCallable(
      const DescribeClassificationJobRequestT& request) const {
    return SubmitCallable(&Macie2Client::DescribeClassificationJob, request);
  }
 
  template <typename DescribeClassificationJobRequestT = Model::DescribeClassificationJobRequest>
  void DescribeClassificationJobAsync(const DescribeClassificationJobRequestT& request,
                                      const DescribeClassificationJobResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Macie2Client::DescribeClassificationJob, request, handler, context);
  }
 
  virtual Model::DescribeOrganizationConfigurationOutcome DescribeOrganizationConfiguration(
      const Model::DescribeOrganizationConfigurationRequest& request = {}) const;
 
  template <typename DescribeOrganizationConfigurationRequestT = Model::DescribeOrganizationConfigurationRequest>
  Model::DescribeOrganizationConfigurationOutcomeCallable DescribeOrganizationConfigurationCallable(
      const DescribeOrganizationConfigurationRequestT& request = {}) const {
    return SubmitCallable(&Macie2Client::DescribeOrganizationConfiguration, request);
  }
 
  template <typename DescribeOrganizationConfigurationRequestT = Model::DescribeOrganizationConfigurationRequest>
  void DescribeOrganizationConfigurationAsync(const DescribeOrganizationConfigurationResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                              const DescribeOrganizationConfigurationRequestT& request = {}) const {
    return SubmitAsync(&Macie2Client::DescribeOrganizationConfiguration, request, handler, context);
  }
 
  virtual Model::DisableMacieOutcome DisableMacie(const Model::DisableMacieRequest& request = {}) const;
 
  template <typename DisableMacieRequestT = Model::DisableMacieRequest>
  Model::DisableMacieOutcomeCallable DisableMacieCallable(const DisableMacieRequestT& request = {}) const {
    return SubmitCallable(&Macie2Client::DisableMacie, request);
  }
 
  template <typename DisableMacieRequestT = Model::DisableMacieRequest>
  void DisableMacieAsync(const DisableMacieResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                         const DisableMacieRequestT& request = {}) const {
    return SubmitAsync(&Macie2Client::DisableMacie, request, handler, context);
  }
 
  virtual Model::DisableOrganizationAdminAccountOutcome DisableOrganizationAdminAccount(
      const Model::DisableOrganizationAdminAccountRequest& request) const;
 
  template <typename DisableOrganizationAdminAccountRequestT = Model::DisableOrganizationAdminAccountRequest>
  Model::DisableOrganizationAdminAccountOutcomeCallable DisableOrganizationAdminAccountCallable(
      const DisableOrganizationAdminAccountRequestT& request) const {
    return SubmitCallable(&Macie2Client::DisableOrganizationAdminAccount, request);
  }
 
  template <typename DisableOrganizationAdminAccountRequestT = Model::DisableOrganizationAdminAccountRequest>
  void DisableOrganizationAdminAccountAsync(const DisableOrganizationAdminAccountRequestT& request,
                                            const DisableOrganizationAdminAccountResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Macie2Client::DisableOrganizationAdminAccount, request, handler, context);
  }
 
  virtual Model::DisassociateFromAdministratorAccountOutcome DisassociateFromAdministratorAccount(
      const Model::DisassociateFromAdministratorAccountRequest& request = {}) const;
 
  template <typename DisassociateFromAdministratorAccountRequestT = Model::DisassociateFromAdministratorAccountRequest>
  Model::DisassociateFromAdministratorAccountOutcomeCallable DisassociateFromAdministratorAccountCallable(
      const DisassociateFromAdministratorAccountRequestT& request = {}) const {
    return SubmitCallable(&Macie2Client::DisassociateFromAdministratorAccount, request);
  }
 
  template <typename DisassociateFromAdministratorAccountRequestT = Model::DisassociateFromAdministratorAccountRequest>
  void DisassociateFromAdministratorAccountAsync(const DisassociateFromAdministratorAccountResponseReceivedHandler& handler,
                                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                                 const DisassociateFromAdministratorAccountRequestT& request = {}) const {
    return SubmitAsync(&Macie2Client::DisassociateFromAdministratorAccount, request, handler, context);
  }
 
  virtual Model::DisassociateFromMasterAccountOutcome DisassociateFromMasterAccount(
      const Model::DisassociateFromMasterAccountRequest& request = {}) const;
 
  template <typename DisassociateFromMasterAccountRequestT = Model::DisassociateFromMasterAccountRequest>
  Model::DisassociateFromMasterAccountOutcomeCallable DisassociateFromMasterAccountCallable(
      const DisassociateFromMasterAccountRequestT& request = {}) const {
    return SubmitCallable(&Macie2Client::DisassociateFromMasterAccount, request);
  }
 
  template <typename DisassociateFromMasterAccountRequestT = Model::DisassociateFromMasterAccountRequest>
  void DisassociateFromMasterAccountAsync(const DisassociateFromMasterAccountResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                          const DisassociateFromMasterAccountRequestT& request = {}) const {
    return SubmitAsync(&Macie2Client::DisassociateFromMasterAccount, request, handler, context);
  }
 
  virtual Model::DisassociateMemberOutcome DisassociateMember(const Model::DisassociateMemberRequest& request) const;
 
  template <typename DisassociateMemberRequestT = Model::DisassociateMemberRequest>
  Model::DisassociateMemberOutcomeCallable DisassociateMemberCallable(const DisassociateMemberRequestT& request) const {
    return SubmitCallable(&Macie2Client::DisassociateMember, request);
  }
 
  template <typename DisassociateMemberRequestT = Model::DisassociateMemberRequest>
  void DisassociateMemberAsync(const DisassociateMemberRequestT& request, const DisassociateMemberResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Macie2Client::DisassociateMember, request, handler, context);
  }
 
  virtual Model::EnableMacieOutcome EnableMacie(const Model::EnableMacieRequest& request = {}) const;
 
  template <typename EnableMacieRequestT = Model::EnableMacieRequest>
  Model::EnableMacieOutcomeCallable EnableMacieCallable(const EnableMacieRequestT& request = {}) const {
    return SubmitCallable(&Macie2Client::EnableMacie, request);
  }
 
  template <typename EnableMacieRequestT = Model::EnableMacieRequest>
  void EnableMacieAsync(const EnableMacieResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                        const EnableMacieRequestT& request = {}) const {
    return SubmitAsync(&Macie2Client::EnableMacie, request, handler, context);
  }
 
  virtual Model::EnableOrganizationAdminAccountOutcome EnableOrganizationAdminAccount(
      const Model::EnableOrganizationAdminAccountRequest& request) const;
 
  template <typename EnableOrganizationAdminAccountRequestT = Model::EnableOrganizationAdminAccountRequest>
  Model::EnableOrganizationAdminAccountOutcomeCallable EnableOrganizationAdminAccountCallable(
      const EnableOrganizationAdminAccountRequestT& request) const {
    return SubmitCallable(&Macie2Client::EnableOrganizationAdminAccount, request);
  }
 
  template <typename EnableOrganizationAdminAccountRequestT = Model::EnableOrganizationAdminAccountRequest>
  void EnableOrganizationAdminAccountAsync(const EnableOrganizationAdminAccountRequestT& request,
                                           const EnableOrganizationAdminAccountResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Macie2Client::EnableOrganizationAdminAccount, request, handler, context);
  }
 
  virtual Model::GetAdministratorAccountOutcome GetAdministratorAccount(const Model::GetAdministratorAccountRequest& request = {}) const;
 
  template <typename GetAdministratorAccountRequestT = Model::GetAdministratorAccountRequest>
  Model::GetAdministratorAccountOutcomeCallable GetAdministratorAccountCallable(const GetAdministratorAccountRequestT& request = {}) const {
    return SubmitCallable(&Macie2Client::GetAdministratorAccount, request);
  }
 
  template <typename GetAdministratorAccountRequestT = Model::GetAdministratorAccountRequest>
  void GetAdministratorAccountAsync(const GetAdministratorAccountResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                    const GetAdministratorAccountRequestT& request = {}) const {
    return SubmitAsync(&Macie2Client::GetAdministratorAccount, request, handler, context);
  }
 
  virtual Model::GetAllowListOutcome GetAllowList(const Model::GetAllowListRequest& request) const;
 
  template <typename GetAllowListRequestT = Model::GetAllowListRequest>
  Model::GetAllowListOutcomeCallable GetAllowListCallable(const GetAllowListRequestT& request) const {
    return SubmitCallable(&Macie2Client::GetAllowList, request);
  }
 
  template <typename GetAllowListRequestT = Model::GetAllowListRequest>
  void GetAllowListAsync(const GetAllowListRequestT& request, const GetAllowListResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Macie2Client::GetAllowList, request, handler, context);
  }
 
  virtual Model::GetAutomatedDiscoveryConfigurationOutcome GetAutomatedDiscoveryConfiguration(
      const Model::GetAutomatedDiscoveryConfigurationRequest& request = {}) const;
 
  template <typename GetAutomatedDiscoveryConfigurationRequestT = Model::GetAutomatedDiscoveryConfigurationRequest>
  Model::GetAutomatedDiscoveryConfigurationOutcomeCallable GetAutomatedDiscoveryConfigurationCallable(
      const GetAutomatedDiscoveryConfigurationRequestT& request = {}) const {
    return SubmitCallable(&Macie2Client::GetAutomatedDiscoveryConfiguration, request);
  }
 
  template <typename GetAutomatedDiscoveryConfigurationRequestT = Model::GetAutomatedDiscoveryConfigurationRequest>
  void GetAutomatedDiscoveryConfigurationAsync(const GetAutomatedDiscoveryConfigurationResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                               const GetAutomatedDiscoveryConfigurationRequestT& request = {}) const {
    return SubmitAsync(&Macie2Client::GetAutomatedDiscoveryConfiguration, request, handler, context);
  }
 
  virtual Model::GetBucketStatisticsOutcome GetBucketStatistics(const Model::GetBucketStatisticsRequest& request = {}) const;
 
  template <typename GetBucketStatisticsRequestT = Model::GetBucketStatisticsRequest>
  Model::GetBucketStatisticsOutcomeCallable GetBucketStatisticsCallable(const GetBucketStatisticsRequestT& request = {}) const {
    return SubmitCallable(&Macie2Client::GetBucketStatistics, request);
  }
 
  template <typename GetBucketStatisticsRequestT = Model::GetBucketStatisticsRequest>
  void GetBucketStatisticsAsync(const GetBucketStatisticsResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                const GetBucketStatisticsRequestT& request = {}) const {
    return SubmitAsync(&Macie2Client::GetBucketStatistics, request, handler, context);
  }
 
  virtual Model::GetClassificationExportConfigurationOutcome GetClassificationExportConfiguration(
      const Model::GetClassificationExportConfigurationRequest& request = {}) const;
 
  template <typename GetClassificationExportConfigurationRequestT = Model::GetClassificationExportConfigurationRequest>
  Model::GetClassificationExportConfigurationOutcomeCallable GetClassificationExportConfigurationCallable(
      const GetClassificationExportConfigurationRequestT& request = {}) const {
    return SubmitCallable(&Macie2Client::GetClassificationExportConfiguration, request);
  }
 
  template <typename GetClassificationExportConfigurationRequestT = Model::GetClassificationExportConfigurationRequest>
  void GetClassificationExportConfigurationAsync(const GetClassificationExportConfigurationResponseReceivedHandler& handler,
                                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                                 const GetClassificationExportConfigurationRequestT& request = {}) const {
    return SubmitAsync(&Macie2Client::GetClassificationExportConfiguration, request, handler, context);
  }
 
  virtual Model::GetClassificationScopeOutcome GetClassificationScope(const Model::GetClassificationScopeRequest& request) const;
 
  template <typename GetClassificationScopeRequestT = Model::GetClassificationScopeRequest>
  Model::GetClassificationScopeOutcomeCallable GetClassificationScopeCallable(const GetClassificationScopeRequestT& request) const {
    return SubmitCallable(&Macie2Client::GetClassificationScope, request);
  }
 
  template <typename GetClassificationScopeRequestT = Model::GetClassificationScopeRequest>
  void GetClassificationScopeAsync(const GetClassificationScopeRequestT& request,
                                   const GetClassificationScopeResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Macie2Client::GetClassificationScope, request, handler, context);
  }
 
  virtual Model::GetCustomDataIdentifierOutcome GetCustomDataIdentifier(const Model::GetCustomDataIdentifierRequest& request) const;
 
  template <typename GetCustomDataIdentifierRequestT = Model::GetCustomDataIdentifierRequest>
  Model::GetCustomDataIdentifierOutcomeCallable GetCustomDataIdentifierCallable(const GetCustomDataIdentifierRequestT& request) const {
    return SubmitCallable(&Macie2Client::GetCustomDataIdentifier, request);
  }
 
  template <typename GetCustomDataIdentifierRequestT = Model::GetCustomDataIdentifierRequest>
  void GetCustomDataIdentifierAsync(const GetCustomDataIdentifierRequestT& request,
                                    const GetCustomDataIdentifierResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Macie2Client::GetCustomDataIdentifier, request, handler, context);
  }
 
  virtual Model::GetFindingStatisticsOutcome GetFindingStatistics(const Model::GetFindingStatisticsRequest& request) const;
 
  template <typename GetFindingStatisticsRequestT = Model::GetFindingStatisticsRequest>
  Model::GetFindingStatisticsOutcomeCallable GetFindingStatisticsCallable(const GetFindingStatisticsRequestT& request) const {
    return SubmitCallable(&Macie2Client::GetFindingStatistics, request);
  }
 
  template <typename GetFindingStatisticsRequestT = Model::GetFindingStatisticsRequest>
  void GetFindingStatisticsAsync(const GetFindingStatisticsRequestT& request, const GetFindingStatisticsResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Macie2Client::GetFindingStatistics, request, handler, context);
  }
 
  virtual Model::GetFindingsOutcome GetFindings(const Model::GetFindingsRequest& request) const;
 
  template <typename GetFindingsRequestT = Model::GetFindingsRequest>
  Model::GetFindingsOutcomeCallable GetFindingsCallable(const GetFindingsRequestT& request) const {
    return SubmitCallable(&Macie2Client::GetFindings, request);
  }
 
  template <typename GetFindingsRequestT = Model::GetFindingsRequest>
  void GetFindingsAsync(const GetFindingsRequestT& request, const GetFindingsResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Macie2Client::GetFindings, request, handler, context);
  }
 
  virtual Model::GetFindingsFilterOutcome GetFindingsFilter(const Model::GetFindingsFilterRequest& request) const;
 
  template <typename GetFindingsFilterRequestT = Model::GetFindingsFilterRequest>
  Model::GetFindingsFilterOutcomeCallable GetFindingsFilterCallable(const GetFindingsFilterRequestT& request) const {
    return SubmitCallable(&Macie2Client::GetFindingsFilter, request);
  }
 
  template <typename GetFindingsFilterRequestT = Model::GetFindingsFilterRequest>
  void GetFindingsFilterAsync(const GetFindingsFilterRequestT& request, const GetFindingsFilterResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Macie2Client::GetFindingsFilter, request, handler, context);
  }
 
  virtual Model::GetFindingsPublicationConfigurationOutcome GetFindingsPublicationConfiguration(
      const Model::GetFindingsPublicationConfigurationRequest& request = {}) const;
 
  template <typename GetFindingsPublicationConfigurationRequestT = Model::GetFindingsPublicationConfigurationRequest>
  Model::GetFindingsPublicationConfigurationOutcomeCallable GetFindingsPublicationConfigurationCallable(
      const GetFindingsPublicationConfigurationRequestT& request = {}) const {
    return SubmitCallable(&Macie2Client::GetFindingsPublicationConfiguration, request);
  }
 
  template <typename GetFindingsPublicationConfigurationRequestT = Model::GetFindingsPublicationConfigurationRequest>
  void GetFindingsPublicationConfigurationAsync(const GetFindingsPublicationConfigurationResponseReceivedHandler& handler,
                                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                                const GetFindingsPublicationConfigurationRequestT& request = {}) const {
    return SubmitAsync(&Macie2Client::GetFindingsPublicationConfiguration, request, handler, context);
  }
 
  virtual Model::GetInvitationsCountOutcome GetInvitationsCount(const Model::GetInvitationsCountRequest& request = {}) const;
 
  template <typename GetInvitationsCountRequestT = Model::GetInvitationsCountRequest>
  Model::GetInvitationsCountOutcomeCallable GetInvitationsCountCallable(const GetInvitationsCountRequestT& request = {}) const {
    return SubmitCallable(&Macie2Client::GetInvitationsCount, request);
  }
 
  template <typename GetInvitationsCountRequestT = Model::GetInvitationsCountRequest>
  void GetInvitationsCountAsync(const GetInvitationsCountResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                const GetInvitationsCountRequestT& request = {}) const {
    return SubmitAsync(&Macie2Client::GetInvitationsCount, request, handler, context);
  }
 
  virtual Model::GetMacieSessionOutcome GetMacieSession(const Model::GetMacieSessionRequest& request = {}) const;
 
  template <typename GetMacieSessionRequestT = Model::GetMacieSessionRequest>
  Model::GetMacieSessionOutcomeCallable GetMacieSessionCallable(const GetMacieSessionRequestT& request = {}) const {
    return SubmitCallable(&Macie2Client::GetMacieSession, request);
  }
 
  template <typename GetMacieSessionRequestT = Model::GetMacieSessionRequest>
  void GetMacieSessionAsync(const GetMacieSessionResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                            const GetMacieSessionRequestT& request = {}) const {
    return SubmitAsync(&Macie2Client::GetMacieSession, request, handler, context);
  }
 
  virtual Model::GetMasterAccountOutcome GetMasterAccount(const Model::GetMasterAccountRequest& request = {}) const;
 
  template <typename GetMasterAccountRequestT = Model::GetMasterAccountRequest>
  Model::GetMasterAccountOutcomeCallable GetMasterAccountCallable(const GetMasterAccountRequestT& request = {}) const {
    return SubmitCallable(&Macie2Client::GetMasterAccount, request);
  }
 
  template <typename GetMasterAccountRequestT = Model::GetMasterAccountRequest>
  void GetMasterAccountAsync(const GetMasterAccountResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                             const GetMasterAccountRequestT& request = {}) const {
    return SubmitAsync(&Macie2Client::GetMasterAccount, request, handler, context);
  }
 
  virtual Model::GetMemberOutcome GetMember(const Model::GetMemberRequest& request) const;
 
  template <typename GetMemberRequestT = Model::GetMemberRequest>
  Model::GetMemberOutcomeCallable GetMemberCallable(const GetMemberRequestT& request) const {
    return SubmitCallable(&Macie2Client::GetMember, request);
  }
 
  template <typename GetMemberRequestT = Model::GetMemberRequest>
  void GetMemberAsync(const GetMemberRequestT& request, const GetMemberResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Macie2Client::GetMember, request, handler, context);
  }
 
  virtual Model::GetResourceProfileOutcome GetResourceProfile(const Model::GetResourceProfileRequest& request) const;
 
  template <typename GetResourceProfileRequestT = Model::GetResourceProfileRequest>
  Model::GetResourceProfileOutcomeCallable GetResourceProfileCallable(const GetResourceProfileRequestT& request) const {
    return SubmitCallable(&Macie2Client::GetResourceProfile, request);
  }
 
  template <typename GetResourceProfileRequestT = Model::GetResourceProfileRequest>
  void GetResourceProfileAsync(const GetResourceProfileRequestT& request, const GetResourceProfileResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Macie2Client::GetResourceProfile, request, handler, context);
  }
 
  virtual Model::GetRevealConfigurationOutcome GetRevealConfiguration(const Model::GetRevealConfigurationRequest& request = {}) const;
 
  template <typename GetRevealConfigurationRequestT = Model::GetRevealConfigurationRequest>
  Model::GetRevealConfigurationOutcomeCallable GetRevealConfigurationCallable(const GetRevealConfigurationRequestT& request = {}) const {
    return SubmitCallable(&Macie2Client::GetRevealConfiguration, request);
  }
 
  template <typename GetRevealConfigurationRequestT = Model::GetRevealConfigurationRequest>
  void GetRevealConfigurationAsync(const GetRevealConfigurationResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                   const GetRevealConfigurationRequestT& request = {}) const {
    return SubmitAsync(&Macie2Client::GetRevealConfiguration, request, handler, context);
  }
 
  virtual Model::GetSensitiveDataOccurrencesOutcome GetSensitiveDataOccurrences(
      const Model::GetSensitiveDataOccurrencesRequest& request) const;
 
  template <typename GetSensitiveDataOccurrencesRequestT = Model::GetSensitiveDataOccurrencesRequest>
  Model::GetSensitiveDataOccurrencesOutcomeCallable GetSensitiveDataOccurrencesCallable(
      const GetSensitiveDataOccurrencesRequestT& request) const {
    return SubmitCallable(&Macie2Client::GetSensitiveDataOccurrences, request);
  }
 
  template <typename GetSensitiveDataOccurrencesRequestT = Model::GetSensitiveDataOccurrencesRequest>
  void GetSensitiveDataOccurrencesAsync(const GetSensitiveDataOccurrencesRequestT& request,
                                        const GetSensitiveDataOccurrencesResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Macie2Client::GetSensitiveDataOccurrences, request, handler, context);
  }
 
  virtual Model::GetSensitiveDataOccurrencesAvailabilityOutcome GetSensitiveDataOccurrencesAvailability(
      const Model::GetSensitiveDataOccurrencesAvailabilityRequest& request) const;
 
  template <typename GetSensitiveDataOccurrencesAvailabilityRequestT = Model::GetSensitiveDataOccurrencesAvailabilityRequest>
  Model::GetSensitiveDataOccurrencesAvailabilityOutcomeCallable GetSensitiveDataOccurrencesAvailabilityCallable(
      const GetSensitiveDataOccurrencesAvailabilityRequestT& request) const {
    return SubmitCallable(&Macie2Client::GetSensitiveDataOccurrencesAvailability, request);
  }
 
  template <typename GetSensitiveDataOccurrencesAvailabilityRequestT = Model::GetSensitiveDataOccurrencesAvailabilityRequest>
  void GetSensitiveDataOccurrencesAvailabilityAsync(const GetSensitiveDataOccurrencesAvailabilityRequestT& request,
                                                    const GetSensitiveDataOccurrencesAvailabilityResponseReceivedHandler& handler,
                                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Macie2Client::GetSensitiveDataOccurrencesAvailability, request, handler, context);
  }
 
  virtual Model::GetSensitivityInspectionTemplateOutcome GetSensitivityInspectionTemplate(
      const Model::GetSensitivityInspectionTemplateRequest& request) const;
 
  template <typename GetSensitivityInspectionTemplateRequestT = Model::GetSensitivityInspectionTemplateRequest>
  Model::GetSensitivityInspectionTemplateOutcomeCallable GetSensitivityInspectionTemplateCallable(
      const GetSensitivityInspectionTemplateRequestT& request) const {
    return SubmitCallable(&Macie2Client::GetSensitivityInspectionTemplate, request);
  }
 
  template <typename GetSensitivityInspectionTemplateRequestT = Model::GetSensitivityInspectionTemplateRequest>
  void GetSensitivityInspectionTemplateAsync(const GetSensitivityInspectionTemplateRequestT& request,
                                             const GetSensitivityInspectionTemplateResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Macie2Client::GetSensitivityInspectionTemplate, request, handler, context);
  }
 
  virtual Model::GetUsageStatisticsOutcome GetUsageStatistics(const Model::GetUsageStatisticsRequest& request = {}) const;
 
  template <typename GetUsageStatisticsRequestT = Model::GetUsageStatisticsRequest>
  Model::GetUsageStatisticsOutcomeCallable GetUsageStatisticsCallable(const GetUsageStatisticsRequestT& request = {}) const {
    return SubmitCallable(&Macie2Client::GetUsageStatistics, request);
  }
 
  template <typename GetUsageStatisticsRequestT = Model::GetUsageStatisticsRequest>
  void GetUsageStatisticsAsync(const GetUsageStatisticsResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                               const GetUsageStatisticsRequestT& request = {}) const {
    return SubmitAsync(&Macie2Client::GetUsageStatistics, request, handler, context);
  }
 
  virtual Model::GetUsageTotalsOutcome GetUsageTotals(const Model::GetUsageTotalsRequest& request = {}) const;
 
  template <typename GetUsageTotalsRequestT = Model::GetUsageTotalsRequest>
  Model::GetUsageTotalsOutcomeCallable GetUsageTotalsCallable(const GetUsageTotalsRequestT& request = {}) const {
    return SubmitCallable(&Macie2Client::GetUsageTotals, request);
  }
 
  template <typename GetUsageTotalsRequestT = Model::GetUsageTotalsRequest>
  void GetUsageTotalsAsync(const GetUsageTotalsResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                           const GetUsageTotalsRequestT& request = {}) const {
    return SubmitAsync(&Macie2Client::GetUsageTotals, request, handler, context);
  }
 
  virtual Model::ListAllowListsOutcome ListAllowLists(const Model::ListAllowListsRequest& request = {}) const;
 
  template <typename ListAllowListsRequestT = Model::ListAllowListsRequest>
  Model::ListAllowListsOutcomeCallable ListAllowListsCallable(const ListAllowListsRequestT& request = {}) const {
    return SubmitCallable(&Macie2Client::ListAllowLists, request);
  }
 
  template <typename ListAllowListsRequestT = Model::ListAllowListsRequest>
  void ListAllowListsAsync(const ListAllowListsResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                           const ListAllowListsRequestT& request = {}) const {
    return SubmitAsync(&Macie2Client::ListAllowLists, request, handler, context);
  }
 
  virtual Model::ListAutomatedDiscoveryAccountsOutcome ListAutomatedDiscoveryAccounts(
      const Model::ListAutomatedDiscoveryAccountsRequest& request = {}) const;
 
  template <typename ListAutomatedDiscoveryAccountsRequestT = Model::ListAutomatedDiscoveryAccountsRequest>
  Model::ListAutomatedDiscoveryAccountsOutcomeCallable ListAutomatedDiscoveryAccountsCallable(
      const ListAutomatedDiscoveryAccountsRequestT& request = {}) const {
    return SubmitCallable(&Macie2Client::ListAutomatedDiscoveryAccounts, request);
  }
 
  template <typename ListAutomatedDiscoveryAccountsRequestT = Model::ListAutomatedDiscoveryAccountsRequest>
  void ListAutomatedDiscoveryAccountsAsync(const ListAutomatedDiscoveryAccountsResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                           const ListAutomatedDiscoveryAccountsRequestT& request = {}) const {
    return SubmitAsync(&Macie2Client::ListAutomatedDiscoveryAccounts, request, handler, context);
  }
 
  virtual Model::ListClassificationJobsOutcome ListClassificationJobs(const Model::ListClassificationJobsRequest& request = {}) const;
 
  template <typename ListClassificationJobsRequestT = Model::ListClassificationJobsRequest>
  Model::ListClassificationJobsOutcomeCallable ListClassificationJobsCallable(const ListClassificationJobsRequestT& request = {}) const {
    return SubmitCallable(&Macie2Client::ListClassificationJobs, request);
  }
 
  template <typename ListClassificationJobsRequestT = Model::ListClassificationJobsRequest>
  void ListClassificationJobsAsync(const ListClassificationJobsResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                   const ListClassificationJobsRequestT& request = {}) const {
    return SubmitAsync(&Macie2Client::ListClassificationJobs, request, handler, context);
  }
 
  virtual Model::ListClassificationScopesOutcome ListClassificationScopes(const Model::ListClassificationScopesRequest& request = {}) const;
 
  template <typename ListClassificationScopesRequestT = Model::ListClassificationScopesRequest>
  Model::ListClassificationScopesOutcomeCallable ListClassificationScopesCallable(
      const ListClassificationScopesRequestT& request = {}) const {
    return SubmitCallable(&Macie2Client::ListClassificationScopes, request);
  }
 
  template <typename ListClassificationScopesRequestT = Model::ListClassificationScopesRequest>
  void ListClassificationScopesAsync(const ListClassificationScopesResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                     const ListClassificationScopesRequestT& request = {}) const {
    return SubmitAsync(&Macie2Client::ListClassificationScopes, request, handler, context);
  }
 
  virtual Model::ListCustomDataIdentifiersOutcome ListCustomDataIdentifiers(
      const Model::ListCustomDataIdentifiersRequest& request = {}) const;
 
  template <typename ListCustomDataIdentifiersRequestT = Model::ListCustomDataIdentifiersRequest>
  Model::ListCustomDataIdentifiersOutcomeCallable ListCustomDataIdentifiersCallable(
      const ListCustomDataIdentifiersRequestT& request = {}) const {
    return SubmitCallable(&Macie2Client::ListCustomDataIdentifiers, request);
  }
 
  template <typename ListCustomDataIdentifiersRequestT = Model::ListCustomDataIdentifiersRequest>
  void ListCustomDataIdentifiersAsync(const ListCustomDataIdentifiersResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                      const ListCustomDataIdentifiersRequestT& request = {}) const {
    return SubmitAsync(&Macie2Client::ListCustomDataIdentifiers, request, handler, context);
  }
 
  virtual Model::ListFindingsOutcome ListFindings(const Model::ListFindingsRequest& request = {}) const;
 
  template <typename ListFindingsRequestT = Model::ListFindingsRequest>
  Model::ListFindingsOutcomeCallable ListFindingsCallable(const ListFindingsRequestT& request = {}) const {
    return SubmitCallable(&Macie2Client::ListFindings, request);
  }
 
  template <typename ListFindingsRequestT = Model::ListFindingsRequest>
  void ListFindingsAsync(const ListFindingsResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                         const ListFindingsRequestT& request = {}) const {
    return SubmitAsync(&Macie2Client::ListFindings, request, handler, context);
  }
 
  virtual Model::ListFindingsFiltersOutcome ListFindingsFilters(const Model::ListFindingsFiltersRequest& request = {}) const;
 
  template <typename ListFindingsFiltersRequestT = Model::ListFindingsFiltersRequest>
  Model::ListFindingsFiltersOutcomeCallable ListFindingsFiltersCallable(const ListFindingsFiltersRequestT& request = {}) const {
    return SubmitCallable(&Macie2Client::ListFindingsFilters, request);
  }
 
  template <typename ListFindingsFiltersRequestT = Model::ListFindingsFiltersRequest>
  void ListFindingsFiltersAsync(const ListFindingsFiltersResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                const ListFindingsFiltersRequestT& request = {}) const {
    return SubmitAsync(&Macie2Client::ListFindingsFilters, request, handler, context);
  }
 
  virtual Model::ListInvitationsOutcome ListInvitations(const Model::ListInvitationsRequest& request = {}) const;
 
  template <typename ListInvitationsRequestT = Model::ListInvitationsRequest>
  Model::ListInvitationsOutcomeCallable ListInvitationsCallable(const ListInvitationsRequestT& request = {}) const {
    return SubmitCallable(&Macie2Client::ListInvitations, request);
  }
 
  template <typename ListInvitationsRequestT = Model::ListInvitationsRequest>
  void ListInvitationsAsync(const ListInvitationsResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                            const ListInvitationsRequestT& request = {}) const {
    return SubmitAsync(&Macie2Client::ListInvitations, request, handler, context);
  }
 
  virtual Model::ListManagedDataIdentifiersOutcome ListManagedDataIdentifiers(
      const Model::ListManagedDataIdentifiersRequest& request = {}) const;
 
  template <typename ListManagedDataIdentifiersRequestT = Model::ListManagedDataIdentifiersRequest>
  Model::ListManagedDataIdentifiersOutcomeCallable ListManagedDataIdentifiersCallable(
      const ListManagedDataIdentifiersRequestT& request = {}) const {
    return SubmitCallable(&Macie2Client::ListManagedDataIdentifiers, request);
  }
 
  template <typename ListManagedDataIdentifiersRequestT = Model::ListManagedDataIdentifiersRequest>
  void ListManagedDataIdentifiersAsync(const ListManagedDataIdentifiersResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                       const ListManagedDataIdentifiersRequestT& request = {}) const {
    return SubmitAsync(&Macie2Client::ListManagedDataIdentifiers, request, handler, context);
  }
 
  virtual Model::ListMembersOutcome ListMembers(const Model::ListMembersRequest& request = {}) const;
 
  template <typename ListMembersRequestT = Model::ListMembersRequest>
  Model::ListMembersOutcomeCallable ListMembersCallable(const ListMembersRequestT& request = {}) const {
    return SubmitCallable(&Macie2Client::ListMembers, request);
  }
 
  template <typename ListMembersRequestT = Model::ListMembersRequest>
  void ListMembersAsync(const ListMembersResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                        const ListMembersRequestT& request = {}) const {
    return SubmitAsync(&Macie2Client::ListMembers, request, handler, context);
  }
 
  virtual Model::ListOrganizationAdminAccountsOutcome ListOrganizationAdminAccounts(
      const Model::ListOrganizationAdminAccountsRequest& request = {}) const;
 
  template <typename ListOrganizationAdminAccountsRequestT = Model::ListOrganizationAdminAccountsRequest>
  Model::ListOrganizationAdminAccountsOutcomeCallable ListOrganizationAdminAccountsCallable(
      const ListOrganizationAdminAccountsRequestT& request = {}) const {
    return SubmitCallable(&Macie2Client::ListOrganizationAdminAccounts, request);
  }
 
  template <typename ListOrganizationAdminAccountsRequestT = Model::ListOrganizationAdminAccountsRequest>
  void ListOrganizationAdminAccountsAsync(const ListOrganizationAdminAccountsResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                          const ListOrganizationAdminAccountsRequestT& request = {}) const {
    return SubmitAsync(&Macie2Client::ListOrganizationAdminAccounts, request, handler, context);
  }
 
  virtual Model::ListResourceProfileArtifactsOutcome ListResourceProfileArtifacts(
      const Model::ListResourceProfileArtifactsRequest& request) const;
 
  template <typename ListResourceProfileArtifactsRequestT = Model::ListResourceProfileArtifactsRequest>
  Model::ListResourceProfileArtifactsOutcomeCallable ListResourceProfileArtifactsCallable(
      const ListResourceProfileArtifactsRequestT& request) const {
    return SubmitCallable(&Macie2Client::ListResourceProfileArtifacts, request);
  }
 
  template <typename ListResourceProfileArtifactsRequestT = Model::ListResourceProfileArtifactsRequest>
  void ListResourceProfileArtifactsAsync(const ListResourceProfileArtifactsRequestT& request,
                                         const ListResourceProfileArtifactsResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Macie2Client::ListResourceProfileArtifacts, request, handler, context);
  }
 
  virtual Model::ListResourceProfileDetectionsOutcome ListResourceProfileDetections(
      const Model::ListResourceProfileDetectionsRequest& request) const;
 
  template <typename ListResourceProfileDetectionsRequestT = Model::ListResourceProfileDetectionsRequest>
  Model::ListResourceProfileDetectionsOutcomeCallable ListResourceProfileDetectionsCallable(
      const ListResourceProfileDetectionsRequestT& request) const {
    return SubmitCallable(&Macie2Client::ListResourceProfileDetections, request);
  }
 
  template <typename ListResourceProfileDetectionsRequestT = Model::ListResourceProfileDetectionsRequest>
  void ListResourceProfileDetectionsAsync(const ListResourceProfileDetectionsRequestT& request,
                                          const ListResourceProfileDetectionsResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Macie2Client::ListResourceProfileDetections, request, handler, context);
  }
 
  virtual Model::ListSensitivityInspectionTemplatesOutcome ListSensitivityInspectionTemplates(
      const Model::ListSensitivityInspectionTemplatesRequest& request = {}) const;
 
  template <typename ListSensitivityInspectionTemplatesRequestT = Model::ListSensitivityInspectionTemplatesRequest>
  Model::ListSensitivityInspectionTemplatesOutcomeCallable ListSensitivityInspectionTemplatesCallable(
      const ListSensitivityInspectionTemplatesRequestT& request = {}) const {
    return SubmitCallable(&Macie2Client::ListSensitivityInspectionTemplates, request);
  }
 
  template <typename ListSensitivityInspectionTemplatesRequestT = Model::ListSensitivityInspectionTemplatesRequest>
  void ListSensitivityInspectionTemplatesAsync(const ListSensitivityInspectionTemplatesResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                               const ListSensitivityInspectionTemplatesRequestT& request = {}) const {
    return SubmitAsync(&Macie2Client::ListSensitivityInspectionTemplates, 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(&Macie2Client::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(&Macie2Client::ListTagsForResource, request, handler, context);
  }
 
  virtual Model::PutClassificationExportConfigurationOutcome PutClassificationExportConfiguration(
      const Model::PutClassificationExportConfigurationRequest& request) const;
 
  template <typename PutClassificationExportConfigurationRequestT = Model::PutClassificationExportConfigurationRequest>
  Model::PutClassificationExportConfigurationOutcomeCallable PutClassificationExportConfigurationCallable(
      const PutClassificationExportConfigurationRequestT& request) const {
    return SubmitCallable(&Macie2Client::PutClassificationExportConfiguration, request);
  }
 
  template <typename PutClassificationExportConfigurationRequestT = Model::PutClassificationExportConfigurationRequest>
  void PutClassificationExportConfigurationAsync(const PutClassificationExportConfigurationRequestT& request,
                                                 const PutClassificationExportConfigurationResponseReceivedHandler& handler,
                                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Macie2Client::PutClassificationExportConfiguration, request, handler, context);
  }
 
  virtual Model::PutFindingsPublicationConfigurationOutcome PutFindingsPublicationConfiguration(
      const Model::PutFindingsPublicationConfigurationRequest& request = {}) const;
 
  template <typename PutFindingsPublicationConfigurationRequestT = Model::PutFindingsPublicationConfigurationRequest>
  Model::PutFindingsPublicationConfigurationOutcomeCallable PutFindingsPublicationConfigurationCallable(
      const PutFindingsPublicationConfigurationRequestT& request = {}) const {
    return SubmitCallable(&Macie2Client::PutFindingsPublicationConfiguration, request);
  }
 
  template <typename PutFindingsPublicationConfigurationRequestT = Model::PutFindingsPublicationConfigurationRequest>
  void PutFindingsPublicationConfigurationAsync(const PutFindingsPublicationConfigurationResponseReceivedHandler& handler,
                                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                                const PutFindingsPublicationConfigurationRequestT& request = {}) const {
    return SubmitAsync(&Macie2Client::PutFindingsPublicationConfiguration, request, handler, context);
  }
 
  virtual Model::SearchResourcesOutcome SearchResources(const Model::SearchResourcesRequest& request = {}) const;
 
  template <typename SearchResourcesRequestT = Model::SearchResourcesRequest>
  Model::SearchResourcesOutcomeCallable SearchResourcesCallable(const SearchResourcesRequestT& request = {}) const {
    return SubmitCallable(&Macie2Client::SearchResources, request);
  }
 
  template <typename SearchResourcesRequestT = Model::SearchResourcesRequest>
  void SearchResourcesAsync(const SearchResourcesResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                            const SearchResourcesRequestT& request = {}) const {
    return SubmitAsync(&Macie2Client::SearchResources, 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(&Macie2Client::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(&Macie2Client::TagResource, request, handler, context);
  }
 
  virtual Model::TestCustomDataIdentifierOutcome TestCustomDataIdentifier(const Model::TestCustomDataIdentifierRequest& request) const;
 
  template <typename TestCustomDataIdentifierRequestT = Model::TestCustomDataIdentifierRequest>
  Model::TestCustomDataIdentifierOutcomeCallable TestCustomDataIdentifierCallable(const TestCustomDataIdentifierRequestT& request) const {
    return SubmitCallable(&Macie2Client::TestCustomDataIdentifier, request);
  }
 
  template <typename TestCustomDataIdentifierRequestT = Model::TestCustomDataIdentifierRequest>
  void TestCustomDataIdentifierAsync(const TestCustomDataIdentifierRequestT& request,
                                     const TestCustomDataIdentifierResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Macie2Client::TestCustomDataIdentifier, 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(&Macie2Client::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(&Macie2Client::UntagResource, request, handler, context);
  }
 
  virtual Model::UpdateAllowListOutcome UpdateAllowList(const Model::UpdateAllowListRequest& request) const;
 
  template <typename UpdateAllowListRequestT = Model::UpdateAllowListRequest>
  Model::UpdateAllowListOutcomeCallable UpdateAllowListCallable(const UpdateAllowListRequestT& request) const {
    return SubmitCallable(&Macie2Client::UpdateAllowList, request);
  }
 
  template <typename UpdateAllowListRequestT = Model::UpdateAllowListRequest>
  void UpdateAllowListAsync(const UpdateAllowListRequestT& request, const UpdateAllowListResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Macie2Client::UpdateAllowList, request, handler, context);
  }
 
  virtual Model::UpdateAutomatedDiscoveryConfigurationOutcome UpdateAutomatedDiscoveryConfiguration(
      const Model::UpdateAutomatedDiscoveryConfigurationRequest& request) const;
 
  template <typename UpdateAutomatedDiscoveryConfigurationRequestT = Model::UpdateAutomatedDiscoveryConfigurationRequest>
  Model::UpdateAutomatedDiscoveryConfigurationOutcomeCallable UpdateAutomatedDiscoveryConfigurationCallable(
      const UpdateAutomatedDiscoveryConfigurationRequestT& request) const {
    return SubmitCallable(&Macie2Client::UpdateAutomatedDiscoveryConfiguration, request);
  }
 
  template <typename UpdateAutomatedDiscoveryConfigurationRequestT = Model::UpdateAutomatedDiscoveryConfigurationRequest>
  void UpdateAutomatedDiscoveryConfigurationAsync(const UpdateAutomatedDiscoveryConfigurationRequestT& request,
                                                  const UpdateAutomatedDiscoveryConfigurationResponseReceivedHandler& handler,
                                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Macie2Client::UpdateAutomatedDiscoveryConfiguration, request, handler, context);
  }
 
  virtual Model::UpdateClassificationJobOutcome UpdateClassificationJob(const Model::UpdateClassificationJobRequest& request) const;
 
  template <typename UpdateClassificationJobRequestT = Model::UpdateClassificationJobRequest>
  Model::UpdateClassificationJobOutcomeCallable UpdateClassificationJobCallable(const UpdateClassificationJobRequestT& request) const {
    return SubmitCallable(&Macie2Client::UpdateClassificationJob, request);
  }
 
  template <typename UpdateClassificationJobRequestT = Model::UpdateClassificationJobRequest>
  void UpdateClassificationJobAsync(const UpdateClassificationJobRequestT& request,
                                    const UpdateClassificationJobResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Macie2Client::UpdateClassificationJob, request, handler, context);
  }
 
  virtual Model::UpdateClassificationScopeOutcome UpdateClassificationScope(const Model::UpdateClassificationScopeRequest& request) const;
 
  template <typename UpdateClassificationScopeRequestT = Model::UpdateClassificationScopeRequest>
  Model::UpdateClassificationScopeOutcomeCallable UpdateClassificationScopeCallable(
      const UpdateClassificationScopeRequestT& request) const {
    return SubmitCallable(&Macie2Client::UpdateClassificationScope, request);
  }
 
  template <typename UpdateClassificationScopeRequestT = Model::UpdateClassificationScopeRequest>
  void UpdateClassificationScopeAsync(const UpdateClassificationScopeRequestT& request,
                                      const UpdateClassificationScopeResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Macie2Client::UpdateClassificationScope, request, handler, context);
  }
 
  virtual Model::UpdateFindingsFilterOutcome UpdateFindingsFilter(const Model::UpdateFindingsFilterRequest& request) const;
 
  template <typename UpdateFindingsFilterRequestT = Model::UpdateFindingsFilterRequest>
  Model::UpdateFindingsFilterOutcomeCallable UpdateFindingsFilterCallable(const UpdateFindingsFilterRequestT& request) const {
    return SubmitCallable(&Macie2Client::UpdateFindingsFilter, request);
  }
 
  template <typename UpdateFindingsFilterRequestT = Model::UpdateFindingsFilterRequest>
  void UpdateFindingsFilterAsync(const UpdateFindingsFilterRequestT& request, const UpdateFindingsFilterResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Macie2Client::UpdateFindingsFilter, request, handler, context);
  }
 
  virtual Model::UpdateMacieSessionOutcome UpdateMacieSession(const Model::UpdateMacieSessionRequest& request = {}) const;
 
  template <typename UpdateMacieSessionRequestT = Model::UpdateMacieSessionRequest>
  Model::UpdateMacieSessionOutcomeCallable UpdateMacieSessionCallable(const UpdateMacieSessionRequestT& request = {}) const {
    return SubmitCallable(&Macie2Client::UpdateMacieSession, request);
  }
 
  template <typename UpdateMacieSessionRequestT = Model::UpdateMacieSessionRequest>
  void UpdateMacieSessionAsync(const UpdateMacieSessionResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                               const UpdateMacieSessionRequestT& request = {}) const {
    return SubmitAsync(&Macie2Client::UpdateMacieSession, request, handler, context);
  }
 
  virtual Model::UpdateMemberSessionOutcome UpdateMemberSession(const Model::UpdateMemberSessionRequest& request) const;
 
  template <typename UpdateMemberSessionRequestT = Model::UpdateMemberSessionRequest>
  Model::UpdateMemberSessionOutcomeCallable UpdateMemberSessionCallable(const UpdateMemberSessionRequestT& request) const {
    return SubmitCallable(&Macie2Client::UpdateMemberSession, request);
  }
 
  template <typename UpdateMemberSessionRequestT = Model::UpdateMemberSessionRequest>
  void UpdateMemberSessionAsync(const UpdateMemberSessionRequestT& request, const UpdateMemberSessionResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Macie2Client::UpdateMemberSession, request, handler, context);
  }
 
  virtual Model::UpdateOrganizationConfigurationOutcome UpdateOrganizationConfiguration(
      const Model::UpdateOrganizationConfigurationRequest& request) const;
 
  template <typename UpdateOrganizationConfigurationRequestT = Model::UpdateOrganizationConfigurationRequest>
  Model::UpdateOrganizationConfigurationOutcomeCallable UpdateOrganizationConfigurationCallable(
      const UpdateOrganizationConfigurationRequestT& request) const {
    return SubmitCallable(&Macie2Client::UpdateOrganizationConfiguration, request);
  }
 
  template <typename UpdateOrganizationConfigurationRequestT = Model::UpdateOrganizationConfigurationRequest>
  void UpdateOrganizationConfigurationAsync(const UpdateOrganizationConfigurationRequestT& request,
                                            const UpdateOrganizationConfigurationResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Macie2Client::UpdateOrganizationConfiguration, request, handler, context);
  }
 
  virtual Model::UpdateResourceProfileOutcome UpdateResourceProfile(const Model::UpdateResourceProfileRequest& request) const;
 
  template <typename UpdateResourceProfileRequestT = Model::UpdateResourceProfileRequest>
  Model::UpdateResourceProfileOutcomeCallable UpdateResourceProfileCallable(const UpdateResourceProfileRequestT& request) const {
    return SubmitCallable(&Macie2Client::UpdateResourceProfile, request);
  }
 
  template <typename UpdateResourceProfileRequestT = Model::UpdateResourceProfileRequest>
  void UpdateResourceProfileAsync(const UpdateResourceProfileRequestT& request, const UpdateResourceProfileResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Macie2Client::UpdateResourceProfile, request, handler, context);
  }
 
  virtual Model::UpdateResourceProfileDetectionsOutcome UpdateResourceProfileDetections(
      const Model::UpdateResourceProfileDetectionsRequest& request) const;
 
  template <typename UpdateResourceProfileDetectionsRequestT = Model::UpdateResourceProfileDetectionsRequest>
  Model::UpdateResourceProfileDetectionsOutcomeCallable UpdateResourceProfileDetectionsCallable(
      const UpdateResourceProfileDetectionsRequestT& request) const {
    return SubmitCallable(&Macie2Client::UpdateResourceProfileDetections, request);
  }
 
  template <typename UpdateResourceProfileDetectionsRequestT = Model::UpdateResourceProfileDetectionsRequest>
  void UpdateResourceProfileDetectionsAsync(const UpdateResourceProfileDetectionsRequestT& request,
                                            const UpdateResourceProfileDetectionsResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Macie2Client::UpdateResourceProfileDetections, request, handler, context);
  }
 
  virtual Model::UpdateRevealConfigurationOutcome UpdateRevealConfiguration(const Model::UpdateRevealConfigurationRequest& request) const;
 
  template <typename UpdateRevealConfigurationRequestT = Model::UpdateRevealConfigurationRequest>
  Model::UpdateRevealConfigurationOutcomeCallable UpdateRevealConfigurationCallable(
      const UpdateRevealConfigurationRequestT& request) const {
    return SubmitCallable(&Macie2Client::UpdateRevealConfiguration, request);
  }
 
  template <typename UpdateRevealConfigurationRequestT = Model::UpdateRevealConfigurationRequest>
  void UpdateRevealConfigurationAsync(const UpdateRevealConfigurationRequestT& request,
                                      const UpdateRevealConfigurationResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Macie2Client::UpdateRevealConfiguration, request, handler, context);
  }
 
  virtual Model::UpdateSensitivityInspectionTemplateOutcome UpdateSensitivityInspectionTemplate(
      const Model::UpdateSensitivityInspectionTemplateRequest& request) const;
 
  template <typename UpdateSensitivityInspectionTemplateRequestT = Model::UpdateSensitivityInspectionTemplateRequest>
  Model::UpdateSensitivityInspectionTemplateOutcomeCallable UpdateSensitivityInspectionTemplateCallable(
      const UpdateSensitivityInspectionTemplateRequestT& request) const {
    return SubmitCallable(&Macie2Client::UpdateSensitivityInspectionTemplate, request);
  }
 
  template <typename UpdateSensitivityInspectionTemplateRequestT = Model::UpdateSensitivityInspectionTemplateRequest>
  void UpdateSensitivityInspectionTemplateAsync(const UpdateSensitivityInspectionTemplateRequestT& request,
                                                const UpdateSensitivityInspectionTemplateResponseReceivedHandler& handler,
                                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Macie2Client::UpdateSensitivityInspectionTemplate, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<Macie2EndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<Macie2Client>;
  void init(const Macie2ClientConfiguration& clientConfiguration);
 
  Macie2ClientConfiguration m_clientConfiguration;
  std::shared_ptr<Macie2EndpointProviderBase> m_endpointProvider;
};
 
}  // namespace Macie2
}  // namespace Aws