GuardDutyClient.h

 
#pragma once
#include <aws/guardduty/GuardDuty_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/guardduty/GuardDutyServiceClientModel.h>
 
namespace Aws
{
namespace GuardDuty
{
  class AWS_GUARDDUTY_API GuardDutyClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<GuardDutyClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef GuardDutyClientConfiguration ClientConfigurationType;
      typedef GuardDutyEndpointProvider EndpointProviderType;
 
        GuardDutyClient(const Aws::GuardDuty::GuardDutyClientConfiguration& clientConfiguration = Aws::GuardDuty::GuardDutyClientConfiguration(),
                        std::shared_ptr<GuardDutyEndpointProviderBase> endpointProvider = nullptr);
 
        GuardDutyClient(const Aws::Auth::AWSCredentials& credentials,
                        std::shared_ptr<GuardDutyEndpointProviderBase> endpointProvider = nullptr,
                        const Aws::GuardDuty::GuardDutyClientConfiguration& clientConfiguration = Aws::GuardDuty::GuardDutyClientConfiguration());
 
        GuardDutyClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                        std::shared_ptr<GuardDutyEndpointProviderBase> endpointProvider = nullptr,
                        const Aws::GuardDuty::GuardDutyClientConfiguration& clientConfiguration = Aws::GuardDuty::GuardDutyClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        GuardDutyClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        GuardDutyClient(const Aws::Auth::AWSCredentials& credentials,
                        const Aws::Client::ClientConfiguration& clientConfiguration);
 
        GuardDutyClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                        const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~GuardDutyClient();
 
        virtual Model::AcceptAdministratorInvitationOutcome AcceptAdministratorInvitation(const Model::AcceptAdministratorInvitationRequest& request) const;
 
        template<typename AcceptAdministratorInvitationRequestT = Model::AcceptAdministratorInvitationRequest>
        Model::AcceptAdministratorInvitationOutcomeCallable AcceptAdministratorInvitationCallable(const AcceptAdministratorInvitationRequestT& request) const
        {
            return SubmitCallable(&GuardDutyClient::AcceptAdministratorInvitation, request);
        }
 
        template<typename AcceptAdministratorInvitationRequestT = Model::AcceptAdministratorInvitationRequest>
        void AcceptAdministratorInvitationAsync(const AcceptAdministratorInvitationRequestT& request, const AcceptAdministratorInvitationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GuardDutyClient::AcceptAdministratorInvitation, request, handler, context);
        }
 
        virtual Model::ArchiveFindingsOutcome ArchiveFindings(const Model::ArchiveFindingsRequest& request) const;
 
        template<typename ArchiveFindingsRequestT = Model::ArchiveFindingsRequest>
        Model::ArchiveFindingsOutcomeCallable ArchiveFindingsCallable(const ArchiveFindingsRequestT& request) const
        {
            return SubmitCallable(&GuardDutyClient::ArchiveFindings, request);
        }
 
