SecurityHubClient.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/securityhub/SecurityHubPaginationBase.h>
#include <aws/securityhub/SecurityHubServiceClientModel.h>
#include <aws/securityhub/SecurityHubWaiter.h>
#include <aws/securityhub/SecurityHub_EXPORTS.h>
 
namespace Aws {
namespace SecurityHub {
class AWS_SECURITYHUB_API SecurityHubClient : public Aws::Client::AWSJsonClient,
                                              public Aws::Client::ClientWithAsyncTemplateMethods<SecurityHubClient>,
                                              public SecurityHubPaginationBase<SecurityHubClient>,
                                              public SecurityHubWaiter<SecurityHubClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef SecurityHubClientConfiguration ClientConfigurationType;
  typedef SecurityHubEndpointProvider EndpointProviderType;
 
  SecurityHubClient(
      const Aws::SecurityHub::SecurityHubClientConfiguration& clientConfiguration = Aws::SecurityHub::SecurityHubClientConfiguration(),
      std::shared_ptr<SecurityHubEndpointProviderBase> endpointProvider = nullptr);
 
  SecurityHubClient(
      const Aws::Auth::AWSCredentials& credentials, std::shared_ptr<SecurityHubEndpointProviderBase> endpointProvider = nullptr,
      const Aws::SecurityHub::SecurityHubClientConfiguration& clientConfiguration = Aws::SecurityHub::SecurityHubClientConfiguration());
 
  SecurityHubClient(
      const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
      std::shared_ptr<SecurityHubEndpointProviderBase> endpointProvider = nullptr,
      const Aws::SecurityHub::SecurityHubClientConfiguration& clientConfiguration = Aws::SecurityHub::SecurityHubClientConfiguration());
 
  /* Legacy constructors due deprecation */
  SecurityHubClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  SecurityHubClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  SecurityHubClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                    const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~SecurityHubClient();
 
  virtual Model::AcceptAdministratorInvitationOutcome AcceptAdministratorInvitation(
      const Model::AcceptAdministratorInvitationRequest& request) const;
 
  template <typename AcceptAdministratorInvitationRequestT = Model::AcceptAdministratorInvitationRequest>
  Model::AcceptAdministratorInvitationOutcomeCallable AcceptAdministratorInvitationCallable(
      const AcceptAdministratorInvitationRequestT& request) const {
    return SubmitCallable(&SecurityHubClient::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(&SecurityHubClient::AcceptAdministratorInvitation, request, handler, context);
  }
 
  virtual Model::BatchDeleteAutomationRulesOutcome BatchDeleteAutomationRules(
      const Model::BatchDeleteAutomationRulesRequest& request) const;
 
  template <typename BatchDeleteAutomationRulesRequestT = Model::BatchDeleteAutomationRulesRequest>
  Model::BatchDeleteAutomationRulesOutcomeCallable BatchDeleteAutomationRulesCallable(
      const BatchDeleteAutomationRulesRequestT& request) const {
    return SubmitCallable(&SecurityHubClient::BatchDeleteAutomationRules, request);
  }
 
  template <typename BatchDeleteAutomationRulesRequestT = Model::BatchDeleteAutomationRulesRequest>
  void BatchDeleteAutomationRulesAsync(const BatchDeleteAutomationRulesRequestT& request,
                                       const BatchDeleteAutomationRulesResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityHubClient::BatchDeleteAutomationRules, request, handler, context);
  }
 
  virtual Model::BatchDisableStandardsOutcome BatchDisableStandards(const Model::BatchDisableStandardsRequest& request) const;
 
  template <typename BatchDisableStandardsRequestT = Model::BatchDisableStandardsRequest>
  Model::BatchDisableStandardsOutcomeCallable BatchDisableStandardsCallable(const BatchDisableStandardsRequestT& request) const {
    return SubmitCallable(&SecurityHubClient::BatchDisableStandards, request);
  }
 
  template <typename BatchDisableStandardsRequestT = Model::BatchDisableStandardsRequest>
  void BatchDisableStandardsAsync(const BatchDisableStandardsRequestT& request, const BatchDisableStandardsResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityHubClient::BatchDisableStandards, request, handler, context);
  }
 
  virtual Model::BatchEnableStandardsOutcome BatchEnableStandards(const Model::BatchEnableStandardsRequest& request) const;
 
  template <typename BatchEnableStandardsRequestT = Model::BatchEnableStandardsRequest>
  Model::BatchEnableStandardsOutcomeCallable BatchEnableStandardsCallable(const BatchEnableStandardsRequestT& request) const {
    return SubmitCallable(&SecurityHubClient::BatchEnableStandards, request);
  }
 
