GuardDutyClient.h

 
#pragma once
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/guardduty/GuardDutyPaginationBase.h>
#include <aws/guardduty/GuardDutyServiceClientModel.h>
#include <aws/guardduty/GuardDutyWaiter.h>
#include <aws/guardduty/GuardDuty_EXPORTS.h>
 
namespace Aws {
namespace GuardDuty {
class AWS_GUARDDUTY_API GuardDutyClient : public Aws::Client::AWSJsonClient,
                                          public Aws::Client::ClientWithAsyncTemplateMethods<GuardDutyClient>,
                                          public GuardDutyPaginationBase<GuardDutyClient>,
                                          public GuardDutyWaiter<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::CreateCustomDetectionRuleAssociationOutcome CreateCustomDetectionRuleAssociation(
      const Model::CreateCustomDetectionRuleAssociationRequest& request) const;
 
  template <typename CreateCustomDetectionRuleAssociationRequestT = Model::CreateCustomDetectionRuleAssociationRequest>
  Model::CreateCustomDetectionRuleAssociationOutcomeCallable CreateCustomDetectionRuleAssociationCallable(
      const CreateCustomDetectionRuleAssociationRequestT& request) const {
    return SubmitCallable(&GuardDutyClient::CreateCustomDetectionRuleAssociation, request);
  }
 
  template <typename CreateCustomDetectionRuleAssociationRequestT = Model::CreateCustomDetectionRuleAssociationRequest>
  void CreateCustomDetectionRuleAssociationAsync(const CreateCustomDetectionRuleAssociationRequestT& request,
                                                 const CreateCustomDetectionRuleAssociationResponseReceivedHandler& handler,
                                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GuardDutyClient::CreateCustomDetectionRuleAssociation, request, handler, context);
  }
 
  virtual Model::CreateCustomDetectionRuleOrgConfigurationOutcome CreateCustomDetectionRuleOrgConfiguration(
      const Model::CreateCustomDetectionRuleOrgConfigurationRequest& request) const;
 
  template <typename CreateCustomDetectionRuleOrgConfigurationRequestT = Model::CreateCustomDetectionRuleOrgConfigurationRequest>
  Model::CreateCustomDetectionRuleOrgConfigurationOutcomeCallable CreateCustomDetectionRuleOrgConfigurationCallable(
      const CreateCustomDetectionRuleOrgConfigurationRequestT& request) const {
    return SubmitCallable(&GuardDutyClient::CreateCustomDetectionRuleOrgConfiguration, request);
  }
 
