Macie2Client.h

 
#pragma once
#include <aws/macie2/Macie2_EXPORTS.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/macie2/Macie2ServiceClientModel.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);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      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