  template <typename BatchEnableStandardsRequestT = Model::BatchEnableStandardsRequest>
  void BatchEnableStandardsAsync(const BatchEnableStandardsRequestT& request, const BatchEnableStandardsResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityHubClient::BatchEnableStandards, request, handler, context);
  }
 
  virtual Model::BatchGetAutomationRulesOutcome BatchGetAutomationRules(const Model::BatchGetAutomationRulesRequest& request) const;
 
  template <typename BatchGetAutomationRulesRequestT = Model::BatchGetAutomationRulesRequest>
  Model::BatchGetAutomationRulesOutcomeCallable BatchGetAutomationRulesCallable(const BatchGetAutomationRulesRequestT& request) const {
    return SubmitCallable(&SecurityHubClient::BatchGetAutomationRules, request);
  }
 
  template <typename BatchGetAutomationRulesRequestT = Model::BatchGetAutomationRulesRequest>
  void BatchGetAutomationRulesAsync(const BatchGetAutomationRulesRequestT& request,
                                    const BatchGetAutomationRulesResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityHubClient::BatchGetAutomationRules, request, handler, context);
  }
 
  virtual Model::BatchGetConfigurationPolicyAssociationsOutcome BatchGetConfigurationPolicyAssociations(
      const Model::BatchGetConfigurationPolicyAssociationsRequest& request) const;
 
  template <typename BatchGetConfigurationPolicyAssociationsRequestT = Model::BatchGetConfigurationPolicyAssociationsRequest>
  Model::BatchGetConfigurationPolicyAssociationsOutcomeCallable BatchGetConfigurationPolicyAssociationsCallable(
      const BatchGetConfigurationPolicyAssociationsRequestT& request) const {
    return SubmitCallable(&SecurityHubClient::BatchGetConfigurationPolicyAssociations, request);
  }
 
  template <typename BatchGetConfigurationPolicyAssociationsRequestT = Model::BatchGetConfigurationPolicyAssociationsRequest>
  void BatchGetConfigurationPolicyAssociationsAsync(const BatchGetConfigurationPolicyAssociationsRequestT& request,
                                                    const BatchGetConfigurationPolicyAssociationsResponseReceivedHandler& handler,
                                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityHubClient::BatchGetConfigurationPolicyAssociations, request, handler, context);
  }
 
  virtual Model::BatchGetSecurityControlsOutcome BatchGetSecurityControls(const Model::BatchGetSecurityControlsRequest& request) const;
 
  template <typename BatchGetSecurityControlsRequestT = Model::BatchGetSecurityControlsRequest>
  Model::BatchGetSecurityControlsOutcomeCallable BatchGetSecurityControlsCallable(const BatchGetSecurityControlsRequestT& request) const {
    return SubmitCallable(&SecurityHubClient::BatchGetSecurityControls, request);
  }
 
  template <typename BatchGetSecurityControlsRequestT = Model::BatchGetSecurityControlsRequest>
  void BatchGetSecurityControlsAsync(const BatchGetSecurityControlsRequestT& request,
                                     const BatchGetSecurityControlsResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityHubClient::BatchGetSecurityControls, request, handler, context);
  }
 
  virtual Model::BatchGetStandardsControlAssociationsOutcome BatchGetStandardsControlAssociations(
      const Model::BatchGetStandardsControlAssociationsRequest& request) const;
 
  template <typename BatchGetStandardsControlAssociationsRequestT = Model::BatchGetStandardsControlAssociationsRequest>
  Model::BatchGetStandardsControlAssociationsOutcomeCallable BatchGetStandardsControlAssociationsCallable(
      const BatchGetStandardsControlAssociationsRequestT& request) const {
    return SubmitCallable(&SecurityHubClient::BatchGetStandardsControlAssociations, request);
  }
 
  template <typename BatchGetStandardsControlAssociationsRequestT = Model::BatchGetStandardsControlAssociationsRequest>
  void BatchGetStandardsControlAssociationsAsync(const BatchGetStandardsControlAssociationsRequestT& request,
                                                 const BatchGetStandardsControlAssociationsResponseReceivedHandler& handler,
                                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityHubClient::BatchGetStandardsControlAssociations, request, handler, context);
  }
 
  virtual Model::BatchImportFindingsOutcome BatchImportFindings(const Model::BatchImportFindingsRequest& request) const;
 
  template <typename BatchImportFindingsRequestT = Model::BatchImportFindingsRequest>
  Model::BatchImportFindingsOutcomeCallable BatchImportFindingsCallable(const BatchImportFindingsRequestT& request) const {
    return SubmitCallable(&SecurityHubClient::BatchImportFindings, request);
  }
 
  template <typename BatchImportFindingsRequestT = Model::BatchImportFindingsRequest>
  void BatchImportFindingsAsync(const BatchImportFindingsRequestT& request, const BatchImportFindingsResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityHubClient::BatchImportFindings, request, handler, context);
  }
 
  virtual Model::BatchUpdateAutomationRulesOutcome BatchUpdateAutomationRules(
      const Model::BatchUpdateAutomationRulesRequest& request) const;
 
  template <typename BatchUpdateAutomationRulesRequestT = Model::BatchUpdateAutomationRulesRequest>
  Model::BatchUpdateAutomationRulesOutcomeCallable BatchUpdateAutomationRulesCallable(
      const BatchUpdateAutomationRulesRequestT& request) const {
    return SubmitCallable(&SecurityHubClient::BatchUpdateAutomationRules, request);
  }
 
  template <typename BatchUpdateAutomationRulesRequestT = Model::BatchUpdateAutomationRulesRequest>
  void BatchUpdateAutomationRulesAsync(const BatchUpdateAutomationRulesRequestT& request,
                                       const BatchUpdateAutomationRulesResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityHubClient::BatchUpdateAutomationRules, request, handler, context);
  }
 
  virtual Model::BatchUpdateFindingsOutcome BatchUpdateFindings(const Model::BatchUpdateFindingsRequest& request) const;
 
  template <typename BatchUpdateFindingsRequestT = Model::BatchUpdateFindingsRequest>
  Model::BatchUpdateFindingsOutcomeCallable BatchUpdateFindingsCallable(const BatchUpdateFindingsRequestT& request) const {
    return SubmitCallable(&SecurityHubClient::BatchUpdateFindings, request);
  }
 
  template <typename BatchUpdateFindingsRequestT = Model::BatchUpdateFindingsRequest>
  void BatchUpdateFindingsAsync(const BatchUpdateFindingsRequestT& request, const BatchUpdateFindingsResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityHubClient::BatchUpdateFindings, request, handler, context);
  }
 
  virtual Model::BatchUpdateFindingsV2Outcome BatchUpdateFindingsV2(const Model::BatchUpdateFindingsV2Request& request = {}) const;
 
  template <typename BatchUpdateFindingsV2RequestT = Model::BatchUpdateFindingsV2Request>
  Model::BatchUpdateFindingsV2OutcomeCallable BatchUpdateFindingsV2Callable(const BatchUpdateFindingsV2RequestT& request = {}) const {
    return SubmitCallable(&SecurityHubClient::BatchUpdateFindingsV2, request);
  }
 
  template <typename BatchUpdateFindingsV2RequestT = Model::BatchUpdateFindingsV2Request>
  void BatchUpdateFindingsV2Async(const BatchUpdateFindingsV2ResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                  const BatchUpdateFindingsV2RequestT& request = {}) const {
    return SubmitAsync(&SecurityHubClient::BatchUpdateFindingsV2, request, handler, context);
  }
 
  virtual Model::BatchUpdateStandardsControlAssociationsOutcome BatchUpdateStandardsControlAssociations(
      const Model::BatchUpdateStandardsControlAssociationsRequest& request) const;
 
  template <typename BatchUpdateStandardsControlAssociationsRequestT = Model::BatchUpdateStandardsControlAssociationsRequest>
  Model::BatchUpdateStandardsControlAssociationsOutcomeCallable BatchUpdateStandardsControlAssociationsCallable(
      const BatchUpdateStandardsControlAssociationsRequestT& request) const {
    return SubmitCallable(&SecurityHubClient::BatchUpdateStandardsControlAssociations, request);
  }
 
  template <typename BatchUpdateStandardsControlAssociationsRequestT = Model::BatchUpdateStandardsControlAssociationsRequest>
  void BatchUpdateStandardsControlAssociationsAsync(const BatchUpdateStandardsControlAssociationsRequestT& request,
                                                    const BatchUpdateStandardsControlAssociationsResponseReceivedHandler& handler,
                                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityHubClient::BatchUpdateStandardsControlAssociations, request, handler, context);
  }
 
  virtual Model::CreateActionTargetOutcome CreateActionTarget(const Model::CreateActionTargetRequest& request) const;
 
  template <typename CreateActionTargetRequestT = Model::CreateActionTargetRequest>
  Model::CreateActionTargetOutcomeCallable CreateActionTargetCallable(const CreateActionTargetRequestT& request) const {
    return SubmitCallable(&SecurityHubClient::CreateActionTarget, request);
  }
 
  template <typename CreateActionTargetRequestT = Model::CreateActionTargetRequest>
  void CreateActionTargetAsync(const CreateActionTargetRequestT& request, const CreateActionTargetResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityHubClient::CreateActionTarget, request, handler, context);
  }
 
  virtual Model::CreateAggregatorV2Outcome CreateAggregatorV2(const Model::CreateAggregatorV2Request& request) const;
 
  template <typename CreateAggregatorV2RequestT = Model::CreateAggregatorV2Request>
  Model::CreateAggregatorV2OutcomeCallable CreateAggregatorV2Callable(const CreateAggregatorV2RequestT& request) const {
    return SubmitCallable(&SecurityHubClient::CreateAggregatorV2, request);
  }
 
  template <typename CreateAggregatorV2RequestT = Model::CreateAggregatorV2Request>
  void CreateAggregatorV2Async(const CreateAggregatorV2RequestT& request, const CreateAggregatorV2ResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityHubClient::CreateAggregatorV2, request, handler, context);
  }
 
  virtual Model::CreateAutomationRuleOutcome CreateAutomationRule(const Model::CreateAutomationRuleRequest& request) const;
 
  template <typename CreateAutomationRuleRequestT = Model::CreateAutomationRuleRequest>
  Model::CreateAutomationRuleOutcomeCallable CreateAutomationRuleCallable(const CreateAutomationRuleRequestT& request) const {
    return SubmitCallable(&SecurityHubClient::CreateAutomationRule, request);
  }
 
  template <typename CreateAutomationRuleRequestT = Model::CreateAutomationRuleRequest>
  void CreateAutomationRuleAsync(const CreateAutomationRuleRequestT& request, const CreateAutomationRuleResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityHubClient::CreateAutomationRule, request, handler, context);
  }
 
  virtual Model::CreateAutomationRuleV2Outcome CreateAutomationRuleV2(const Model::CreateAutomationRuleV2Request& request) const;
 
  template <typename CreateAutomationRuleV2RequestT = Model::CreateAutomationRuleV2Request>
  Model::CreateAutomationRuleV2OutcomeCallable CreateAutomationRuleV2Callable(const CreateAutomationRuleV2RequestT& request) const {
    return SubmitCallable(&SecurityHubClient::CreateAutomationRuleV2, request);
  }
 
  template <typename CreateAutomationRuleV2RequestT = Model::CreateAutomationRuleV2Request>
  void CreateAutomationRuleV2Async(const CreateAutomationRuleV2RequestT& request,
                                   const CreateAutomationRuleV2ResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityHubClient::CreateAutomationRuleV2, request, handler, context);
  }
 
  virtual Model::CreateConfigurationPolicyOutcome CreateConfigurationPolicy(const Model::CreateConfigurationPolicyRequest& request) const;
 
  template <typename CreateConfigurationPolicyRequestT = Model::CreateConfigurationPolicyRequest>
  Model::CreateConfigurationPolicyOutcomeCallable CreateConfigurationPolicyCallable(
      const CreateConfigurationPolicyRequestT& request) const {
    return SubmitCallable(&SecurityHubClient::CreateConfigurationPolicy, request);
  }
 
  template <typename CreateConfigurationPolicyRequestT = Model::CreateConfigurationPolicyRequest>
  void CreateConfigurationPolicyAsync(const CreateConfigurationPolicyRequestT& request,
                                      const CreateConfigurationPolicyResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityHubClient::CreateConfigurationPolicy, request, handler, context);
  }
 
  virtual Model::CreateConnectorOutcome CreateConnector(const Model::CreateConnectorRequest& request) const;
 
  template <typename CreateConnectorRequestT = Model::CreateConnectorRequest>
  Model::CreateConnectorOutcomeCallable CreateConnectorCallable(const CreateConnectorRequestT& request) const {
    return SubmitCallable(&SecurityHubClient::CreateConnector, request);
  }
 
  template <typename CreateConnectorRequestT = Model::CreateConnectorRequest>
  void CreateConnectorAsync(const CreateConnectorRequestT& request, const CreateConnectorResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityHubClient::CreateConnector, request, handler, context);
  }
 
  virtual Model::CreateConnectorV2Outcome CreateConnectorV2(const Model::CreateConnectorV2Request& request) const;
 
  template <typename CreateConnectorV2RequestT = Model::CreateConnectorV2Request>
  Model::CreateConnectorV2OutcomeCallable CreateConnectorV2Callable(const CreateConnectorV2RequestT& request) const {
    return SubmitCallable(&SecurityHubClient::CreateConnectorV2, request);
  }
 
  template <typename CreateConnectorV2RequestT = Model::CreateConnectorV2Request>
  void CreateConnectorV2Async(const CreateConnectorV2RequestT& request, const CreateConnectorV2ResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityHubClient::CreateConnectorV2, request, handler, context);
  }
 
  virtual Model::CreateFindingAggregatorOutcome CreateFindingAggregator(const Model::CreateFindingAggregatorRequest& request) const;
 
  template <typename CreateFindingAggregatorRequestT = Model::CreateFindingAggregatorRequest>
  Model::CreateFindingAggregatorOutcomeCallable CreateFindingAggregatorCallable(const CreateFindingAggregatorRequestT& request) const {
    return SubmitCallable(&SecurityHubClient::CreateFindingAggregator, request);
  }
 
  template <typename CreateFindingAggregatorRequestT = Model::CreateFindingAggregatorRequest>
  void CreateFindingAggregatorAsync(const CreateFindingAggregatorRequestT& request,
                                    const CreateFindingAggregatorResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityHubClient::CreateFindingAggregator, request, handler, context);
  }
 
  virtual Model::CreateInsightOutcome CreateInsight(const Model::CreateInsightRequest& request) const;
 
  template <typename CreateInsightRequestT = Model::CreateInsightRequest>
  Model::CreateInsightOutcomeCallable CreateInsightCallable(const CreateInsightRequestT& request) const {
    return SubmitCallable(&SecurityHubClient::CreateInsight, request);
  }
 
  template <typename CreateInsightRequestT = Model::CreateInsightRequest>
  void CreateInsightAsync(const CreateInsightRequestT& request, const CreateInsightResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityHubClient::CreateInsight, 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(&SecurityHubClient::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(&SecurityHubClient::CreateMembers, request, handler, context);
  }
 
  virtual Model::CreateTicketV2Outcome CreateTicketV2(const Model::CreateTicketV2Request& request) const;
 
  template <typename CreateTicketV2RequestT = Model::CreateTicketV2Request>
  Model::CreateTicketV2OutcomeCallable CreateTicketV2Callable(const CreateTicketV2RequestT& request) const {
    return SubmitCallable(&SecurityHubClient::CreateTicketV2, request);
  }
 
  template <typename CreateTicketV2RequestT = Model::CreateTicketV2Request>
  void CreateTicketV2Async(const CreateTicketV2RequestT& request, const CreateTicketV2ResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityHubClient::CreateTicketV2, 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(&SecurityHubClient::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(&SecurityHubClient::DeclineInvitations, request, handler, context);
  }
 
  virtual Model::DeleteActionTargetOutcome DeleteActionTarget(const Model::DeleteActionTargetRequest& request) const;
 
  template <typename DeleteActionTargetRequestT = Model::DeleteActionTargetRequest>
  Model::DeleteActionTargetOutcomeCallable DeleteActionTargetCallable(const DeleteActionTargetRequestT& request) const {
    return SubmitCallable(&SecurityHubClient::DeleteActionTarget, request);
  }
 
  template <typename DeleteActionTargetRequestT = Model::DeleteActionTargetRequest>
  void DeleteActionTargetAsync(const DeleteActionTargetRequestT& request, const DeleteActionTargetResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityHubClient::DeleteActionTarget, request, handler, context);
  }
 
  virtual Model::DeleteAggregatorV2Outcome DeleteAggregatorV2(const Model::DeleteAggregatorV2Request& request) const;
 
  template <typename DeleteAggregatorV2RequestT = Model::DeleteAggregatorV2Request>
  Model::DeleteAggregatorV2OutcomeCallable DeleteAggregatorV2Callable(const DeleteAggregatorV2RequestT& request) const {
    return SubmitCallable(&SecurityHubClient::DeleteAggregatorV2, request);
  }
 
  template <typename DeleteAggregatorV2RequestT = Model::DeleteAggregatorV2Request>
  void DeleteAggregatorV2Async(const DeleteAggregatorV2RequestT& request, const DeleteAggregatorV2ResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityHubClient::DeleteAggregatorV2, request, handler, context);
  }
 
  virtual Model::DeleteAutomationRuleV2Outcome DeleteAutomationRuleV2(const Model::DeleteAutomationRuleV2Request& request) const;
 
  template <typename DeleteAutomationRuleV2RequestT = Model::DeleteAutomationRuleV2Request>
  Model::DeleteAutomationRuleV2OutcomeCallable DeleteAutomationRuleV2Callable(const DeleteAutomationRuleV2RequestT& request) const {
    return SubmitCallable(&SecurityHubClient::DeleteAutomationRuleV2, request);
  }
 
  template <typename DeleteAutomationRuleV2RequestT = Model::DeleteAutomationRuleV2Request>
  void DeleteAutomationRuleV2Async(const DeleteAutomationRuleV2RequestT& request,
                                   const DeleteAutomationRuleV2ResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityHubClient::DeleteAutomationRuleV2, request, handler, context);
  }
 
  virtual Model::DeleteConfigurationPolicyOutcome DeleteConfigurationPolicy(const Model::DeleteConfigurationPolicyRequest& request) const;
 
  template <typename DeleteConfigurationPolicyRequestT = Model::DeleteConfigurationPolicyRequest>
  Model::DeleteConfigurationPolicyOutcomeCallable DeleteConfigurationPolicyCallable(
      const DeleteConfigurationPolicyRequestT& request) const {
    return SubmitCallable(&SecurityHubClient::DeleteConfigurationPolicy, request);
  }
 
  template <typename DeleteConfigurationPolicyRequestT = Model::DeleteConfigurationPolicyRequest>
  void DeleteConfigurationPolicyAsync(const DeleteConfigurationPolicyRequestT& request,
                                      const DeleteConfigurationPolicyResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityHubClient::DeleteConfigurationPolicy, request, handler, context);
  }
 
  virtual Model::DeleteConnectorOutcome DeleteConnector(const Model::DeleteConnectorRequest& request) const;
 
  template <typename DeleteConnectorRequestT = Model::DeleteConnectorRequest>
  Model::DeleteConnectorOutcomeCallable DeleteConnectorCallable(const DeleteConnectorRequestT& request) const {
    return SubmitCallable(&SecurityHubClient::DeleteConnector, request);
  }
 
  template <typename DeleteConnectorRequestT = Model::DeleteConnectorRequest>
  void DeleteConnectorAsync(const DeleteConnectorRequestT& request, const DeleteConnectorResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityHubClient::DeleteConnector, request, handler, context);
  }
 
  virtual Model::DeleteConnectorV2Outcome DeleteConnectorV2(const Model::DeleteConnectorV2Request& request) const;
 
  template <typename DeleteConnectorV2RequestT = Model::DeleteConnectorV2Request>
  Model::DeleteConnectorV2OutcomeCallable DeleteConnectorV2Callable(const DeleteConnectorV2RequestT& request) const {
    return SubmitCallable(&SecurityHubClient::DeleteConnectorV2, request);
  }
 
  template <typename DeleteConnectorV2RequestT = Model::DeleteConnectorV2Request>
  void DeleteConnectorV2Async(const DeleteConnectorV2RequestT& request, const DeleteConnectorV2ResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityHubClient::DeleteConnectorV2, request, handler, context);
  }
 
  virtual Model::DeleteFindingAggregatorOutcome DeleteFindingAggregator(const Model::DeleteFindingAggregatorRequest& request) const;
 
  template <typename DeleteFindingAggregatorRequestT = Model::DeleteFindingAggregatorRequest>
  Model::DeleteFindingAggregatorOutcomeCallable DeleteFindingAggregatorCallable(const DeleteFindingAggregatorRequestT& request) const {
    return SubmitCallable(&SecurityHubClient::DeleteFindingAggregator, request);
  }
 
  template <typename DeleteFindingAggregatorRequestT = Model::DeleteFindingAggregatorRequest>
  void DeleteFindingAggregatorAsync(const DeleteFindingAggregatorRequestT& request,
                                    const DeleteFindingAggregatorResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityHubClient::DeleteFindingAggregator, request, handler, context);
  }
 
  virtual Model::DeleteInsightOutcome DeleteInsight(const Model::DeleteInsightRequest& request) const;
 
  template <typename DeleteInsightRequestT = Model::DeleteInsightRequest>
  Model::DeleteInsightOutcomeCallable DeleteInsightCallable(const DeleteInsightRequestT& request) const {
    return SubmitCallable(&SecurityHubClient::DeleteInsight, request);
  }
 
  template <typename DeleteInsightRequestT = Model::DeleteInsightRequest>
  void DeleteInsightAsync(const DeleteInsightRequestT& request, const DeleteInsightResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityHubClient::DeleteInsight, 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(&SecurityHubClient::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(&SecurityHubClient::DeleteInvitations, 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(&SecurityHubClient::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(&SecurityHubClient::DeleteMembers, request, handler, context);
  }
 
  virtual Model::DescribeActionTargetsOutcome DescribeActionTargets(const Model::DescribeActionTargetsRequest& request = {}) const;
 
  template <typename DescribeActionTargetsRequestT = Model::DescribeActionTargetsRequest>
  Model::DescribeActionTargetsOutcomeCallable DescribeActionTargetsCallable(const DescribeActionTargetsRequestT& request = {}) const {
    return SubmitCallable(&SecurityHubClient::DescribeActionTargets, request);
  }
 
  template <typename DescribeActionTargetsRequestT = Model::DescribeActionTargetsRequest>
  void DescribeActionTargetsAsync(const DescribeActionTargetsResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                  const DescribeActionTargetsRequestT& request = {}) const {
    return SubmitAsync(&SecurityHubClient::DescribeActionTargets, request, handler, context);
  }
 
  virtual Model::DescribeHubOutcome DescribeHub(const Model::DescribeHubRequest& request = {}) const;
 
  template <typename DescribeHubRequestT = Model::DescribeHubRequest>
  Model::DescribeHubOutcomeCallable DescribeHubCallable(const DescribeHubRequestT& request = {}) const {
    return SubmitCallable(&SecurityHubClient::DescribeHub, request);
  }
 
  template <typename DescribeHubRequestT = Model::DescribeHubRequest>
  void DescribeHubAsync(const DescribeHubResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                        const DescribeHubRequestT& request = {}) const {
    return SubmitAsync(&SecurityHubClient::DescribeHub, 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(&SecurityHubClient::DescribeOrganizationConfiguration, request);
  }
 
  template <typename DescribeOrganizationConfigurationRequestT = Model::DescribeOrganizationConfigurationRequest>
  void DescribeOrganizationConfigurationAsync(const DescribeOrganizationConfigurationResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                              const DescribeOrganizationConfigurationRequestT& request = {}) const {
    return SubmitAsync(&SecurityHubClient::DescribeOrganizationConfiguration, request, handler, context);
  }
 
  virtual Model::DescribeProductsOutcome DescribeProducts(const Model::DescribeProductsRequest& request = {}) const;
 
  template <typename DescribeProductsRequestT = Model::DescribeProductsRequest>
  Model::DescribeProductsOutcomeCallable DescribeProductsCallable(const DescribeProductsRequestT& request = {}) const {
    return SubmitCallable(&SecurityHubClient::DescribeProducts, request);
  }
 
  template <typename DescribeProductsRequestT = Model::DescribeProductsRequest>
  void DescribeProductsAsync(const DescribeProductsResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                             const DescribeProductsRequestT& request = {}) const {
    return SubmitAsync(&SecurityHubClient::DescribeProducts, request, handler, context);
  }
 
  virtual Model::DescribeProductsV2Outcome DescribeProductsV2(const Model::DescribeProductsV2Request& request = {}) const;
 
  template <typename DescribeProductsV2RequestT = Model::DescribeProductsV2Request>
  Model::DescribeProductsV2OutcomeCallable DescribeProductsV2Callable(const DescribeProductsV2RequestT& request = {}) const {
    return SubmitCallable(&SecurityHubClient::DescribeProductsV2, request);
  }
 
  template <typename DescribeProductsV2RequestT = Model::DescribeProductsV2Request>
  void DescribeProductsV2Async(const DescribeProductsV2ResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                               const DescribeProductsV2RequestT& request = {}) const {
    return SubmitAsync(&SecurityHubClient::DescribeProductsV2, request, handler, context);
  }
 
  virtual Model::DescribeSecurityHubV2Outcome DescribeSecurityHubV2(const Model::DescribeSecurityHubV2Request& request = {}) const;
 
  template <typename DescribeSecurityHubV2RequestT = Model::DescribeSecurityHubV2Request>
  Model::DescribeSecurityHubV2OutcomeCallable DescribeSecurityHubV2Callable(const DescribeSecurityHubV2RequestT& request = {}) const {
    return SubmitCallable(&SecurityHubClient::DescribeSecurityHubV2, request);
  }
 
  template <typename DescribeSecurityHubV2RequestT = Model::DescribeSecurityHubV2Request>
  void DescribeSecurityHubV2Async(const DescribeSecurityHubV2ResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                  const DescribeSecurityHubV2RequestT& request = {}) const {
    return SubmitAsync(&SecurityHubClient::DescribeSecurityHubV2, request, handler, context);
  }
 
  virtual Model::DescribeStandardsOutcome DescribeStandards(const Model::DescribeStandardsRequest& request = {}) const;
 
  template <typename DescribeStandardsRequestT = Model::DescribeStandardsRequest>
  Model::DescribeStandardsOutcomeCallable DescribeStandardsCallable(const DescribeStandardsRequestT& request = {}) const {
    return SubmitCallable(&SecurityHubClient::DescribeStandards, request);
  }
 
  template <typename DescribeStandardsRequestT = Model::DescribeStandardsRequest>
  void DescribeStandardsAsync(const DescribeStandardsResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                              const DescribeStandardsRequestT& request = {}) const {
    return SubmitAsync(&SecurityHubClient::DescribeStandards, request, handler, context);
  }
 
  virtual Model::DescribeStandardsControlsOutcome DescribeStandardsControls(const Model::DescribeStandardsControlsRequest& request) const;
 
  template <typename DescribeStandardsControlsRequestT = Model::DescribeStandardsControlsRequest>
  Model::DescribeStandardsControlsOutcomeCallable DescribeStandardsControlsCallable(
      const DescribeStandardsControlsRequestT& request) const {
    return SubmitCallable(&SecurityHubClient::DescribeStandardsControls, request);
  }
 
  template <typename DescribeStandardsControlsRequestT = Model::DescribeStandardsControlsRequest>
  void DescribeStandardsControlsAsync(const DescribeStandardsControlsRequestT& request,
                                      const DescribeStandardsControlsResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityHubClient::DescribeStandardsControls, request, handler, context);
  }
 
  virtual Model::DisableImportFindingsForProductOutcome DisableImportFindingsForProduct(
      const Model::DisableImportFindingsForProductRequest& request) const;
 
  template <typename DisableImportFindingsForProductRequestT = Model::DisableImportFindingsForProductRequest>
  Model::DisableImportFindingsForProductOutcomeCallable DisableImportFindingsForProductCallable(
      const DisableImportFindingsForProductRequestT& request) const {
    return SubmitCallable(&SecurityHubClient::DisableImportFindingsForProduct, request);
  }
 
  template <typename DisableImportFindingsForProductRequestT = Model::DisableImportFindingsForProductRequest>
  void DisableImportFindingsForProductAsync(const DisableImportFindingsForProductRequestT& request,
                                            const DisableImportFindingsForProductResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityHubClient::DisableImportFindingsForProduct, 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(&SecurityHubClient::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(&SecurityHubClient::DisableOrganizationAdminAccount, request, handler, context);
  }
 
  virtual Model::DisableSecurityHubOutcome DisableSecurityHub(const Model::DisableSecurityHubRequest& request = {}) const;
 
  template <typename DisableSecurityHubRequestT = Model::DisableSecurityHubRequest>
  Model::DisableSecurityHubOutcomeCallable DisableSecurityHubCallable(const DisableSecurityHubRequestT& request = {}) const {
    return SubmitCallable(&SecurityHubClient::DisableSecurityHub, request);
  }
 
  template <typename DisableSecurityHubRequestT = Model::DisableSecurityHubRequest>
  void DisableSecurityHubAsync(const DisableSecurityHubResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                               const DisableSecurityHubRequestT& request = {}) const {
    return SubmitAsync(&SecurityHubClient::DisableSecurityHub, request, handler, context);
  }
 
  virtual Model::DisableSecurityHubFeatureV2Outcome DisableSecurityHubFeatureV2(
      const Model::DisableSecurityHubFeatureV2Request& request) const;
 
  template <typename DisableSecurityHubFeatureV2RequestT = Model::DisableSecurityHubFeatureV2Request>
  Model::DisableSecurityHubFeatureV2OutcomeCallable DisableSecurityHubFeatureV2Callable(
      const DisableSecurityHubFeatureV2RequestT& request) const {
    return SubmitCallable(&SecurityHubClient::DisableSecurityHubFeatureV2, request);
  }
 
  template <typename DisableSecurityHubFeatureV2RequestT = Model::DisableSecurityHubFeatureV2Request>
  void DisableSecurityHubFeatureV2Async(const DisableSecurityHubFeatureV2RequestT& request,
                                        const DisableSecurityHubFeatureV2ResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityHubClient::DisableSecurityHubFeatureV2, request, handler, context);
  }
 
  virtual Model::DisableSecurityHubV2Outcome DisableSecurityHubV2(const Model::DisableSecurityHubV2Request& request = {}) const;
 
  template <typename DisableSecurityHubV2RequestT = Model::DisableSecurityHubV2Request>
  Model::DisableSecurityHubV2OutcomeCallable DisableSecurityHubV2Callable(const DisableSecurityHubV2RequestT& request = {}) const {
    return SubmitCallable(&SecurityHubClient::DisableSecurityHubV2, request);
  }
 
  template <typename DisableSecurityHubV2RequestT = Model::DisableSecurityHubV2Request>
  void DisableSecurityHubV2Async(const DisableSecurityHubV2ResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                 const DisableSecurityHubV2RequestT& request = {}) const {
    return SubmitAsync(&SecurityHubClient::DisableSecurityHubV2, 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(&SecurityHubClient::DisassociateFromAdministratorAccount, request);
  }
 
  template <typename DisassociateFromAdministratorAccountRequestT = Model::DisassociateFromAdministratorAccountRequest>
  void DisassociateFromAdministratorAccountAsync(const DisassociateFromAdministratorAccountResponseReceivedHandler& handler,
                                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                                 const DisassociateFromAdministratorAccountRequestT& request = {}) const {
    return SubmitAsync(&SecurityHubClient::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(&SecurityHubClient::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(&SecurityHubClient::DisassociateMembers, request, handler, context);
  }
 
  virtual Model::EnableImportFindingsForProductOutcome EnableImportFindingsForProduct(
      const Model::EnableImportFindingsForProductRequest& request) const;
 
  template <typename EnableImportFindingsForProductRequestT = Model::EnableImportFindingsForProductRequest>
  Model::EnableImportFindingsForProductOutcomeCallable EnableImportFindingsForProductCallable(
      const EnableImportFindingsForProductRequestT& request) const {
    return SubmitCallable(&SecurityHubClient::EnableImportFindingsForProduct, request);
  }
 
  template <typename EnableImportFindingsForProductRequestT = Model::EnableImportFindingsForProductRequest>
  void EnableImportFindingsForProductAsync(const EnableImportFindingsForProductRequestT& request,
                                           const EnableImportFindingsForProductResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityHubClient::EnableImportFindingsForProduct, 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(&SecurityHubClient::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(&SecurityHubClient::EnableOrganizationAdminAccount, request, handler, context);
  }
 
  virtual Model::EnableSecurityHubOutcome EnableSecurityHub(const Model::EnableSecurityHubRequest& request = {}) const;
 
  template <typename EnableSecurityHubRequestT = Model::EnableSecurityHubRequest>
  Model::EnableSecurityHubOutcomeCallable EnableSecurityHubCallable(const EnableSecurityHubRequestT& request = {}) const {
    return SubmitCallable(&SecurityHubClient::EnableSecurityHub, request);
  }
 
  template <typename EnableSecurityHubRequestT = Model::EnableSecurityHubRequest>
  void EnableSecurityHubAsync(const EnableSecurityHubResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                              const EnableSecurityHubRequestT& request = {}) const {
    return SubmitAsync(&SecurityHubClient::EnableSecurityHub, request, handler, context);
  }
 
  virtual Model::EnableSecurityHubFeatureV2Outcome EnableSecurityHubFeatureV2(
      const Model::EnableSecurityHubFeatureV2Request& request) const;
 
  template <typename EnableSecurityHubFeatureV2RequestT = Model::EnableSecurityHubFeatureV2Request>
  Model::EnableSecurityHubFeatureV2OutcomeCallable EnableSecurityHubFeatureV2Callable(
      const EnableSecurityHubFeatureV2RequestT& request) const {
    return SubmitCallable(&SecurityHubClient::EnableSecurityHubFeatureV2, request);
  }
 
  template <typename EnableSecurityHubFeatureV2RequestT = Model::EnableSecurityHubFeatureV2Request>
  void EnableSecurityHubFeatureV2Async(const EnableSecurityHubFeatureV2RequestT& request,
                                       const EnableSecurityHubFeatureV2ResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityHubClient::EnableSecurityHubFeatureV2, request, handler, context);
  }
 
  virtual Model::EnableSecurityHubV2Outcome EnableSecurityHubV2(const Model::EnableSecurityHubV2Request& request = {}) const;
 
  template <typename EnableSecurityHubV2RequestT = Model::EnableSecurityHubV2Request>
  Model::EnableSecurityHubV2OutcomeCallable EnableSecurityHubV2Callable(const EnableSecurityHubV2RequestT& request = {}) const {
    return SubmitCallable(&SecurityHubClient::EnableSecurityHubV2, request);
  }
 
  template <typename EnableSecurityHubV2RequestT = Model::EnableSecurityHubV2Request>
  void EnableSecurityHubV2Async(const EnableSecurityHubV2ResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                const EnableSecurityHubV2RequestT& request = {}) const {
    return SubmitAsync(&SecurityHubClient::EnableSecurityHubV2, request, handler, context);
  }
 
  virtual Model::GenerateRecommendedPolicyV2Outcome GenerateRecommendedPolicyV2(
      const Model::GenerateRecommendedPolicyV2Request& request) const;
 
  template <typename GenerateRecommendedPolicyV2RequestT = Model::GenerateRecommendedPolicyV2Request>
  Model::GenerateRecommendedPolicyV2OutcomeCallable GenerateRecommendedPolicyV2Callable(
      const GenerateRecommendedPolicyV2RequestT& request) const {
    return SubmitCallable(&SecurityHubClient::GenerateRecommendedPolicyV2, request);
  }
 
  template <typename GenerateRecommendedPolicyV2RequestT = Model::GenerateRecommendedPolicyV2Request>
  void GenerateRecommendedPolicyV2Async(const GenerateRecommendedPolicyV2RequestT& request,
                                        const GenerateRecommendedPolicyV2ResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityHubClient::GenerateRecommendedPolicyV2, 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(&SecurityHubClient::GetAdministratorAccount, request);
  }
 
  template <typename GetAdministratorAccountRequestT = Model::GetAdministratorAccountRequest>
  void GetAdministratorAccountAsync(const GetAdministratorAccountResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                    const GetAdministratorAccountRequestT& request = {}) const {
    return SubmitAsync(&SecurityHubClient::GetAdministratorAccount, request, handler, context);
  }
 
  virtual Model::GetAggregatorV2Outcome GetAggregatorV2(const Model::GetAggregatorV2Request& request) const;
 
  template <typename GetAggregatorV2RequestT = Model::GetAggregatorV2Request>
  Model::GetAggregatorV2OutcomeCallable GetAggregatorV2Callable(const GetAggregatorV2RequestT& request) const {
    return SubmitCallable(&SecurityHubClient::GetAggregatorV2, request);
  }
 
  template <typename GetAggregatorV2RequestT = Model::GetAggregatorV2Request>
  void GetAggregatorV2Async(const GetAggregatorV2RequestT& request, const GetAggregatorV2ResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityHubClient::GetAggregatorV2, request, handler, context);
  }
 
  virtual Model::GetAutomationRuleV2Outcome GetAutomationRuleV2(const Model::GetAutomationRuleV2Request& request) const;
 
  template <typename GetAutomationRuleV2RequestT = Model::GetAutomationRuleV2Request>
  Model::GetAutomationRuleV2OutcomeCallable GetAutomationRuleV2Callable(const GetAutomationRuleV2RequestT& request) const {
    return SubmitCallable(&SecurityHubClient::GetAutomationRuleV2, request);
  }
 
  template <typename GetAutomationRuleV2RequestT = Model::GetAutomationRuleV2Request>
  void GetAutomationRuleV2Async(const GetAutomationRuleV2RequestT& request, const GetAutomationRuleV2ResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityHubClient::GetAutomationRuleV2, request, handler, context);
  }
 
  virtual Model::GetConfigurationPolicyOutcome GetConfigurationPolicy(const Model::GetConfigurationPolicyRequest& request) const;
 
  template <typename GetConfigurationPolicyRequestT = Model::GetConfigurationPolicyRequest>
  Model::GetConfigurationPolicyOutcomeCallable GetConfigurationPolicyCallable(const GetConfigurationPolicyRequestT& request) const {
    return SubmitCallable(&SecurityHubClient::GetConfigurationPolicy, request);
  }
 
  template <typename GetConfigurationPolicyRequestT = Model::GetConfigurationPolicyRequest>
  void GetConfigurationPolicyAsync(const GetConfigurationPolicyRequestT& request,
                                   const GetConfigurationPolicyResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityHubClient::GetConfigurationPolicy, request, handler, context);
  }
 
  virtual Model::GetConfigurationPolicyAssociationOutcome GetConfigurationPolicyAssociation(
      const Model::GetConfigurationPolicyAssociationRequest& request) const;
 
  template <typename GetConfigurationPolicyAssociationRequestT = Model::GetConfigurationPolicyAssociationRequest>
  Model::GetConfigurationPolicyAssociationOutcomeCallable GetConfigurationPolicyAssociationCallable(
      const GetConfigurationPolicyAssociationRequestT& request) const {
    return SubmitCallable(&SecurityHubClient::GetConfigurationPolicyAssociation, request);
  }
 
  template <typename GetConfigurationPolicyAssociationRequestT = Model::GetConfigurationPolicyAssociationRequest>
  void GetConfigurationPolicyAssociationAsync(const GetConfigurationPolicyAssociationRequestT& request,
                                              const GetConfigurationPolicyAssociationResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityHubClient::GetConfigurationPolicyAssociation, request, handler, context);
  }
 
  virtual Model::GetConnectorOutcome GetConnector(const Model::GetConnectorRequest& request) const;
 
  template <typename GetConnectorRequestT = Model::GetConnectorRequest>
  Model::GetConnectorOutcomeCallable GetConnectorCallable(const GetConnectorRequestT& request) const {
    return SubmitCallable(&SecurityHubClient::GetConnector, request);
  }
 
  template <typename GetConnectorRequestT = Model::GetConnectorRequest>
  void GetConnectorAsync(const GetConnectorRequestT& request, const GetConnectorResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityHubClient::GetConnector, request, handler, context);
  }
 
  virtual Model::GetConnectorV2Outcome GetConnectorV2(const Model::GetConnectorV2Request& request) const;
 
  template <typename GetConnectorV2RequestT = Model::GetConnectorV2Request>
  Model::GetConnectorV2OutcomeCallable GetConnectorV2Callable(const GetConnectorV2RequestT& request) const {
    return SubmitCallable(&SecurityHubClient::GetConnectorV2, request);
  }
 
  template <typename GetConnectorV2RequestT = Model::GetConnectorV2Request>
  void GetConnectorV2Async(const GetConnectorV2RequestT& request, const GetConnectorV2ResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityHubClient::GetConnectorV2, request, handler, context);
  }
 
  virtual Model::GetEnabledStandardsOutcome GetEnabledStandards(const Model::GetEnabledStandardsRequest& request = {}) const;
 
  template <typename GetEnabledStandardsRequestT = Model::GetEnabledStandardsRequest>
  Model::GetEnabledStandardsOutcomeCallable GetEnabledStandardsCallable(const GetEnabledStandardsRequestT& request = {}) const {
    return SubmitCallable(&SecurityHubClient::GetEnabledStandards, request);
  }
 
  template <typename GetEnabledStandardsRequestT = Model::GetEnabledStandardsRequest>
  void GetEnabledStandardsAsync(const GetEnabledStandardsResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                const GetEnabledStandardsRequestT& request = {}) const {
    return SubmitAsync(&SecurityHubClient::GetEnabledStandards, request, handler, context);
  }
 
  virtual Model::GetFindingAggregatorOutcome GetFindingAggregator(const Model::GetFindingAggregatorRequest& request) const;
 
  template <typename GetFindingAggregatorRequestT = Model::GetFindingAggregatorRequest>
  Model::GetFindingAggregatorOutcomeCallable GetFindingAggregatorCallable(const GetFindingAggregatorRequestT& request) const {
    return SubmitCallable(&SecurityHubClient::GetFindingAggregator, request);
  }
 
  template <typename GetFindingAggregatorRequestT = Model::GetFindingAggregatorRequest>
  void GetFindingAggregatorAsync(const GetFindingAggregatorRequestT& request, const GetFindingAggregatorResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityHubClient::GetFindingAggregator, request, handler, context);
  }
 
  virtual Model::GetFindingHistoryOutcome GetFindingHistory(const Model::GetFindingHistoryRequest& request) const;
 
  template <typename GetFindingHistoryRequestT = Model::GetFindingHistoryRequest>
  Model::GetFindingHistoryOutcomeCallable GetFindingHistoryCallable(const GetFindingHistoryRequestT& request) const {
    return SubmitCallable(&SecurityHubClient::GetFindingHistory, request);
  }
 
  template <typename GetFindingHistoryRequestT = Model::GetFindingHistoryRequest>
  void GetFindingHistoryAsync(const GetFindingHistoryRequestT& request, const GetFindingHistoryResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityHubClient::GetFindingHistory, request, handler, context);
  }
 
  virtual Model::GetFindingStatisticsV2Outcome GetFindingStatisticsV2(const Model::GetFindingStatisticsV2Request& request) const;
 
  template <typename GetFindingStatisticsV2RequestT = Model::GetFindingStatisticsV2Request>
  Model::GetFindingStatisticsV2OutcomeCallable GetFindingStatisticsV2Callable(const GetFindingStatisticsV2RequestT& request) const {
    return SubmitCallable(&SecurityHubClient::GetFindingStatisticsV2, request);
  }
 
  template <typename GetFindingStatisticsV2RequestT = Model::GetFindingStatisticsV2Request>
  void GetFindingStatisticsV2Async(const GetFindingStatisticsV2RequestT& request,
                                   const GetFindingStatisticsV2ResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityHubClient::GetFindingStatisticsV2, 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(&SecurityHubClient::GetFindings, request);
  }
 
  template <typename GetFindingsRequestT = Model::GetFindingsRequest>
  void GetFindingsAsync(const GetFindingsResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                        const GetFindingsRequestT& request = {}) const {
    return SubmitAsync(&SecurityHubClient::GetFindings, request, handler, context);
  }
 
  virtual Model::GetFindingsTrendsV2Outcome GetFindingsTrendsV2(const Model::GetFindingsTrendsV2Request& request) const;
 
  template <typename GetFindingsTrendsV2RequestT = Model::GetFindingsTrendsV2Request>
  Model::GetFindingsTrendsV2OutcomeCallable GetFindingsTrendsV2Callable(const GetFindingsTrendsV2RequestT& request) const {
    return SubmitCallable(&SecurityHubClient::GetFindingsTrendsV2, request);
  }
 
  template <typename GetFindingsTrendsV2RequestT = Model::GetFindingsTrendsV2Request>
  void GetFindingsTrendsV2Async(const GetFindingsTrendsV2RequestT& request, const GetFindingsTrendsV2ResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityHubClient::GetFindingsTrendsV2, request, handler, context);
  }
 
  virtual Model::GetFindingsV2Outcome GetFindingsV2(const Model::GetFindingsV2Request& request = {}) const;
 
  template <typename GetFindingsV2RequestT = Model::GetFindingsV2Request>
  Model::GetFindingsV2OutcomeCallable GetFindingsV2Callable(const GetFindingsV2RequestT& request = {}) const {
    return SubmitCallable(&SecurityHubClient::GetFindingsV2, request);
  }
 
  template <typename GetFindingsV2RequestT = Model::GetFindingsV2Request>
  void GetFindingsV2Async(const GetFindingsV2ResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                          const GetFindingsV2RequestT& request = {}) const {
    return SubmitAsync(&SecurityHubClient::GetFindingsV2, request, handler, context);
  }
 
  virtual Model::GetInsightResultsOutcome GetInsightResults(const Model::GetInsightResultsRequest& request) const;
 
  template <typename GetInsightResultsRequestT = Model::GetInsightResultsRequest>
  Model::GetInsightResultsOutcomeCallable GetInsightResultsCallable(const GetInsightResultsRequestT& request) const {
    return SubmitCallable(&SecurityHubClient::GetInsightResults, request);
  }
 
  template <typename GetInsightResultsRequestT = Model::GetInsightResultsRequest>
  void GetInsightResultsAsync(const GetInsightResultsRequestT& request, const GetInsightResultsResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityHubClient::GetInsightResults, request, handler, context);
  }
 
  virtual Model::GetInsightsOutcome GetInsights(const Model::GetInsightsRequest& request = {}) const;
 
  template <typename GetInsightsRequestT = Model::GetInsightsRequest>
  Model::GetInsightsOutcomeCallable GetInsightsCallable(const GetInsightsRequestT& request = {}) const {
    return SubmitCallable(&SecurityHubClient::GetInsights, request);
  }
 
  template <typename GetInsightsRequestT = Model::GetInsightsRequest>
  void GetInsightsAsync(const GetInsightsResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                        const GetInsightsRequestT& request = {}) const {
    return SubmitAsync(&SecurityHubClient::GetInsights, 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(&SecurityHubClient::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(&SecurityHubClient::GetInvitationsCount, 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(&SecurityHubClient::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(&SecurityHubClient::GetMembers, request, handler, context);
  }
 
  virtual Model::GetRecommendedPolicyV2Outcome GetRecommendedPolicyV2(const Model::GetRecommendedPolicyV2Request& request) const;
 
  template <typename GetRecommendedPolicyV2RequestT = Model::GetRecommendedPolicyV2Request>
  Model::GetRecommendedPolicyV2OutcomeCallable GetRecommendedPolicyV2Callable(const GetRecommendedPolicyV2RequestT& request) const {
    return SubmitCallable(&SecurityHubClient::GetRecommendedPolicyV2, request);
  }
 
  template <typename GetRecommendedPolicyV2RequestT = Model::GetRecommendedPolicyV2Request>
  void GetRecommendedPolicyV2Async(const GetRecommendedPolicyV2RequestT& request,
                                   const GetRecommendedPolicyV2ResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityHubClient::GetRecommendedPolicyV2, request, handler, context);
  }
 
  virtual Model::GetResourcesStatisticsV2Outcome GetResourcesStatisticsV2(const Model::GetResourcesStatisticsV2Request& request) const;
 
  template <typename GetResourcesStatisticsV2RequestT = Model::GetResourcesStatisticsV2Request>
  Model::GetResourcesStatisticsV2OutcomeCallable GetResourcesStatisticsV2Callable(const GetResourcesStatisticsV2RequestT& request) const {
    return SubmitCallable(&SecurityHubClient::GetResourcesStatisticsV2, request);
  }
 
  template <typename GetResourcesStatisticsV2RequestT = Model::GetResourcesStatisticsV2Request>
  void GetResourcesStatisticsV2Async(const GetResourcesStatisticsV2RequestT& request,
                                     const GetResourcesStatisticsV2ResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityHubClient::GetResourcesStatisticsV2, request, handler, context);
  }
 
  virtual Model::GetResourcesTrendsV2Outcome GetResourcesTrendsV2(const Model::GetResourcesTrendsV2Request& request) const;
 
  template <typename GetResourcesTrendsV2RequestT = Model::GetResourcesTrendsV2Request>
  Model::GetResourcesTrendsV2OutcomeCallable GetResourcesTrendsV2Callable(const GetResourcesTrendsV2RequestT& request) const {
    return SubmitCallable(&SecurityHubClient::GetResourcesTrendsV2, request);
  }
 
  template <typename GetResourcesTrendsV2RequestT = Model::GetResourcesTrendsV2Request>
  void GetResourcesTrendsV2Async(const GetResourcesTrendsV2RequestT& request, const GetResourcesTrendsV2ResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityHubClient::GetResourcesTrendsV2, request, handler, context);
  }
 
  virtual Model::GetResourcesV2Outcome GetResourcesV2(const Model::GetResourcesV2Request& request = {}) const;
 
  template <typename GetResourcesV2RequestT = Model::GetResourcesV2Request>
  Model::GetResourcesV2OutcomeCallable GetResourcesV2Callable(const GetResourcesV2RequestT& request = {}) const {
    return SubmitCallable(&SecurityHubClient::GetResourcesV2, request);
  }
 
  template <typename GetResourcesV2RequestT = Model::GetResourcesV2Request>
  void GetResourcesV2Async(const GetResourcesV2ResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                           const GetResourcesV2RequestT& request = {}) const {
    return SubmitAsync(&SecurityHubClient::GetResourcesV2, request, handler, context);
  }
 
  virtual Model::GetSecurityControlDefinitionOutcome GetSecurityControlDefinition(
      const Model::GetSecurityControlDefinitionRequest& request) const;
 
  template <typename GetSecurityControlDefinitionRequestT = Model::GetSecurityControlDefinitionRequest>
  Model::GetSecurityControlDefinitionOutcomeCallable GetSecurityControlDefinitionCallable(
      const GetSecurityControlDefinitionRequestT& request) const {
    return SubmitCallable(&SecurityHubClient::GetSecurityControlDefinition, request);
  }
 
  template <typename GetSecurityControlDefinitionRequestT = Model::GetSecurityControlDefinitionRequest>
  void GetSecurityControlDefinitionAsync(const GetSecurityControlDefinitionRequestT& request,
                                         const GetSecurityControlDefinitionResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityHubClient::GetSecurityControlDefinition, 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(&SecurityHubClient::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(&SecurityHubClient::InviteMembers, request, handler, context);
  }
 
  virtual Model::ListAggregatorsV2Outcome ListAggregatorsV2(const Model::ListAggregatorsV2Request& request = {}) const;
 
  template <typename ListAggregatorsV2RequestT = Model::ListAggregatorsV2Request>
  Model::ListAggregatorsV2OutcomeCallable ListAggregatorsV2Callable(const ListAggregatorsV2RequestT& request = {}) const {
    return SubmitCallable(&SecurityHubClient::ListAggregatorsV2, request);
  }
 
  template <typename ListAggregatorsV2RequestT = Model::ListAggregatorsV2Request>
  void ListAggregatorsV2Async(const ListAggregatorsV2ResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                              const ListAggregatorsV2RequestT& request = {}) const {
    return SubmitAsync(&SecurityHubClient::ListAggregatorsV2, request, handler, context);
  }
 
  virtual Model::ListAutomationRulesOutcome ListAutomationRules(const Model::ListAutomationRulesRequest& request = {}) const;
 
  template <typename ListAutomationRulesRequestT = Model::ListAutomationRulesRequest>
  Model::ListAutomationRulesOutcomeCallable ListAutomationRulesCallable(const ListAutomationRulesRequestT& request = {}) const {
    return SubmitCallable(&SecurityHubClient::ListAutomationRules, request);
  }
 
  template <typename ListAutomationRulesRequestT = Model::ListAutomationRulesRequest>
  void ListAutomationRulesAsync(const ListAutomationRulesResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                const ListAutomationRulesRequestT& request = {}) const {
    return SubmitAsync(&SecurityHubClient::ListAutomationRules, request, handler, context);
  }
 
  virtual Model::ListAutomationRulesV2Outcome ListAutomationRulesV2(const Model::ListAutomationRulesV2Request& request = {}) const;
 
  template <typename ListAutomationRulesV2RequestT = Model::ListAutomationRulesV2Request>
  Model::ListAutomationRulesV2OutcomeCallable ListAutomationRulesV2Callable(const ListAutomationRulesV2RequestT& request = {}) const {
    return SubmitCallable(&SecurityHubClient::ListAutomationRulesV2, request);
  }
 
  template <typename ListAutomationRulesV2RequestT = Model::ListAutomationRulesV2Request>
  void ListAutomationRulesV2Async(const ListAutomationRulesV2ResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                  const ListAutomationRulesV2RequestT& request = {}) const {
    return SubmitAsync(&SecurityHubClient::ListAutomationRulesV2, request, handler, context);
  }
 
  virtual Model::ListConfigurationPoliciesOutcome ListConfigurationPolicies(
      const Model::ListConfigurationPoliciesRequest& request = {}) const;
 
  template <typename ListConfigurationPoliciesRequestT = Model::ListConfigurationPoliciesRequest>
  Model::ListConfigurationPoliciesOutcomeCallable ListConfigurationPoliciesCallable(
      const ListConfigurationPoliciesRequestT& request = {}) const {
    return SubmitCallable(&SecurityHubClient::ListConfigurationPolicies, request);
  }
 
  template <typename ListConfigurationPoliciesRequestT = Model::ListConfigurationPoliciesRequest>
  void ListConfigurationPoliciesAsync(const ListConfigurationPoliciesResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                      const ListConfigurationPoliciesRequestT& request = {}) const {
    return SubmitAsync(&SecurityHubClient::ListConfigurationPolicies, request, handler, context);
  }
 
  virtual Model::ListConfigurationPolicyAssociationsOutcome ListConfigurationPolicyAssociations(
      const Model::ListConfigurationPolicyAssociationsRequest& request = {}) const;
 
  template <typename ListConfigurationPolicyAssociationsRequestT = Model::ListConfigurationPolicyAssociationsRequest>
  Model::ListConfigurationPolicyAssociationsOutcomeCallable ListConfigurationPolicyAssociationsCallable(
      const ListConfigurationPolicyAssociationsRequestT& request = {}) const {
    return SubmitCallable(&SecurityHubClient::ListConfigurationPolicyAssociations, request);
  }
 
  template <typename ListConfigurationPolicyAssociationsRequestT = Model::ListConfigurationPolicyAssociationsRequest>
  void ListConfigurationPolicyAssociationsAsync(const ListConfigurationPolicyAssociationsResponseReceivedHandler& handler,
                                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                                const ListConfigurationPolicyAssociationsRequestT& request = {}) const {
    return SubmitAsync(&SecurityHubClient::ListConfigurationPolicyAssociations, request, handler, context);
  }
 
  virtual Model::ListConnectorsOutcome ListConnectors(const Model::ListConnectorsRequest& request = {}) const;
 
  template <typename ListConnectorsRequestT = Model::ListConnectorsRequest>
  Model::ListConnectorsOutcomeCallable ListConnectorsCallable(const ListConnectorsRequestT& request = {}) const {
    return SubmitCallable(&SecurityHubClient::ListConnectors, request);
  }
 
  template <typename ListConnectorsRequestT = Model::ListConnectorsRequest>
  void ListConnectorsAsync(const ListConnectorsResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                           const ListConnectorsRequestT& request = {}) const {
    return SubmitAsync(&SecurityHubClient::ListConnectors, request, handler, context);
  }
 
  virtual Model::ListConnectorsV2Outcome ListConnectorsV2(const Model::ListConnectorsV2Request& request = {}) const;
 
  template <typename ListConnectorsV2RequestT = Model::ListConnectorsV2Request>
  Model::ListConnectorsV2OutcomeCallable ListConnectorsV2Callable(const ListConnectorsV2RequestT& request = {}) const {
    return SubmitCallable(&SecurityHubClient::ListConnectorsV2, request);
  }
 
  template <typename ListConnectorsV2RequestT = Model::ListConnectorsV2Request>
  void ListConnectorsV2Async(const ListConnectorsV2ResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                             const ListConnectorsV2RequestT& request = {}) const {
    return SubmitAsync(&SecurityHubClient::ListConnectorsV2, request, handler, context);
  }
 
  virtual Model::ListEnabledProductsForImportOutcome ListEnabledProductsForImport(
      const Model::ListEnabledProductsForImportRequest& request = {}) const;
 
  template <typename ListEnabledProductsForImportRequestT = Model::ListEnabledProductsForImportRequest>
  Model::ListEnabledProductsForImportOutcomeCallable ListEnabledProductsForImportCallable(
      const ListEnabledProductsForImportRequestT& request = {}) const {
    return SubmitCallable(&SecurityHubClient::ListEnabledProductsForImport, request);
  }
 
  template <typename ListEnabledProductsForImportRequestT = Model::ListEnabledProductsForImportRequest>
  void ListEnabledProductsForImportAsync(const ListEnabledProductsForImportResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                         const ListEnabledProductsForImportRequestT& request = {}) const {
    return SubmitAsync(&SecurityHubClient::ListEnabledProductsForImport, request, handler, context);
  }
 
  virtual Model::ListFindingAggregatorsOutcome ListFindingAggregators(const Model::ListFindingAggregatorsRequest& request = {}) const;
 
  template <typename ListFindingAggregatorsRequestT = Model::ListFindingAggregatorsRequest>
  Model::ListFindingAggregatorsOutcomeCallable ListFindingAggregatorsCallable(const ListFindingAggregatorsRequestT& request = {}) const {
    return SubmitCallable(&SecurityHubClient::ListFindingAggregators, request);
  }
 
  template <typename ListFindingAggregatorsRequestT = Model::ListFindingAggregatorsRequest>
  void ListFindingAggregatorsAsync(const ListFindingAggregatorsResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                   const ListFindingAggregatorsRequestT& request = {}) const {
    return SubmitAsync(&SecurityHubClient::ListFindingAggregators, 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(&SecurityHubClient::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(&SecurityHubClient::ListInvitations, 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(&SecurityHubClient::ListMembers, request);
  }
 
  template <typename ListMembersRequestT = Model::ListMembersRequest>
  void ListMembersAsync(const ListMembersResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                        const ListMembersRequestT& request = {}) const {
    return SubmitAsync(&SecurityHubClient::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(&SecurityHubClient::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(&SecurityHubClient::ListOrganizationAdminAccounts, request, handler, context);
  }
 
  virtual Model::ListSecurityControlDefinitionsOutcome ListSecurityControlDefinitions(
      const Model::ListSecurityControlDefinitionsRequest& request = {}) const;
 
  template <typename ListSecurityControlDefinitionsRequestT = Model::ListSecurityControlDefinitionsRequest>
  Model::ListSecurityControlDefinitionsOutcomeCallable ListSecurityControlDefinitionsCallable(
      const ListSecurityControlDefinitionsRequestT& request = {}) const {
    return SubmitCallable(&SecurityHubClient::ListSecurityControlDefinitions, request);
  }
 
  template <typename ListSecurityControlDefinitionsRequestT = Model::ListSecurityControlDefinitionsRequest>
  void ListSecurityControlDefinitionsAsync(const ListSecurityControlDefinitionsResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                           const ListSecurityControlDefinitionsRequestT& request = {}) const {
    return SubmitAsync(&SecurityHubClient::ListSecurityControlDefinitions, request, handler, context);
  }
 
  virtual Model::ListStandardsControlAssociationsOutcome ListStandardsControlAssociations(
      const Model::ListStandardsControlAssociationsRequest& request) const;
 
  template <typename ListStandardsControlAssociationsRequestT = Model::ListStandardsControlAssociationsRequest>
  Model::ListStandardsControlAssociationsOutcomeCallable ListStandardsControlAssociationsCallable(
      const ListStandardsControlAssociationsRequestT& request) const {
    return SubmitCallable(&SecurityHubClient::ListStandardsControlAssociations, request);
  }
 
  template <typename ListStandardsControlAssociationsRequestT = Model::ListStandardsControlAssociationsRequest>
  void ListStandardsControlAssociationsAsync(const ListStandardsControlAssociationsRequestT& request,
                                             const ListStandardsControlAssociationsResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityHubClient::ListStandardsControlAssociations, 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(&SecurityHubClient::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(&SecurityHubClient::ListTagsForResource, request, handler, context);
  }
 
  virtual Model::RegisterConnectorV2Outcome RegisterConnectorV2(const Model::RegisterConnectorV2Request& request) const;
 
  template <typename RegisterConnectorV2RequestT = Model::RegisterConnectorV2Request>
  Model::RegisterConnectorV2OutcomeCallable RegisterConnectorV2Callable(const RegisterConnectorV2RequestT& request) const {
    return SubmitCallable(&SecurityHubClient::RegisterConnectorV2, request);
  }
 
  template <typename RegisterConnectorV2RequestT = Model::RegisterConnectorV2Request>
  void RegisterConnectorV2Async(const RegisterConnectorV2RequestT& request, const RegisterConnectorV2ResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityHubClient::RegisterConnectorV2, request, handler, context);
  }
 
  virtual Model::StartConfigurationPolicyAssociationOutcome StartConfigurationPolicyAssociation(
      const Model::StartConfigurationPolicyAssociationRequest& request) const;
 
  template <typename StartConfigurationPolicyAssociationRequestT = Model::StartConfigurationPolicyAssociationRequest>
  Model::StartConfigurationPolicyAssociationOutcomeCallable StartConfigurationPolicyAssociationCallable(
      const StartConfigurationPolicyAssociationRequestT& request) const {
    return SubmitCallable(&SecurityHubClient::StartConfigurationPolicyAssociation, request);
  }
 
  template <typename StartConfigurationPolicyAssociationRequestT = Model::StartConfigurationPolicyAssociationRequest>
  void StartConfigurationPolicyAssociationAsync(const StartConfigurationPolicyAssociationRequestT& request,
                                                const StartConfigurationPolicyAssociationResponseReceivedHandler& handler,
                                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityHubClient::StartConfigurationPolicyAssociation, request, handler, context);
  }
 
  virtual Model::StartConfigurationPolicyDisassociationOutcome StartConfigurationPolicyDisassociation(
      const Model::StartConfigurationPolicyDisassociationRequest& request) const;
 
  template <typename StartConfigurationPolicyDisassociationRequestT = Model::StartConfigurationPolicyDisassociationRequest>
  Model::StartConfigurationPolicyDisassociationOutcomeCallable StartConfigurationPolicyDisassociationCallable(
      const StartConfigurationPolicyDisassociationRequestT& request) const {
    return SubmitCallable(&SecurityHubClient::StartConfigurationPolicyDisassociation, request);
  }
 
  template <typename StartConfigurationPolicyDisassociationRequestT = Model::StartConfigurationPolicyDisassociationRequest>
  void StartConfigurationPolicyDisassociationAsync(const StartConfigurationPolicyDisassociationRequestT& request,
                                                   const StartConfigurationPolicyDisassociationResponseReceivedHandler& handler,
                                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityHubClient::StartConfigurationPolicyDisassociation, 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(&SecurityHubClient::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(&SecurityHubClient::TagResource, request, handler, context);
  }
 
  virtual Model::UntagResourceOutcome UntagResource(const Model::UntagResourceRequest& request) const;
 
  template <typename UntagResourceRequestT = Model::UntagResourceRequest>
  Model::UntagResourceOutcomeCallable UntagResourceCallable(const UntagResourceRequestT& request) const {
    return SubmitCallable(&SecurityHubClient::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(&SecurityHubClient::UntagResource, request, handler, context);
  }
 
  virtual Model::UpdateActionTargetOutcome UpdateActionTarget(const Model::UpdateActionTargetRequest& request) const;
 
  template <typename UpdateActionTargetRequestT = Model::UpdateActionTargetRequest>
  Model::UpdateActionTargetOutcomeCallable UpdateActionTargetCallable(const UpdateActionTargetRequestT& request) const {
    return SubmitCallable(&SecurityHubClient::UpdateActionTarget, request);
  }
 
  template <typename UpdateActionTargetRequestT = Model::UpdateActionTargetRequest>
  void UpdateActionTargetAsync(const UpdateActionTargetRequestT& request, const UpdateActionTargetResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityHubClient::UpdateActionTarget, request, handler, context);
  }
 
  virtual Model::UpdateAggregatorV2Outcome UpdateAggregatorV2(const Model::UpdateAggregatorV2Request& request) const;
 
  template <typename UpdateAggregatorV2RequestT = Model::UpdateAggregatorV2Request>
  Model::UpdateAggregatorV2OutcomeCallable UpdateAggregatorV2Callable(const UpdateAggregatorV2RequestT& request) const {
    return SubmitCallable(&SecurityHubClient::UpdateAggregatorV2, request);
  }
 
  template <typename UpdateAggregatorV2RequestT = Model::UpdateAggregatorV2Request>
  void UpdateAggregatorV2Async(const UpdateAggregatorV2RequestT& request, const UpdateAggregatorV2ResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityHubClient::UpdateAggregatorV2, request, handler, context);
  }
 
  virtual Model::UpdateAutomationRuleV2Outcome UpdateAutomationRuleV2(const Model::UpdateAutomationRuleV2Request& request) const;
 
  template <typename UpdateAutomationRuleV2RequestT = Model::UpdateAutomationRuleV2Request>
  Model::UpdateAutomationRuleV2OutcomeCallable UpdateAutomationRuleV2Callable(const UpdateAutomationRuleV2RequestT& request) const {
    return SubmitCallable(&SecurityHubClient::UpdateAutomationRuleV2, request);
  }
 
  template <typename UpdateAutomationRuleV2RequestT = Model::UpdateAutomationRuleV2Request>
  void UpdateAutomationRuleV2Async(const UpdateAutomationRuleV2RequestT& request,
                                   const UpdateAutomationRuleV2ResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityHubClient::UpdateAutomationRuleV2, request, handler, context);
  }
 
  virtual Model::UpdateConfigurationPolicyOutcome UpdateConfigurationPolicy(const Model::UpdateConfigurationPolicyRequest& request) const;
 
  template <typename UpdateConfigurationPolicyRequestT = Model::UpdateConfigurationPolicyRequest>
  Model::UpdateConfigurationPolicyOutcomeCallable UpdateConfigurationPolicyCallable(
      const UpdateConfigurationPolicyRequestT& request) const {
    return SubmitCallable(&SecurityHubClient::UpdateConfigurationPolicy, request);
  }
 
  template <typename UpdateConfigurationPolicyRequestT = Model::UpdateConfigurationPolicyRequest>
  void UpdateConfigurationPolicyAsync(const UpdateConfigurationPolicyRequestT& request,
                                      const UpdateConfigurationPolicyResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityHubClient::UpdateConfigurationPolicy, request, handler, context);
  }
 
  virtual Model::UpdateConnectorOutcome UpdateConnector(const Model::UpdateConnectorRequest& request) const;
 
  template <typename UpdateConnectorRequestT = Model::UpdateConnectorRequest>
  Model::UpdateConnectorOutcomeCallable UpdateConnectorCallable(const UpdateConnectorRequestT& request) const {
    return SubmitCallable(&SecurityHubClient::UpdateConnector, request);
  }
 
  template <typename UpdateConnectorRequestT = Model::UpdateConnectorRequest>
  void UpdateConnectorAsync(const UpdateConnectorRequestT& request, const UpdateConnectorResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityHubClient::UpdateConnector, request, handler, context);
  }
 
  virtual Model::UpdateConnectorV2Outcome UpdateConnectorV2(const Model::UpdateConnectorV2Request& request) const;
 
  template <typename UpdateConnectorV2RequestT = Model::UpdateConnectorV2Request>
  Model::UpdateConnectorV2OutcomeCallable UpdateConnectorV2Callable(const UpdateConnectorV2RequestT& request) const {
    return SubmitCallable(&SecurityHubClient::UpdateConnectorV2, request);
  }
 
  template <typename UpdateConnectorV2RequestT = Model::UpdateConnectorV2Request>
  void UpdateConnectorV2Async(const UpdateConnectorV2RequestT& request, const UpdateConnectorV2ResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityHubClient::UpdateConnectorV2, request, handler, context);
  }
 
  virtual Model::UpdateFindingAggregatorOutcome UpdateFindingAggregator(const Model::UpdateFindingAggregatorRequest& request) const;
 
  template <typename UpdateFindingAggregatorRequestT = Model::UpdateFindingAggregatorRequest>
  Model::UpdateFindingAggregatorOutcomeCallable UpdateFindingAggregatorCallable(const UpdateFindingAggregatorRequestT& request) const {
    return SubmitCallable(&SecurityHubClient::UpdateFindingAggregator, request);
  }
 
  template <typename UpdateFindingAggregatorRequestT = Model::UpdateFindingAggregatorRequest>
  void UpdateFindingAggregatorAsync(const UpdateFindingAggregatorRequestT& request,
                                    const UpdateFindingAggregatorResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityHubClient::UpdateFindingAggregator, request, handler, context);
  }
 
  virtual Model::UpdateFindingsOutcome UpdateFindings(const Model::UpdateFindingsRequest& request) const;
 
  template <typename UpdateFindingsRequestT = Model::UpdateFindingsRequest>
  Model::UpdateFindingsOutcomeCallable UpdateFindingsCallable(const UpdateFindingsRequestT& request) const {
    return SubmitCallable(&SecurityHubClient::UpdateFindings, request);
  }
 
  template <typename UpdateFindingsRequestT = Model::UpdateFindingsRequest>
  void UpdateFindingsAsync(const UpdateFindingsRequestT& request, const UpdateFindingsResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityHubClient::UpdateFindings, request, handler, context);
  }
 
  virtual Model::UpdateInsightOutcome UpdateInsight(const Model::UpdateInsightRequest& request) const;
 
  template <typename UpdateInsightRequestT = Model::UpdateInsightRequest>
  Model::UpdateInsightOutcomeCallable UpdateInsightCallable(const UpdateInsightRequestT& request) const {
    return SubmitCallable(&SecurityHubClient::UpdateInsight, request);
  }
 
  template <typename UpdateInsightRequestT = Model::UpdateInsightRequest>
  void UpdateInsightAsync(const UpdateInsightRequestT& request, const UpdateInsightResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityHubClient::UpdateInsight, 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(&SecurityHubClient::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(&SecurityHubClient::UpdateOrganizationConfiguration, request, handler, context);
  }
 
  virtual Model::UpdateSecurityControlOutcome UpdateSecurityControl(const Model::UpdateSecurityControlRequest& request) const;
 
  template <typename UpdateSecurityControlRequestT = Model::UpdateSecurityControlRequest>
  Model::UpdateSecurityControlOutcomeCallable UpdateSecurityControlCallable(const UpdateSecurityControlRequestT& request) const {
    return SubmitCallable(&SecurityHubClient::UpdateSecurityControl, request);
  }
 
  template <typename UpdateSecurityControlRequestT = Model::UpdateSecurityControlRequest>
  void UpdateSecurityControlAsync(const UpdateSecurityControlRequestT& request, const UpdateSecurityControlResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityHubClient::UpdateSecurityControl, request, handler, context);
  }
 
  virtual Model::UpdateSecurityHubConfigurationOutcome UpdateSecurityHubConfiguration(
      const Model::UpdateSecurityHubConfigurationRequest& request = {}) const;
 
  template <typename UpdateSecurityHubConfigurationRequestT = Model::UpdateSecurityHubConfigurationRequest>
  Model::UpdateSecurityHubConfigurationOutcomeCallable UpdateSecurityHubConfigurationCallable(
      const UpdateSecurityHubConfigurationRequestT& request = {}) const {
    return SubmitCallable(&SecurityHubClient::UpdateSecurityHubConfiguration, request);
  }
 
  template <typename UpdateSecurityHubConfigurationRequestT = Model::UpdateSecurityHubConfigurationRequest>
  void UpdateSecurityHubConfigurationAsync(const UpdateSecurityHubConfigurationResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                           const UpdateSecurityHubConfigurationRequestT& request = {}) const {
    return SubmitAsync(&SecurityHubClient::UpdateSecurityHubConfiguration, request, handler, context);
  }
 
  virtual Model::UpdateStandardsControlOutcome UpdateStandardsControl(const Model::UpdateStandardsControlRequest& request) const;
 
  template <typename UpdateStandardsControlRequestT = Model::UpdateStandardsControlRequest>
  Model::UpdateStandardsControlOutcomeCallable UpdateStandardsControlCallable(const UpdateStandardsControlRequestT& request) const {
    return SubmitCallable(&SecurityHubClient::UpdateStandardsControl, request);
  }
 
  template <typename UpdateStandardsControlRequestT = Model::UpdateStandardsControlRequest>
  void UpdateStandardsControlAsync(const UpdateStandardsControlRequestT& request,
                                   const UpdateStandardsControlResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityHubClient::UpdateStandardsControl, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<SecurityHubEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<SecurityHubClient>;
  void init(const SecurityHubClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, SecurityHubError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request,
                                                const std::function<void(Aws::Endpoint::ResolveEndpointOutcome&)>& resolveUri,
                                                Aws::Http::HttpMethod httpMethod) const;
 
  SecurityHubClientConfiguration m_clientConfiguration;
  std::shared_ptr<SecurityHubEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace SecurityHub
}  // namespace Aws