SecurityHubClient.h

 
#pragma once
#include <aws/securityhub/SecurityHub_EXPORTS.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/securityhub/SecurityHubServiceClientModel.h>
 
namespace Aws
{
namespace SecurityHub
{
  class AWS_SECURITYHUB_API SecurityHubClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<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::ConnectorRegistrationsV2Outcome ConnectorRegistrationsV2(const Model::ConnectorRegistrationsV2Request& request) const;
 
        template<typename ConnectorRegistrationsV2RequestT = Model::ConnectorRegistrationsV2Request>
        Model::ConnectorRegistrationsV2OutcomeCallable ConnectorRegistrationsV2Callable(const ConnectorRegistrationsV2RequestT& request) const
        {
            return SubmitCallable(&SecurityHubClient::ConnectorRegistrationsV2, request);
        }
 
        template<typename ConnectorRegistrationsV2RequestT = Model::ConnectorRegistrationsV2Request>
        void ConnectorRegistrationsV2Async(const ConnectorRegistrationsV2RequestT& request, const ConnectorRegistrationsV2ResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SecurityHubClient::ConnectorRegistrationsV2, 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::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::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::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::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::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::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::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::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::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::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::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::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);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<SecurityHubEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<SecurityHubClient>;
      void init(const SecurityHubClientConfiguration& clientConfiguration);
 
      SecurityHubClientConfiguration m_clientConfiguration;
      std::shared_ptr<SecurityHubEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace SecurityHub
} // namespace Aws