  template <typename CreateCustomDetectionRuleOrgConfigurationRequestT = Model::CreateCustomDetectionRuleOrgConfigurationRequest>
  void CreateCustomDetectionRuleOrgConfigurationAsync(
      const CreateCustomDetectionRuleOrgConfigurationRequestT& request,
      const CreateCustomDetectionRuleOrgConfigurationResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GuardDutyClient::CreateCustomDetectionRuleOrgConfiguration, 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::CreateInvestigationOutcome CreateInvestigation(const Model::CreateInvestigationRequest& request) const;
 
  template <typename CreateInvestigationRequestT = Model::CreateInvestigationRequest>
  Model::CreateInvestigationOutcomeCallable CreateInvestigationCallable(const CreateInvestigationRequestT& request) const {
    return SubmitCallable(&GuardDutyClient::CreateInvestigation, request);
  }
 
  template <typename CreateInvestigationRequestT = Model::CreateInvestigationRequest>
  void CreateInvestigationAsync(const CreateInvestigationRequestT& request, const CreateInvestigationResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GuardDutyClient::CreateInvestigation, 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::DeleteCustomDetectionRuleAssociationOutcome DeleteCustomDetectionRuleAssociation(
      const Model::DeleteCustomDetectionRuleAssociationRequest& request) const;
 
  template <typename DeleteCustomDetectionRuleAssociationRequestT = Model::DeleteCustomDetectionRuleAssociationRequest>
  Model::DeleteCustomDetectionRuleAssociationOutcomeCallable DeleteCustomDetectionRuleAssociationCallable(
      const DeleteCustomDetectionRuleAssociationRequestT& request) const {
    return SubmitCallable(&GuardDutyClient::DeleteCustomDetectionRuleAssociation, request);
  }
 
  template <typename DeleteCustomDetectionRuleAssociationRequestT = Model::DeleteCustomDetectionRuleAssociationRequest>
  void DeleteCustomDetectionRuleAssociationAsync(const DeleteCustomDetectionRuleAssociationRequestT& request,
                                                 const DeleteCustomDetectionRuleAssociationResponseReceivedHandler& handler,
                                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GuardDutyClient::DeleteCustomDetectionRuleAssociation, request, handler, context);
  }
 
  virtual Model::DeleteCustomDetectionRuleOrgConfigurationOutcome DeleteCustomDetectionRuleOrgConfiguration(
      const Model::DeleteCustomDetectionRuleOrgConfigurationRequest& request) const;
 
  template <typename DeleteCustomDetectionRuleOrgConfigurationRequestT = Model::DeleteCustomDetectionRuleOrgConfigurationRequest>
  Model::DeleteCustomDetectionRuleOrgConfigurationOutcomeCallable DeleteCustomDetectionRuleOrgConfigurationCallable(
      const DeleteCustomDetectionRuleOrgConfigurationRequestT& request) const {
    return SubmitCallable(&GuardDutyClient::DeleteCustomDetectionRuleOrgConfiguration, request);
  }
 
  template <typename DeleteCustomDetectionRuleOrgConfigurationRequestT = Model::DeleteCustomDetectionRuleOrgConfigurationRequest>
  void DeleteCustomDetectionRuleOrgConfigurationAsync(
      const DeleteCustomDetectionRuleOrgConfigurationRequestT& request,
      const DeleteCustomDetectionRuleOrgConfigurationResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GuardDutyClient::DeleteCustomDetectionRuleOrgConfiguration, 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::GetCustomDetectionRuleOutcome GetCustomDetectionRule(const Model::GetCustomDetectionRuleRequest& request) const;
 
  template <typename GetCustomDetectionRuleRequestT = Model::GetCustomDetectionRuleRequest>
  Model::GetCustomDetectionRuleOutcomeCallable GetCustomDetectionRuleCallable(const GetCustomDetectionRuleRequestT& request) const {
    return SubmitCallable(&GuardDutyClient::GetCustomDetectionRule, request);
  }
 
  template <typename GetCustomDetectionRuleRequestT = Model::GetCustomDetectionRuleRequest>
  void GetCustomDetectionRuleAsync(const GetCustomDetectionRuleRequestT& request,
                                   const GetCustomDetectionRuleResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GuardDutyClient::GetCustomDetectionRule, request, handler, context);
  }
 
  virtual Model::GetCustomDetectionRuleAssociationOutcome GetCustomDetectionRuleAssociation(
      const Model::GetCustomDetectionRuleAssociationRequest& request) const;
 
  template <typename GetCustomDetectionRuleAssociationRequestT = Model::GetCustomDetectionRuleAssociationRequest>
  Model::GetCustomDetectionRuleAssociationOutcomeCallable GetCustomDetectionRuleAssociationCallable(
      const GetCustomDetectionRuleAssociationRequestT& request) const {
    return SubmitCallable(&GuardDutyClient::GetCustomDetectionRuleAssociation, request);
  }
 
  template <typename GetCustomDetectionRuleAssociationRequestT = Model::GetCustomDetectionRuleAssociationRequest>
  void GetCustomDetectionRuleAssociationAsync(const GetCustomDetectionRuleAssociationRequestT& request,
                                              const GetCustomDetectionRuleAssociationResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GuardDutyClient::GetCustomDetectionRuleAssociation, request, handler, context);
  }
 
  virtual Model::GetCustomDetectionRuleOrgConfigurationOutcome GetCustomDetectionRuleOrgConfiguration(
      const Model::GetCustomDetectionRuleOrgConfigurationRequest& request) const;
 
  template <typename GetCustomDetectionRuleOrgConfigurationRequestT = Model::GetCustomDetectionRuleOrgConfigurationRequest>
  Model::GetCustomDetectionRuleOrgConfigurationOutcomeCallable GetCustomDetectionRuleOrgConfigurationCallable(
      const GetCustomDetectionRuleOrgConfigurationRequestT& request) const {
    return SubmitCallable(&GuardDutyClient::GetCustomDetectionRuleOrgConfiguration, request);
  }
 