        template<typename ArchiveFindingsRequestT = Model::ArchiveFindingsRequest>
        void ArchiveFindingsAsync(const ArchiveFindingsRequestT& request, const ArchiveFindingsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GuardDutyClient::ArchiveFindings, request, handler, context);
        }
 
        virtual Model::CreateDetectorOutcome CreateDetector(const Model::CreateDetectorRequest& request) const;
 
        template<typename CreateDetectorRequestT = Model::CreateDetectorRequest>
        Model::CreateDetectorOutcomeCallable CreateDetectorCallable(const CreateDetectorRequestT& request) const
        {
            return SubmitCallable(&GuardDutyClient::CreateDetector, request);
        }
 
        template<typename CreateDetectorRequestT = Model::CreateDetectorRequest>
        void CreateDetectorAsync(const CreateDetectorRequestT& request, const CreateDetectorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GuardDutyClient::CreateDetector, request, handler, context);
        }
 
        virtual Model::CreateFilterOutcome CreateFilter(const Model::CreateFilterRequest& request) const;
 
        template<typename CreateFilterRequestT = Model::CreateFilterRequest>
        Model::CreateFilterOutcomeCallable CreateFilterCallable(const CreateFilterRequestT& request) const
        {
            return SubmitCallable(&GuardDutyClient::CreateFilter, request);
        }
 
        template<typename CreateFilterRequestT = Model::CreateFilterRequest>
        void CreateFilterAsync(const CreateFilterRequestT& request, const CreateFilterResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GuardDutyClient::CreateFilter, request, handler, context);
        }
 
        virtual Model::CreateIPSetOutcome CreateIPSet(const Model::CreateIPSetRequest& request) const;
 
        template<typename CreateIPSetRequestT = Model::CreateIPSetRequest>
        Model::CreateIPSetOutcomeCallable CreateIPSetCallable(const CreateIPSetRequestT& request) const
        {
            return SubmitCallable(&GuardDutyClient::CreateIPSet, request);
        }
 
        template<typename CreateIPSetRequestT = Model::CreateIPSetRequest>
        void CreateIPSetAsync(const CreateIPSetRequestT& request, const CreateIPSetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GuardDutyClient::CreateIPSet, request, handler, context);
        }
 
        virtual Model::CreateMalwareProtectionPlanOutcome CreateMalwareProtectionPlan(const Model::CreateMalwareProtectionPlanRequest& request) const;
 
        template<typename CreateMalwareProtectionPlanRequestT = Model::CreateMalwareProtectionPlanRequest>
        Model::CreateMalwareProtectionPlanOutcomeCallable CreateMalwareProtectionPlanCallable(const CreateMalwareProtectionPlanRequestT& request) const
        {
            return SubmitCallable(&GuardDutyClient::CreateMalwareProtectionPlan, request);
        }
 
        template<typename CreateMalwareProtectionPlanRequestT = Model::CreateMalwareProtectionPlanRequest>
        void CreateMalwareProtectionPlanAsync(const CreateMalwareProtectionPlanRequestT& request, const CreateMalwareProtectionPlanResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GuardDutyClient::CreateMalwareProtectionPlan, request, handler, context);
        }
 
        virtual Model::CreateMembersOutcome CreateMembers(const Model::CreateMembersRequest& request) const;
 
        template<typename CreateMembersRequestT = Model::CreateMembersRequest>
        Model::CreateMembersOutcomeCallable CreateMembersCallable(const CreateMembersRequestT& request) const
        {
            return SubmitCallable(&GuardDutyClient::CreateMembers, request);
        }
 
        template<typename CreateMembersRequestT = Model::CreateMembersRequest>
        void CreateMembersAsync(const CreateMembersRequestT& request, const CreateMembersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GuardDutyClient::CreateMembers, request, handler, context);
        }
 
        virtual Model::CreatePublishingDestinationOutcome CreatePublishingDestination(const Model::CreatePublishingDestinationRequest& request) const;
 
        template<typename CreatePublishingDestinationRequestT = Model::CreatePublishingDestinationRequest>
        Model::CreatePublishingDestinationOutcomeCallable CreatePublishingDestinationCallable(const CreatePublishingDestinationRequestT& request) const
        {
            return SubmitCallable(&GuardDutyClient::CreatePublishingDestination, request);
        }
 
        template<typename CreatePublishingDestinationRequestT = Model::CreatePublishingDestinationRequest>
        void CreatePublishingDestinationAsync(const CreatePublishingDestinationRequestT& request, const CreatePublishingDestinationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GuardDutyClient::CreatePublishingDestination, 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(&GuardDutyClient::CreateSampleFindings, request);
        }
 
        template<typename CreateSampleFindingsRequestT = Model::CreateSampleFindingsRequest>
        void CreateSampleFindingsAsync(const CreateSampleFindingsRequestT& request, const CreateSampleFindingsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GuardDutyClient::CreateSampleFindings, request, handler, context);
        }
 
        virtual Model::CreateThreatEntitySetOutcome CreateThreatEntitySet(const Model::CreateThreatEntitySetRequest& request) const;
 
        template<typename CreateThreatEntitySetRequestT = Model::CreateThreatEntitySetRequest>
        Model::CreateThreatEntitySetOutcomeCallable CreateThreatEntitySetCallable(const CreateThreatEntitySetRequestT& request) const
        {
            return SubmitCallable(&GuardDutyClient::CreateThreatEntitySet, request);
        }
 
        template<typename CreateThreatEntitySetRequestT = Model::CreateThreatEntitySetRequest>
        void CreateThreatEntitySetAsync(const CreateThreatEntitySetRequestT& request, const CreateThreatEntitySetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GuardDutyClient::CreateThreatEntitySet, request, handler, context);
        }
 
        virtual Model::CreateThreatIntelSetOutcome CreateThreatIntelSet(const Model::CreateThreatIntelSetRequest& request) const;
 
        template<typename CreateThreatIntelSetRequestT = Model::CreateThreatIntelSetRequest>
        Model::CreateThreatIntelSetOutcomeCallable CreateThreatIntelSetCallable(const CreateThreatIntelSetRequestT& request) const
        {
            return SubmitCallable(&GuardDutyClient::CreateThreatIntelSet, request);
        }
 
        template<typename CreateThreatIntelSetRequestT = Model::CreateThreatIntelSetRequest>
        void CreateThreatIntelSetAsync(const CreateThreatIntelSetRequestT& request, const CreateThreatIntelSetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GuardDutyClient::CreateThreatIntelSet, request, handler, context);
        }
 
        virtual Model::CreateTrustedEntitySetOutcome CreateTrustedEntitySet(const Model::CreateTrustedEntitySetRequest& request) const;
 
        template<typename CreateTrustedEntitySetRequestT = Model::CreateTrustedEntitySetRequest>
        Model::CreateTrustedEntitySetOutcomeCallable CreateTrustedEntitySetCallable(const CreateTrustedEntitySetRequestT& request) const
        {
            return SubmitCallable(&GuardDutyClient::CreateTrustedEntitySet, request);
        }
 
        template<typename CreateTrustedEntitySetRequestT = Model::CreateTrustedEntitySetRequest>
        void CreateTrustedEntitySetAsync(const CreateTrustedEntitySetRequestT& request, const CreateTrustedEntitySetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GuardDutyClient::CreateTrustedEntitySet, 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(&GuardDutyClient::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(&GuardDutyClient::DeclineInvitations, request, handler, context);
        }
 
        virtual Model::DeleteDetectorOutcome DeleteDetector(const Model::DeleteDetectorRequest& request) const;
 
        template<typename DeleteDetectorRequestT = Model::DeleteDetectorRequest>
        Model::DeleteDetectorOutcomeCallable DeleteDetectorCallable(const DeleteDetectorRequestT& request) const
        {
            return SubmitCallable(&GuardDutyClient::DeleteDetector, request);
        }
 
        template<typename DeleteDetectorRequestT = Model::DeleteDetectorRequest>
        void DeleteDetectorAsync(const DeleteDetectorRequestT& request, const DeleteDetectorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GuardDutyClient::DeleteDetector, request, handler, context);
        }
 
        virtual Model::DeleteFilterOutcome DeleteFilter(const Model::DeleteFilterRequest& request) const;
 
        template<typename DeleteFilterRequestT = Model::DeleteFilterRequest>
        Model::DeleteFilterOutcomeCallable DeleteFilterCallable(const DeleteFilterRequestT& request) const
        {
            return SubmitCallable(&GuardDutyClient::DeleteFilter, request);
        }
 
        template<typename DeleteFilterRequestT = Model::DeleteFilterRequest>
        void DeleteFilterAsync(const DeleteFilterRequestT& request, const DeleteFilterResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GuardDutyClient::DeleteFilter, request, handler, context);
        }
 
        virtual Model::DeleteIPSetOutcome DeleteIPSet(const Model::DeleteIPSetRequest& request) const;
 
        template<typename DeleteIPSetRequestT = Model::DeleteIPSetRequest>
        Model::DeleteIPSetOutcomeCallable DeleteIPSetCallable(const DeleteIPSetRequestT& request) const
        {
            return SubmitCallable(&GuardDutyClient::DeleteIPSet, request);
        }
 
        template<typename DeleteIPSetRequestT = Model::DeleteIPSetRequest>
        void DeleteIPSetAsync(const DeleteIPSetRequestT& request, const DeleteIPSetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GuardDutyClient::DeleteIPSet, 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(&GuardDutyClient::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(&GuardDutyClient::DeleteInvitations, request, handler, context);
        }
 
        virtual Model::DeleteMalwareProtectionPlanOutcome DeleteMalwareProtectionPlan(const Model::DeleteMalwareProtectionPlanRequest& request) const;
 
        template<typename DeleteMalwareProtectionPlanRequestT = Model::DeleteMalwareProtectionPlanRequest>
        Model::DeleteMalwareProtectionPlanOutcomeCallable DeleteMalwareProtectionPlanCallable(const DeleteMalwareProtectionPlanRequestT& request) const
        {
            return SubmitCallable(&GuardDutyClient::DeleteMalwareProtectionPlan, request);
        }
 
        template<typename DeleteMalwareProtectionPlanRequestT = Model::DeleteMalwareProtectionPlanRequest>
        void DeleteMalwareProtectionPlanAsync(const DeleteMalwareProtectionPlanRequestT& request, const DeleteMalwareProtectionPlanResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GuardDutyClient::DeleteMalwareProtectionPlan, request, handler, context);
        }
 
        virtual Model::DeleteMembersOutcome DeleteMembers(const Model::DeleteMembersRequest& request) const;
 
        template<typename DeleteMembersRequestT = Model::DeleteMembersRequest>
        Model::DeleteMembersOutcomeCallable DeleteMembersCallable(const DeleteMembersRequestT& request) const
        {
            return SubmitCallable(&GuardDutyClient::DeleteMembers, request);
        }
 
        template<typename DeleteMembersRequestT = Model::DeleteMembersRequest>
        void DeleteMembersAsync(const DeleteMembersRequestT& request, const DeleteMembersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GuardDutyClient::DeleteMembers, request, handler, context);
        }
 
        virtual Model::DeletePublishingDestinationOutcome DeletePublishingDestination(const Model::DeletePublishingDestinationRequest& request) const;
 
        template<typename DeletePublishingDestinationRequestT = Model::DeletePublishingDestinationRequest>
        Model::DeletePublishingDestinationOutcomeCallable DeletePublishingDestinationCallable(const DeletePublishingDestinationRequestT& request) const
        {
            return SubmitCallable(&GuardDutyClient::DeletePublishingDestination, request);
        }
 
        template<typename DeletePublishingDestinationRequestT = Model::DeletePublishingDestinationRequest>
        void DeletePublishingDestinationAsync(const DeletePublishingDestinationRequestT& request, const DeletePublishingDestinationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GuardDutyClient::DeletePublishingDestination, request, handler, context);
        }
 
        virtual Model::DeleteThreatEntitySetOutcome DeleteThreatEntitySet(const Model::DeleteThreatEntitySetRequest& request) const;
 
        template<typename DeleteThreatEntitySetRequestT = Model::DeleteThreatEntitySetRequest>
        Model::DeleteThreatEntitySetOutcomeCallable DeleteThreatEntitySetCallable(const DeleteThreatEntitySetRequestT& request) const
        {
            return SubmitCallable(&GuardDutyClient::DeleteThreatEntitySet, request);
        }
 
        template<typename DeleteThreatEntitySetRequestT = Model::DeleteThreatEntitySetRequest>
        void DeleteThreatEntitySetAsync(const DeleteThreatEntitySetRequestT& request, const DeleteThreatEntitySetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GuardDutyClient::DeleteThreatEntitySet, request, handler, context);
        }
 
        virtual Model::DeleteThreatIntelSetOutcome DeleteThreatIntelSet(const Model::DeleteThreatIntelSetRequest& request) const;
 
        template<typename DeleteThreatIntelSetRequestT = Model::DeleteThreatIntelSetRequest>
        Model::DeleteThreatIntelSetOutcomeCallable DeleteThreatIntelSetCallable(const DeleteThreatIntelSetRequestT& request) const
        {
            return SubmitCallable(&GuardDutyClient::DeleteThreatIntelSet, request);
        }
 
        template<typename DeleteThreatIntelSetRequestT = Model::DeleteThreatIntelSetRequest>
        void DeleteThreatIntelSetAsync(const DeleteThreatIntelSetRequestT& request, const DeleteThreatIntelSetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GuardDutyClient::DeleteThreatIntelSet, request, handler, context);
        }
 
        virtual Model::DeleteTrustedEntitySetOutcome DeleteTrustedEntitySet(const Model::DeleteTrustedEntitySetRequest& request) const;
 
        template<typename DeleteTrustedEntitySetRequestT = Model::DeleteTrustedEntitySetRequest>
        Model::DeleteTrustedEntitySetOutcomeCallable DeleteTrustedEntitySetCallable(const DeleteTrustedEntitySetRequestT& request) const
        {
            return SubmitCallable(&GuardDutyClient::DeleteTrustedEntitySet, request);
        }
 
        template<typename DeleteTrustedEntitySetRequestT = Model::DeleteTrustedEntitySetRequest>
        void DeleteTrustedEntitySetAsync(const DeleteTrustedEntitySetRequestT& request, const DeleteTrustedEntitySetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GuardDutyClient::DeleteTrustedEntitySet, request, handler, context);
        }
 
        virtual Model::DescribeMalwareScansOutcome DescribeMalwareScans(const Model::DescribeMalwareScansRequest& request) const;
 
        template<typename DescribeMalwareScansRequestT = Model::DescribeMalwareScansRequest>
        Model::DescribeMalwareScansOutcomeCallable DescribeMalwareScansCallable(const DescribeMalwareScansRequestT& request) const
        {
            return SubmitCallable(&GuardDutyClient::DescribeMalwareScans, request);
        }
 
        template<typename DescribeMalwareScansRequestT = Model::DescribeMalwareScansRequest>
        void DescribeMalwareScansAsync(const DescribeMalwareScansRequestT& request, const DescribeMalwareScansResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GuardDutyClient::DescribeMalwareScans, 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(&GuardDutyClient::DescribeOrganizationConfiguration, request);
        }
 
        template<typename DescribeOrganizationConfigurationRequestT = Model::DescribeOrganizationConfigurationRequest>
        void DescribeOrganizationConfigurationAsync(const DescribeOrganizationConfigurationRequestT& request, const DescribeOrganizationConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GuardDutyClient::DescribeOrganizationConfiguration, request, handler, context);
        }
 
        virtual Model::DescribePublishingDestinationOutcome DescribePublishingDestination(const Model::DescribePublishingDestinationRequest& request) const;
 
        template<typename DescribePublishingDestinationRequestT = Model::DescribePublishingDestinationRequest>
        Model::DescribePublishingDestinationOutcomeCallable DescribePublishingDestinationCallable(const DescribePublishingDestinationRequestT& request) const
        {
            return SubmitCallable(&GuardDutyClient::DescribePublishingDestination, request);
        }
 
        template<typename DescribePublishingDestinationRequestT = Model::DescribePublishingDestinationRequest>
        void DescribePublishingDestinationAsync(const DescribePublishingDestinationRequestT& request, const DescribePublishingDestinationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GuardDutyClient::DescribePublishingDestination, 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(&GuardDutyClient::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(&GuardDutyClient::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(&GuardDutyClient::DisassociateFromAdministratorAccount, request);
        }
 
        template<typename DisassociateFromAdministratorAccountRequestT = Model::DisassociateFromAdministratorAccountRequest>
        void DisassociateFromAdministratorAccountAsync(const DisassociateFromAdministratorAccountRequestT& request, const DisassociateFromAdministratorAccountResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GuardDutyClient::DisassociateFromAdministratorAccount, request, handler, context);
        }
 
        virtual Model::DisassociateMembersOutcome DisassociateMembers(const Model::DisassociateMembersRequest& request) const;
 
        template<typename DisassociateMembersRequestT = Model::DisassociateMembersRequest>
        Model::DisassociateMembersOutcomeCallable DisassociateMembersCallable(const DisassociateMembersRequestT& request) const
        {
            return SubmitCallable(&GuardDutyClient::DisassociateMembers, request);
        }
 
        template<typename DisassociateMembersRequestT = Model::DisassociateMembersRequest>
        void DisassociateMembersAsync(const DisassociateMembersRequestT& request, const DisassociateMembersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GuardDutyClient::DisassociateMembers, 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(&GuardDutyClient::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(&GuardDutyClient::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(&GuardDutyClient::GetAdministratorAccount, request);
        }
 
        template<typename GetAdministratorAccountRequestT = Model::GetAdministratorAccountRequest>
        void GetAdministratorAccountAsync(const GetAdministratorAccountRequestT& request, const GetAdministratorAccountResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GuardDutyClient::GetAdministratorAccount, request, handler, context);
        }
 
        virtual Model::GetCoverageStatisticsOutcome GetCoverageStatistics(const Model::GetCoverageStatisticsRequest& request) const;
 
        template<typename GetCoverageStatisticsRequestT = Model::GetCoverageStatisticsRequest>
        Model::GetCoverageStatisticsOutcomeCallable GetCoverageStatisticsCallable(const GetCoverageStatisticsRequestT& request) const
        {
            return SubmitCallable(&GuardDutyClient::GetCoverageStatistics, request);
        }
 
        template<typename GetCoverageStatisticsRequestT = Model::GetCoverageStatisticsRequest>
        void GetCoverageStatisticsAsync(const GetCoverageStatisticsRequestT& request, const GetCoverageStatisticsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GuardDutyClient::GetCoverageStatistics, request, handler, context);
        }
 
        virtual Model::GetDetectorOutcome GetDetector(const Model::GetDetectorRequest& request) const;
 
        template<typename GetDetectorRequestT = Model::GetDetectorRequest>
        Model::GetDetectorOutcomeCallable GetDetectorCallable(const GetDetectorRequestT& request) const
        {
            return SubmitCallable(&GuardDutyClient::GetDetector, request);
        }
 
        template<typename GetDetectorRequestT = Model::GetDetectorRequest>
        void GetDetectorAsync(const GetDetectorRequestT& request, const GetDetectorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GuardDutyClient::GetDetector, request, handler, context);
        }
 
        virtual Model::GetFilterOutcome GetFilter(const Model::GetFilterRequest& request) const;
 
        template<typename GetFilterRequestT = Model::GetFilterRequest>
        Model::GetFilterOutcomeCallable GetFilterCallable(const GetFilterRequestT& request) const
        {
            return SubmitCallable(&GuardDutyClient::GetFilter, request);
        }
 
        template<typename GetFilterRequestT = Model::GetFilterRequest>
        void GetFilterAsync(const GetFilterRequestT& request, const GetFilterResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GuardDutyClient::GetFilter, 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(&GuardDutyClient::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(&GuardDutyClient::GetFindings, request, handler, context);
        }
 
        virtual Model::GetFindingsStatisticsOutcome GetFindingsStatistics(const Model::GetFindingsStatisticsRequest& request) const;
 
        template<typename GetFindingsStatisticsRequestT = Model::GetFindingsStatisticsRequest>
        Model::GetFindingsStatisticsOutcomeCallable GetFindingsStatisticsCallable(const GetFindingsStatisticsRequestT& request) const
        {
            return SubmitCallable(&GuardDutyClient::GetFindingsStatistics, request);
        }
 
        template<typename GetFindingsStatisticsRequestT = Model::GetFindingsStatisticsRequest>
        void GetFindingsStatisticsAsync(const GetFindingsStatisticsRequestT& request, const GetFindingsStatisticsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GuardDutyClient::GetFindingsStatistics, request, handler, context);
        }
 
        virtual Model::GetIPSetOutcome GetIPSet(const Model::GetIPSetRequest& request) const;
 
        template<typename GetIPSetRequestT = Model::GetIPSetRequest>
        Model::GetIPSetOutcomeCallable GetIPSetCallable(const GetIPSetRequestT& request) const
        {
            return SubmitCallable(&GuardDutyClient::GetIPSet, request);
        }
 
        template<typename GetIPSetRequestT = Model::GetIPSetRequest>
        void GetIPSetAsync(const GetIPSetRequestT& request, const GetIPSetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GuardDutyClient::GetIPSet, 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(&GuardDutyClient::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(&GuardDutyClient::GetInvitationsCount, request, handler, context);
        }
 
        virtual Model::GetMalwareProtectionPlanOutcome GetMalwareProtectionPlan(const Model::GetMalwareProtectionPlanRequest& request) const;
 
        template<typename GetMalwareProtectionPlanRequestT = Model::GetMalwareProtectionPlanRequest>
        Model::GetMalwareProtectionPlanOutcomeCallable GetMalwareProtectionPlanCallable(const GetMalwareProtectionPlanRequestT& request) const
        {
            return SubmitCallable(&GuardDutyClient::GetMalwareProtectionPlan, request);
        }
 
        template<typename GetMalwareProtectionPlanRequestT = Model::GetMalwareProtectionPlanRequest>
        void GetMalwareProtectionPlanAsync(const GetMalwareProtectionPlanRequestT& request, const GetMalwareProtectionPlanResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GuardDutyClient::GetMalwareProtectionPlan, request, handler, context);
        }
 
        virtual Model::GetMalwareScanSettingsOutcome GetMalwareScanSettings(const Model::GetMalwareScanSettingsRequest& request) const;
 
        template<typename GetMalwareScanSettingsRequestT = Model::GetMalwareScanSettingsRequest>
        Model::GetMalwareScanSettingsOutcomeCallable GetMalwareScanSettingsCallable(const GetMalwareScanSettingsRequestT& request) const
        {
            return SubmitCallable(&GuardDutyClient::GetMalwareScanSettings, request);
        }
 
        template<typename GetMalwareScanSettingsRequestT = Model::GetMalwareScanSettingsRequest>
        void GetMalwareScanSettingsAsync(const GetMalwareScanSettingsRequestT& request, const GetMalwareScanSettingsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GuardDutyClient::GetMalwareScanSettings, request, handler, context);
        }
 
        virtual Model::GetMemberDetectorsOutcome GetMemberDetectors(const Model::GetMemberDetectorsRequest& request) const;
 
        template<typename GetMemberDetectorsRequestT = Model::GetMemberDetectorsRequest>
        Model::GetMemberDetectorsOutcomeCallable GetMemberDetectorsCallable(const GetMemberDetectorsRequestT& request) const
        {
            return SubmitCallable(&GuardDutyClient::GetMemberDetectors, request);
        }
 
        template<typename GetMemberDetectorsRequestT = Model::GetMemberDetectorsRequest>
        void GetMemberDetectorsAsync(const GetMemberDetectorsRequestT& request, const GetMemberDetectorsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GuardDutyClient::GetMemberDetectors, request, handler, context);
        }
 
        virtual Model::GetMembersOutcome GetMembers(const Model::GetMembersRequest& request) const;
 
        template<typename GetMembersRequestT = Model::GetMembersRequest>
        Model::GetMembersOutcomeCallable GetMembersCallable(const GetMembersRequestT& request) const
        {
            return SubmitCallable(&GuardDutyClient::GetMembers, request);
        }
 
        template<typename GetMembersRequestT = Model::GetMembersRequest>
        void GetMembersAsync(const GetMembersRequestT& request, const GetMembersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GuardDutyClient::GetMembers, request, handler, context);
        }
 
        virtual Model::GetOrganizationStatisticsOutcome GetOrganizationStatistics(const Model::GetOrganizationStatisticsRequest& request = {}) const;
 
        template<typename GetOrganizationStatisticsRequestT = Model::GetOrganizationStatisticsRequest>
        Model::GetOrganizationStatisticsOutcomeCallable GetOrganizationStatisticsCallable(const GetOrganizationStatisticsRequestT& request = {}) const
        {
            return SubmitCallable(&GuardDutyClient::GetOrganizationStatistics, request);
        }
 
        template<typename GetOrganizationStatisticsRequestT = Model::GetOrganizationStatisticsRequest>
        void GetOrganizationStatisticsAsync(const GetOrganizationStatisticsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetOrganizationStatisticsRequestT& request = {}) const
        {
            return SubmitAsync(&GuardDutyClient::GetOrganizationStatistics, request, handler, context);
        }
 
        virtual Model::GetRemainingFreeTrialDaysOutcome GetRemainingFreeTrialDays(const Model::GetRemainingFreeTrialDaysRequest& request) const;
 
        template<typename GetRemainingFreeTrialDaysRequestT = Model::GetRemainingFreeTrialDaysRequest>
        Model::GetRemainingFreeTrialDaysOutcomeCallable GetRemainingFreeTrialDaysCallable(const GetRemainingFreeTrialDaysRequestT& request) const
        {
            return SubmitCallable(&GuardDutyClient::GetRemainingFreeTrialDays, request);
        }
 
        template<typename GetRemainingFreeTrialDaysRequestT = Model::GetRemainingFreeTrialDaysRequest>
        void GetRemainingFreeTrialDaysAsync(const GetRemainingFreeTrialDaysRequestT& request, const GetRemainingFreeTrialDaysResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GuardDutyClient::GetRemainingFreeTrialDays, request, handler, context);
        }
 
        virtual Model::GetThreatEntitySetOutcome GetThreatEntitySet(const Model::GetThreatEntitySetRequest& request) const;
 
        template<typename GetThreatEntitySetRequestT = Model::GetThreatEntitySetRequest>
        Model::GetThreatEntitySetOutcomeCallable GetThreatEntitySetCallable(const GetThreatEntitySetRequestT& request) const
        {
            return SubmitCallable(&GuardDutyClient::GetThreatEntitySet, request);
        }
 
        template<typename GetThreatEntitySetRequestT = Model::GetThreatEntitySetRequest>
        void GetThreatEntitySetAsync(const GetThreatEntitySetRequestT& request, const GetThreatEntitySetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GuardDutyClient::GetThreatEntitySet, request, handler, context);
        }
 
        virtual Model::GetThreatIntelSetOutcome GetThreatIntelSet(const Model::GetThreatIntelSetRequest& request) const;
 
        template<typename GetThreatIntelSetRequestT = Model::GetThreatIntelSetRequest>
        Model::GetThreatIntelSetOutcomeCallable GetThreatIntelSetCallable(const GetThreatIntelSetRequestT& request) const
        {
            return SubmitCallable(&GuardDutyClient::GetThreatIntelSet, request);
        }
 
        template<typename GetThreatIntelSetRequestT = Model::GetThreatIntelSetRequest>
        void GetThreatIntelSetAsync(const GetThreatIntelSetRequestT& request, const GetThreatIntelSetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GuardDutyClient::GetThreatIntelSet, request, handler, context);
        }
 
        virtual Model::GetTrustedEntitySetOutcome GetTrustedEntitySet(const Model::GetTrustedEntitySetRequest& request) const;
 
        template<typename GetTrustedEntitySetRequestT = Model::GetTrustedEntitySetRequest>
        Model::GetTrustedEntitySetOutcomeCallable GetTrustedEntitySetCallable(const GetTrustedEntitySetRequestT& request) const
        {
            return SubmitCallable(&GuardDutyClient::GetTrustedEntitySet, request);
        }
 
        template<typename GetTrustedEntitySetRequestT = Model::GetTrustedEntitySetRequest>
        void GetTrustedEntitySetAsync(const GetTrustedEntitySetRequestT& request, const GetTrustedEntitySetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GuardDutyClient::GetTrustedEntitySet, 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(&GuardDutyClient::GetUsageStatistics, request);
        }
 
        template<typename GetUsageStatisticsRequestT = Model::GetUsageStatisticsRequest>
        void GetUsageStatisticsAsync(const GetUsageStatisticsRequestT& request, const GetUsageStatisticsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GuardDutyClient::GetUsageStatistics, request, handler, context);
        }
 
        virtual Model::InviteMembersOutcome InviteMembers(const Model::InviteMembersRequest& request) const;
 
        template<typename InviteMembersRequestT = Model::InviteMembersRequest>
        Model::InviteMembersOutcomeCallable InviteMembersCallable(const InviteMembersRequestT& request) const
        {
            return SubmitCallable(&GuardDutyClient::InviteMembers, request);
        }
 
        template<typename InviteMembersRequestT = Model::InviteMembersRequest>
        void InviteMembersAsync(const InviteMembersRequestT& request, const InviteMembersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GuardDutyClient::InviteMembers, request, handler, context);
        }
 
        virtual Model::ListCoverageOutcome ListCoverage(const Model::ListCoverageRequest& request) const;
 
        template<typename ListCoverageRequestT = Model::ListCoverageRequest>
        Model::ListCoverageOutcomeCallable ListCoverageCallable(const ListCoverageRequestT& request) const
        {
            return SubmitCallable(&GuardDutyClient::ListCoverage, request);
        }
 
        template<typename ListCoverageRequestT = Model::ListCoverageRequest>
        void ListCoverageAsync(const ListCoverageRequestT& request, const ListCoverageResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GuardDutyClient::ListCoverage, request, handler, context);
        }
 
        virtual Model::ListDetectorsOutcome ListDetectors(const Model::ListDetectorsRequest& request = {}) const;
 
        template<typename ListDetectorsRequestT = Model::ListDetectorsRequest>
        Model::ListDetectorsOutcomeCallable ListDetectorsCallable(const ListDetectorsRequestT& request = {}) const
        {
            return SubmitCallable(&GuardDutyClient::ListDetectors, request);
        }
 
        template<typename ListDetectorsRequestT = Model::ListDetectorsRequest>
        void ListDetectorsAsync(const ListDetectorsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListDetectorsRequestT& request = {}) const
        {
            return SubmitAsync(&GuardDutyClient::ListDetectors, request, handler, context);
        }
 
        virtual Model::ListFiltersOutcome ListFilters(const Model::ListFiltersRequest& request) const;
 
        template<typename ListFiltersRequestT = Model::ListFiltersRequest>
        Model::ListFiltersOutcomeCallable ListFiltersCallable(const ListFiltersRequestT& request) const
        {
            return SubmitCallable(&GuardDutyClient::ListFilters, request);
        }
 
        template<typename ListFiltersRequestT = Model::ListFiltersRequest>
        void ListFiltersAsync(const ListFiltersRequestT& request, const ListFiltersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GuardDutyClient::ListFilters, 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(&GuardDutyClient::ListFindings, request);
        }
 
        template<typename ListFindingsRequestT = Model::ListFindingsRequest>
        void ListFindingsAsync(const ListFindingsRequestT& request, const ListFindingsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GuardDutyClient::ListFindings, request, handler, context);
        }
 
        virtual Model::ListIPSetsOutcome ListIPSets(const Model::ListIPSetsRequest& request) const;
 
        template<typename ListIPSetsRequestT = Model::ListIPSetsRequest>
        Model::ListIPSetsOutcomeCallable ListIPSetsCallable(const ListIPSetsRequestT& request) const
        {
            return SubmitCallable(&GuardDutyClient::ListIPSets, request);
        }
 
        template<typename ListIPSetsRequestT = Model::ListIPSetsRequest>
        void ListIPSetsAsync(const ListIPSetsRequestT& request, const ListIPSetsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GuardDutyClient::ListIPSets, 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(&GuardDutyClient::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(&GuardDutyClient::ListInvitations, request, handler, context);
        }
 
        virtual Model::ListMalwareProtectionPlansOutcome ListMalwareProtectionPlans(const Model::ListMalwareProtectionPlansRequest& request = {}) const;
 
        template<typename ListMalwareProtectionPlansRequestT = Model::ListMalwareProtectionPlansRequest>
        Model::ListMalwareProtectionPlansOutcomeCallable ListMalwareProtectionPlansCallable(const ListMalwareProtectionPlansRequestT& request = {}) const
        {
            return SubmitCallable(&GuardDutyClient::ListMalwareProtectionPlans, request);
        }
 
        template<typename ListMalwareProtectionPlansRequestT = Model::ListMalwareProtectionPlansRequest>
        void ListMalwareProtectionPlansAsync(const ListMalwareProtectionPlansResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListMalwareProtectionPlansRequestT& request = {}) const
        {
            return SubmitAsync(&GuardDutyClient::ListMalwareProtectionPlans, 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(&GuardDutyClient::ListMembers, request);
        }
 
        template<typename ListMembersRequestT = Model::ListMembersRequest>
        void ListMembersAsync(const ListMembersRequestT& request, const ListMembersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GuardDutyClient::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(&GuardDutyClient::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(&GuardDutyClient::ListOrganizationAdminAccounts, request, handler, context);
        }
 
        virtual Model::ListPublishingDestinationsOutcome ListPublishingDestinations(const Model::ListPublishingDestinationsRequest& request) const;
 
        template<typename ListPublishingDestinationsRequestT = Model::ListPublishingDestinationsRequest>
        Model::ListPublishingDestinationsOutcomeCallable ListPublishingDestinationsCallable(const ListPublishingDestinationsRequestT& request) const
        {
            return SubmitCallable(&GuardDutyClient::ListPublishingDestinations, request);
        }
 
        template<typename ListPublishingDestinationsRequestT = Model::ListPublishingDestinationsRequest>
        void ListPublishingDestinationsAsync(const ListPublishingDestinationsRequestT& request, const ListPublishingDestinationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GuardDutyClient::ListPublishingDestinations, 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(&GuardDutyClient::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(&GuardDutyClient::ListTagsForResource, request, handler, context);
        }
 
        virtual Model::ListThreatEntitySetsOutcome ListThreatEntitySets(const Model::ListThreatEntitySetsRequest& request) const;
 
        template<typename ListThreatEntitySetsRequestT = Model::ListThreatEntitySetsRequest>
        Model::ListThreatEntitySetsOutcomeCallable ListThreatEntitySetsCallable(const ListThreatEntitySetsRequestT& request) const
        {
            return SubmitCallable(&GuardDutyClient::ListThreatEntitySets, request);
        }
 
        template<typename ListThreatEntitySetsRequestT = Model::ListThreatEntitySetsRequest>
        void ListThreatEntitySetsAsync(const ListThreatEntitySetsRequestT& request, const ListThreatEntitySetsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GuardDutyClient::ListThreatEntitySets, request, handler, context);
        }
 
        virtual Model::ListThreatIntelSetsOutcome ListThreatIntelSets(const Model::ListThreatIntelSetsRequest& request) const;
 
        template<typename ListThreatIntelSetsRequestT = Model::ListThreatIntelSetsRequest>
        Model::ListThreatIntelSetsOutcomeCallable ListThreatIntelSetsCallable(const ListThreatIntelSetsRequestT& request) const
        {
            return SubmitCallable(&GuardDutyClient::ListThreatIntelSets, request);
        }
 
        template<typename ListThreatIntelSetsRequestT = Model::ListThreatIntelSetsRequest>
        void ListThreatIntelSetsAsync(const ListThreatIntelSetsRequestT& request, const ListThreatIntelSetsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GuardDutyClient::ListThreatIntelSets, request, handler, context);
        }
 
        virtual Model::ListTrustedEntitySetsOutcome ListTrustedEntitySets(const Model::ListTrustedEntitySetsRequest& request) const;
 
        template<typename ListTrustedEntitySetsRequestT = Model::ListTrustedEntitySetsRequest>
        Model::ListTrustedEntitySetsOutcomeCallable ListTrustedEntitySetsCallable(const ListTrustedEntitySetsRequestT& request) const
        {
            return SubmitCallable(&GuardDutyClient::ListTrustedEntitySets, request);
        }
 
        template<typename ListTrustedEntitySetsRequestT = Model::ListTrustedEntitySetsRequest>
        void ListTrustedEntitySetsAsync(const ListTrustedEntitySetsRequestT& request, const ListTrustedEntitySetsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GuardDutyClient::ListTrustedEntitySets, request, handler, context);
        }
 
        virtual Model::StartMalwareScanOutcome StartMalwareScan(const Model::StartMalwareScanRequest& request) const;
 
        template<typename StartMalwareScanRequestT = Model::StartMalwareScanRequest>
        Model::StartMalwareScanOutcomeCallable StartMalwareScanCallable(const StartMalwareScanRequestT& request) const
        {
            return SubmitCallable(&GuardDutyClient::StartMalwareScan, request);
        }
 
        template<typename StartMalwareScanRequestT = Model::StartMalwareScanRequest>
        void StartMalwareScanAsync(const StartMalwareScanRequestT& request, const StartMalwareScanResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GuardDutyClient::StartMalwareScan, request, handler, context);
        }
 
        virtual Model::StartMonitoringMembersOutcome StartMonitoringMembers(const Model::StartMonitoringMembersRequest& request) const;
 
        template<typename StartMonitoringMembersRequestT = Model::StartMonitoringMembersRequest>
        Model::StartMonitoringMembersOutcomeCallable StartMonitoringMembersCallable(const StartMonitoringMembersRequestT& request) const
        {
            return SubmitCallable(&GuardDutyClient::StartMonitoringMembers, request);
        }
 
        template<typename StartMonitoringMembersRequestT = Model::StartMonitoringMembersRequest>
        void StartMonitoringMembersAsync(const StartMonitoringMembersRequestT& request, const StartMonitoringMembersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GuardDutyClient::StartMonitoringMembers, request, handler, context);
        }
 
        virtual Model::StopMonitoringMembersOutcome StopMonitoringMembers(const Model::StopMonitoringMembersRequest& request) const;
 
        template<typename StopMonitoringMembersRequestT = Model::StopMonitoringMembersRequest>
        Model::StopMonitoringMembersOutcomeCallable StopMonitoringMembersCallable(const StopMonitoringMembersRequestT& request) const
        {
            return SubmitCallable(&GuardDutyClient::StopMonitoringMembers, request);
        }
 
        template<typename StopMonitoringMembersRequestT = Model::StopMonitoringMembersRequest>
        void StopMonitoringMembersAsync(const StopMonitoringMembersRequestT& request, const StopMonitoringMembersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GuardDutyClient::StopMonitoringMembers, 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(&GuardDutyClient::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(&GuardDutyClient::TagResource, request, handler, context);
        }
 
        virtual Model::UnarchiveFindingsOutcome UnarchiveFindings(const Model::UnarchiveFindingsRequest& request) const;
 
        template<typename UnarchiveFindingsRequestT = Model::UnarchiveFindingsRequest>
        Model::UnarchiveFindingsOutcomeCallable UnarchiveFindingsCallable(const UnarchiveFindingsRequestT& request) const
        {
            return SubmitCallable(&GuardDutyClient::UnarchiveFindings, request);
        }
 
        template<typename UnarchiveFindingsRequestT = Model::UnarchiveFindingsRequest>
        void UnarchiveFindingsAsync(const UnarchiveFindingsRequestT& request, const UnarchiveFindingsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GuardDutyClient::UnarchiveFindings, 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(&GuardDutyClient::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(&GuardDutyClient::UntagResource, request, handler, context);
        }
 
        virtual Model::UpdateDetectorOutcome UpdateDetector(const Model::UpdateDetectorRequest& request) const;
 
        template<typename UpdateDetectorRequestT = Model::UpdateDetectorRequest>
        Model::UpdateDetectorOutcomeCallable UpdateDetectorCallable(const UpdateDetectorRequestT& request) const
        {
            return SubmitCallable(&GuardDutyClient::UpdateDetector, request);
        }
 
        template<typename UpdateDetectorRequestT = Model::UpdateDetectorRequest>
        void UpdateDetectorAsync(const UpdateDetectorRequestT& request, const UpdateDetectorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GuardDutyClient::UpdateDetector, request, handler, context);
        }
 
        virtual Model::UpdateFilterOutcome UpdateFilter(const Model::UpdateFilterRequest& request) const;
 
        template<typename UpdateFilterRequestT = Model::UpdateFilterRequest>
        Model::UpdateFilterOutcomeCallable UpdateFilterCallable(const UpdateFilterRequestT& request) const
        {
            return SubmitCallable(&GuardDutyClient::UpdateFilter, request);
        }
 
        template<typename UpdateFilterRequestT = Model::UpdateFilterRequest>
        void UpdateFilterAsync(const UpdateFilterRequestT& request, const UpdateFilterResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GuardDutyClient::UpdateFilter, request, handler, context);
        }
 
        virtual Model::UpdateFindingsFeedbackOutcome UpdateFindingsFeedback(const Model::UpdateFindingsFeedbackRequest& request) const;
 
        template<typename UpdateFindingsFeedbackRequestT = Model::UpdateFindingsFeedbackRequest>
        Model::UpdateFindingsFeedbackOutcomeCallable UpdateFindingsFeedbackCallable(const UpdateFindingsFeedbackRequestT& request) const
        {
            return SubmitCallable(&GuardDutyClient::UpdateFindingsFeedback, request);
        }
 
        template<typename UpdateFindingsFeedbackRequestT = Model::UpdateFindingsFeedbackRequest>
        void UpdateFindingsFeedbackAsync(const UpdateFindingsFeedbackRequestT& request, const UpdateFindingsFeedbackResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GuardDutyClient::UpdateFindingsFeedback, request, handler, context);
        }
 
        virtual Model::UpdateIPSetOutcome UpdateIPSet(const Model::UpdateIPSetRequest& request) const;
 
        template<typename UpdateIPSetRequestT = Model::UpdateIPSetRequest>
        Model::UpdateIPSetOutcomeCallable UpdateIPSetCallable(const UpdateIPSetRequestT& request) const
        {
            return SubmitCallable(&GuardDutyClient::UpdateIPSet, request);
        }
 
        template<typename UpdateIPSetRequestT = Model::UpdateIPSetRequest>
        void UpdateIPSetAsync(const UpdateIPSetRequestT& request, const UpdateIPSetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GuardDutyClient::UpdateIPSet, request, handler, context);
        }
 
        virtual Model::UpdateMalwareProtectionPlanOutcome UpdateMalwareProtectionPlan(const Model::UpdateMalwareProtectionPlanRequest& request) const;
 
        template<typename UpdateMalwareProtectionPlanRequestT = Model::UpdateMalwareProtectionPlanRequest>
        Model::UpdateMalwareProtectionPlanOutcomeCallable UpdateMalwareProtectionPlanCallable(const UpdateMalwareProtectionPlanRequestT& request) const
        {
            return SubmitCallable(&GuardDutyClient::UpdateMalwareProtectionPlan, request);
        }
 
        template<typename UpdateMalwareProtectionPlanRequestT = Model::UpdateMalwareProtectionPlanRequest>
        void UpdateMalwareProtectionPlanAsync(const UpdateMalwareProtectionPlanRequestT& request, const UpdateMalwareProtectionPlanResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GuardDutyClient::UpdateMalwareProtectionPlan, request, handler, context);
        }
 
        virtual Model::UpdateMalwareScanSettingsOutcome UpdateMalwareScanSettings(const Model::UpdateMalwareScanSettingsRequest& request) const;
 
        template<typename UpdateMalwareScanSettingsRequestT = Model::UpdateMalwareScanSettingsRequest>
        Model::UpdateMalwareScanSettingsOutcomeCallable UpdateMalwareScanSettingsCallable(const UpdateMalwareScanSettingsRequestT& request) const
        {
            return SubmitCallable(&GuardDutyClient::UpdateMalwareScanSettings, request);
        }
 
        template<typename UpdateMalwareScanSettingsRequestT = Model::UpdateMalwareScanSettingsRequest>
        void UpdateMalwareScanSettingsAsync(const UpdateMalwareScanSettingsRequestT& request, const UpdateMalwareScanSettingsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GuardDutyClient::UpdateMalwareScanSettings, request, handler, context);
        }
 
        virtual Model::UpdateMemberDetectorsOutcome UpdateMemberDetectors(const Model::UpdateMemberDetectorsRequest& request) const;
 
        template<typename UpdateMemberDetectorsRequestT = Model::UpdateMemberDetectorsRequest>
        Model::UpdateMemberDetectorsOutcomeCallable UpdateMemberDetectorsCallable(const UpdateMemberDetectorsRequestT& request) const
        {
            return SubmitCallable(&GuardDutyClient::UpdateMemberDetectors, request);
        }
 
        template<typename UpdateMemberDetectorsRequestT = Model::UpdateMemberDetectorsRequest>
        void UpdateMemberDetectorsAsync(const UpdateMemberDetectorsRequestT& request, const UpdateMemberDetectorsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GuardDutyClient::UpdateMemberDetectors, 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(&GuardDutyClient::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(&GuardDutyClient::UpdateOrganizationConfiguration, request, handler, context);
        }
 
        virtual Model::UpdatePublishingDestinationOutcome UpdatePublishingDestination(const Model::UpdatePublishingDestinationRequest& request) const;
 
        template<typename UpdatePublishingDestinationRequestT = Model::UpdatePublishingDestinationRequest>
        Model::UpdatePublishingDestinationOutcomeCallable UpdatePublishingDestinationCallable(const UpdatePublishingDestinationRequestT& request) const
        {
            return SubmitCallable(&GuardDutyClient::UpdatePublishingDestination, request);
        }
 
        template<typename UpdatePublishingDestinationRequestT = Model::UpdatePublishingDestinationRequest>
        void UpdatePublishingDestinationAsync(const UpdatePublishingDestinationRequestT& request, const UpdatePublishingDestinationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GuardDutyClient::UpdatePublishingDestination, request, handler, context);
        }
 
        virtual Model::UpdateThreatEntitySetOutcome UpdateThreatEntitySet(const Model::UpdateThreatEntitySetRequest& request) const;
 
        template<typename UpdateThreatEntitySetRequestT = Model::UpdateThreatEntitySetRequest>
        Model::UpdateThreatEntitySetOutcomeCallable UpdateThreatEntitySetCallable(const UpdateThreatEntitySetRequestT& request) const
        {
            return SubmitCallable(&GuardDutyClient::UpdateThreatEntitySet, request);
        }
 
        template<typename UpdateThreatEntitySetRequestT = Model::UpdateThreatEntitySetRequest>
        void UpdateThreatEntitySetAsync(const UpdateThreatEntitySetRequestT& request, const UpdateThreatEntitySetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GuardDutyClient::UpdateThreatEntitySet, request, handler, context);
        }
 
        virtual Model::UpdateThreatIntelSetOutcome UpdateThreatIntelSet(const Model::UpdateThreatIntelSetRequest& request) const;
 
        template<typename UpdateThreatIntelSetRequestT = Model::UpdateThreatIntelSetRequest>
        Model::UpdateThreatIntelSetOutcomeCallable UpdateThreatIntelSetCallable(const UpdateThreatIntelSetRequestT& request) const
        {
            return SubmitCallable(&GuardDutyClient::UpdateThreatIntelSet, request);
        }
 
        template<typename UpdateThreatIntelSetRequestT = Model::UpdateThreatIntelSetRequest>
        void UpdateThreatIntelSetAsync(const UpdateThreatIntelSetRequestT& request, const UpdateThreatIntelSetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GuardDutyClient::UpdateThreatIntelSet, request, handler, context);
        }
 
        virtual Model::UpdateTrustedEntitySetOutcome UpdateTrustedEntitySet(const Model::UpdateTrustedEntitySetRequest& request) const;
 
        template<typename UpdateTrustedEntitySetRequestT = Model::UpdateTrustedEntitySetRequest>
        Model::UpdateTrustedEntitySetOutcomeCallable UpdateTrustedEntitySetCallable(const UpdateTrustedEntitySetRequestT& request) const
        {
            return SubmitCallable(&GuardDutyClient::UpdateTrustedEntitySet, request);
        }
 
        template<typename UpdateTrustedEntitySetRequestT = Model::UpdateTrustedEntitySetRequest>
        void UpdateTrustedEntitySetAsync(const UpdateTrustedEntitySetRequestT& request, const UpdateTrustedEntitySetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GuardDutyClient::UpdateTrustedEntitySet, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<GuardDutyEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<GuardDutyClient>;
      void init(const GuardDutyClientConfiguration& clientConfiguration);
 
      GuardDutyClientConfiguration m_clientConfiguration;
      std::shared_ptr<GuardDutyEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace GuardDuty
} // namespace Aws