  template <typename GetCustomDetectionRuleOrgConfigurationRequestT = Model::GetCustomDetectionRuleOrgConfigurationRequest>
  void GetCustomDetectionRuleOrgConfigurationAsync(const GetCustomDetectionRuleOrgConfigurationRequestT& request,
                                                   const GetCustomDetectionRuleOrgConfigurationResponseReceivedHandler& handler,
                                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GuardDutyClient::GetCustomDetectionRuleOrgConfiguration, 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::GetInvestigationOutcome GetInvestigation(const Model::GetInvestigationRequest& request) const;
 
  template <typename GetInvestigationRequestT = Model::GetInvestigationRequest>
  Model::GetInvestigationOutcomeCallable GetInvestigationCallable(const GetInvestigationRequestT& request) const {
    return SubmitCallable(&GuardDutyClient::GetInvestigation, request);
  }
 
  template <typename GetInvestigationRequestT = Model::GetInvestigationRequest>
  void GetInvestigationAsync(const GetInvestigationRequestT& request, const GetInvestigationResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GuardDutyClient::GetInvestigation, 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::GetMalwareScanOutcome GetMalwareScan(const Model::GetMalwareScanRequest& request) const;
 
  template <typename GetMalwareScanRequestT = Model::GetMalwareScanRequest>
  Model::GetMalwareScanOutcomeCallable GetMalwareScanCallable(const GetMalwareScanRequestT& request) const {
    return SubmitCallable(&GuardDutyClient::GetMalwareScan, request);
  }
 
  template <typename GetMalwareScanRequestT = Model::GetMalwareScanRequest>
  void GetMalwareScanAsync(const GetMalwareScanRequestT& request, const GetMalwareScanResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GuardDutyClient::GetMalwareScan, 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::ListCustomDetectionRuleAssociationsOutcome ListCustomDetectionRuleAssociations(
      const Model::ListCustomDetectionRuleAssociationsRequest& request = {}) const;
 
  template <typename ListCustomDetectionRuleAssociationsRequestT = Model::ListCustomDetectionRuleAssociationsRequest>
  Model::ListCustomDetectionRuleAssociationsOutcomeCallable ListCustomDetectionRuleAssociationsCallable(
      const ListCustomDetectionRuleAssociationsRequestT& request = {}) const {
    return SubmitCallable(&GuardDutyClient::ListCustomDetectionRuleAssociations, request);
  }
 
  template <typename ListCustomDetectionRuleAssociationsRequestT = Model::ListCustomDetectionRuleAssociationsRequest>
  void ListCustomDetectionRuleAssociationsAsync(const ListCustomDetectionRuleAssociationsResponseReceivedHandler& handler,
                                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                                const ListCustomDetectionRuleAssociationsRequestT& request = {}) const {
    return SubmitAsync(&GuardDutyClient::ListCustomDetectionRuleAssociations, request, handler, context);
  }
 
  virtual Model::ListCustomDetectionRuleOrgConfigurationsOutcome ListCustomDetectionRuleOrgConfigurations(
      const Model::ListCustomDetectionRuleOrgConfigurationsRequest& request = {}) const;
 
  template <typename ListCustomDetectionRuleOrgConfigurationsRequestT = Model::ListCustomDetectionRuleOrgConfigurationsRequest>
  Model::ListCustomDetectionRuleOrgConfigurationsOutcomeCallable ListCustomDetectionRuleOrgConfigurationsCallable(
      const ListCustomDetectionRuleOrgConfigurationsRequestT& request = {}) const {
    return SubmitCallable(&GuardDutyClient::ListCustomDetectionRuleOrgConfigurations, request);
  }
 
  template <typename ListCustomDetectionRuleOrgConfigurationsRequestT = Model::ListCustomDetectionRuleOrgConfigurationsRequest>
  void ListCustomDetectionRuleOrgConfigurationsAsync(const ListCustomDetectionRuleOrgConfigurationsResponseReceivedHandler& handler,
                                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                                     const ListCustomDetectionRuleOrgConfigurationsRequestT& request = {}) const {
    return SubmitAsync(&GuardDutyClient::ListCustomDetectionRuleOrgConfigurations, request, handler, context);
  }
 
  virtual Model::ListCustomDetectionRulesOutcome ListCustomDetectionRules(const Model::ListCustomDetectionRulesRequest& request = {}) const;
 
  template <typename ListCustomDetectionRulesRequestT = Model::ListCustomDetectionRulesRequest>
  Model::ListCustomDetectionRulesOutcomeCallable ListCustomDetectionRulesCallable(
      const ListCustomDetectionRulesRequestT& request = {}) const {
    return SubmitCallable(&GuardDutyClient::ListCustomDetectionRules, request);
  }
 
  template <typename ListCustomDetectionRulesRequestT = Model::ListCustomDetectionRulesRequest>
  void ListCustomDetectionRulesAsync(const ListCustomDetectionRulesResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                     const ListCustomDetectionRulesRequestT& request = {}) const {
    return SubmitAsync(&GuardDutyClient::ListCustomDetectionRules, 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::ListInvestigationsOutcome ListInvestigations(const Model::ListInvestigationsRequest& request) const;
 
  template <typename ListInvestigationsRequestT = Model::ListInvestigationsRequest>
  Model::ListInvestigationsOutcomeCallable ListInvestigationsCallable(const ListInvestigationsRequestT& request) const {
    return SubmitCallable(&GuardDutyClient::ListInvestigations, request);
  }
 
  template <typename ListInvestigationsRequestT = Model::ListInvestigationsRequest>
  void ListInvestigationsAsync(const ListInvestigationsRequestT& request, const ListInvestigationsResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GuardDutyClient::ListInvestigations, 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::ListMalwareScansOutcome ListMalwareScans(const Model::ListMalwareScansRequest& request = {}) const;
 
  template <typename ListMalwareScansRequestT = Model::ListMalwareScansRequest>
  Model::ListMalwareScansOutcomeCallable ListMalwareScansCallable(const ListMalwareScansRequestT& request = {}) const {
    return SubmitCallable(&GuardDutyClient::ListMalwareScans, request);
  }
 
  template <typename ListMalwareScansRequestT = Model::ListMalwareScansRequest>
  void ListMalwareScansAsync(const ListMalwareScansResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                             const ListMalwareScansRequestT& request = {}) const {
    return SubmitAsync(&GuardDutyClient::ListMalwareScans, 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::SendObjectMalwareScanOutcome SendObjectMalwareScan(const Model::SendObjectMalwareScanRequest& request = {}) const;
 
  template <typename SendObjectMalwareScanRequestT = Model::SendObjectMalwareScanRequest>
  Model::SendObjectMalwareScanOutcomeCallable SendObjectMalwareScanCallable(const SendObjectMalwareScanRequestT& request = {}) const {
    return SubmitCallable(&GuardDutyClient::SendObjectMalwareScan, request);
  }
 
  template <typename SendObjectMalwareScanRequestT = Model::SendObjectMalwareScanRequest>
  void SendObjectMalwareScanAsync(const SendObjectMalwareScanResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                  const SendObjectMalwareScanRequestT& request = {}) const {
    return SubmitAsync(&GuardDutyClient::SendObjectMalwareScan, 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::UpdateCustomDetectionRuleAssociationOutcome UpdateCustomDetectionRuleAssociation(
      const Model::UpdateCustomDetectionRuleAssociationRequest& request) const;
 
  template <typename UpdateCustomDetectionRuleAssociationRequestT = Model::UpdateCustomDetectionRuleAssociationRequest>
  Model::UpdateCustomDetectionRuleAssociationOutcomeCallable UpdateCustomDetectionRuleAssociationCallable(
      const UpdateCustomDetectionRuleAssociationRequestT& request) const {
    return SubmitCallable(&GuardDutyClient::UpdateCustomDetectionRuleAssociation, request);
  }
 
  template <typename UpdateCustomDetectionRuleAssociationRequestT = Model::UpdateCustomDetectionRuleAssociationRequest>
  void UpdateCustomDetectionRuleAssociationAsync(const UpdateCustomDetectionRuleAssociationRequestT& request,
                                                 const UpdateCustomDetectionRuleAssociationResponseReceivedHandler& handler,
                                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GuardDutyClient::UpdateCustomDetectionRuleAssociation, request, handler, context);
  }
 
  virtual Model::UpdateCustomDetectionRuleOrgConfigurationOutcome UpdateCustomDetectionRuleOrgConfiguration(
      const Model::UpdateCustomDetectionRuleOrgConfigurationRequest& request) const;
 
  template <typename UpdateCustomDetectionRuleOrgConfigurationRequestT = Model::UpdateCustomDetectionRuleOrgConfigurationRequest>
  Model::UpdateCustomDetectionRuleOrgConfigurationOutcomeCallable UpdateCustomDetectionRuleOrgConfigurationCallable(
      const UpdateCustomDetectionRuleOrgConfigurationRequestT& request) const {
    return SubmitCallable(&GuardDutyClient::UpdateCustomDetectionRuleOrgConfiguration, request);
  }
 
  template <typename UpdateCustomDetectionRuleOrgConfigurationRequestT = Model::UpdateCustomDetectionRuleOrgConfigurationRequest>
  void UpdateCustomDetectionRuleOrgConfigurationAsync(
      const UpdateCustomDetectionRuleOrgConfigurationRequestT& request,
      const UpdateCustomDetectionRuleOrgConfigurationResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GuardDutyClient::UpdateCustomDetectionRuleOrgConfiguration, 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);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<GuardDutyEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<GuardDutyClient>;
  void init(const GuardDutyClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, GuardDutyError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request,
                                                const std::function<void(Aws::Endpoint::ResolveEndpointOutcome&)>& resolveUri,
                                                Aws::Http::HttpMethod httpMethod) const;
 
  GuardDutyClientConfiguration m_clientConfiguration;
  std::shared_ptr<GuardDutyEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace GuardDuty
}  // namespace Aws