/** * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. * SPDX-License-Identifier: Apache-2.0. */ #pragma once #include #include #include #include #include #include namespace Aws { namespace SecurityHub { /** *

Security Hub provides you with a comprehensive view of the security state of * your Amazon Web Services environment and resources. It also provides you with * the readiness status of your environment based on controls from supported * security standards. Security Hub collects security data from Amazon Web Services * accounts, services, and integrated third-party products and helps you analyze * security trends in your environment to identify the highest priority security * issues. For more information about Security Hub, see the Security * HubUser Guide.

When you use operations in the Security Hub API, the * requests are executed only in the Amazon Web Services Region that is currently * active or in the specific Amazon Web Services Region that you specify in your * request. Any configuration or settings change that results from the operation is * applied only to that Region. To make the same change in other Regions, run the * same command for each Region in which you want to apply the change.

For * example, if your Region is set to us-west-2, when you use * CreateMembers to add a member account to Security Hub, the * association of the member account with the administrator account is created only * in the us-west-2 Region. Security Hub must be enabled for the * member account in the same Region that the invitation was sent from.

The * following throttling limits apply to using Security Hub API operations.

    *

  • BatchEnableStandards - RateLimit of 1 request * per second. BurstLimit of 1 request per second.

  • * GetFindings - RateLimit of 3 requests per second. * BurstLimit of 6 requests per second.

  • * BatchImportFindings - RateLimit of 10 requests per * second. BurstLimit of 30 requests per second.

  • * BatchUpdateFindings - RateLimit of 10 requests per * second. BurstLimit of 30 requests per second.

  • * UpdateStandardsControl - RateLimit of 1 request per * second. BurstLimit of 5 requests per second.

  • All * other operations - RateLimit of 10 requests per second. * BurstLimit of 30 requests per second.

*/ class AWS_SECURITYHUB_API SecurityHubClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* SERVICE_NAME; static const char* ALLOCATION_TAG; typedef SecurityHubClientConfiguration ClientConfigurationType; typedef SecurityHubEndpointProvider EndpointProviderType; /** * Initializes client to use DefaultCredentialProviderChain, with default http client factory, and optional client config. If client config * is not specified, it will be initialized to default values. */ SecurityHubClient(const Aws::SecurityHub::SecurityHubClientConfiguration& clientConfiguration = Aws::SecurityHub::SecurityHubClientConfiguration(), std::shared_ptr endpointProvider = Aws::MakeShared(ALLOCATION_TAG)); /** * Initializes client to use SimpleAWSCredentialsProvider, with default http client factory, and optional client config. If client config * is not specified, it will be initialized to default values. */ SecurityHubClient(const Aws::Auth::AWSCredentials& credentials, std::shared_ptr endpointProvider = Aws::MakeShared(ALLOCATION_TAG), const Aws::SecurityHub::SecurityHubClientConfiguration& clientConfiguration = Aws::SecurityHub::SecurityHubClientConfiguration()); /** * Initializes client to use specified credentials provider with specified client config. If http client factory is not supplied, * the default http client factory will be used */ SecurityHubClient(const std::shared_ptr& credentialsProvider, std::shared_ptr endpointProvider = Aws::MakeShared(ALLOCATION_TAG), const Aws::SecurityHub::SecurityHubClientConfiguration& clientConfiguration = Aws::SecurityHub::SecurityHubClientConfiguration()); /* Legacy constructors due deprecation */ /** * Initializes client to use DefaultCredentialProviderChain, with default http client factory, and optional client config. If client config * is not specified, it will be initialized to default values. */ SecurityHubClient(const Aws::Client::ClientConfiguration& clientConfiguration); /** * Initializes client to use SimpleAWSCredentialsProvider, with default http client factory, and optional client config. If client config * is not specified, it will be initialized to default values. */ SecurityHubClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration); /** * Initializes client to use specified credentials provider with specified client config. If http client factory is not supplied, * the default http client factory will be used */ SecurityHubClient(const std::shared_ptr& credentialsProvider, const Aws::Client::ClientConfiguration& clientConfiguration); /* End of legacy constructors due deprecation */ virtual ~SecurityHubClient(); /** *

Accepts the invitation to be a member account and be monitored by the * Security Hub administrator account that the invitation was sent from.

*

This operation is only used by member accounts that are not added through * Organizations.

When the member account accepts the invitation, permission * is granted to the administrator account to view findings generated in the member * account.

See Also:

AWS * API Reference

*/ virtual Model::AcceptAdministratorInvitationOutcome AcceptAdministratorInvitation(const Model::AcceptAdministratorInvitationRequest& request) const; /** * A Callable wrapper for AcceptAdministratorInvitation that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::AcceptAdministratorInvitationOutcomeCallable AcceptAdministratorInvitationCallable(const AcceptAdministratorInvitationRequestT& request) const { return SubmitCallable(&SecurityHubClient::AcceptAdministratorInvitation, request); } /** * An Async wrapper for AcceptAdministratorInvitation that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void AcceptAdministratorInvitationAsync(const AcceptAdministratorInvitationRequestT& request, const AcceptAdministratorInvitationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SecurityHubClient::AcceptAdministratorInvitation, request, handler, context); } /** *

Deletes one or more automation rules.

See Also:

AWS * API Reference

*/ virtual Model::BatchDeleteAutomationRulesOutcome BatchDeleteAutomationRules(const Model::BatchDeleteAutomationRulesRequest& request) const; /** * A Callable wrapper for BatchDeleteAutomationRules that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::BatchDeleteAutomationRulesOutcomeCallable BatchDeleteAutomationRulesCallable(const BatchDeleteAutomationRulesRequestT& request) const { return SubmitCallable(&SecurityHubClient::BatchDeleteAutomationRules, request); } /** * An Async wrapper for BatchDeleteAutomationRules that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void BatchDeleteAutomationRulesAsync(const BatchDeleteAutomationRulesRequestT& request, const BatchDeleteAutomationRulesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SecurityHubClient::BatchDeleteAutomationRules, request, handler, context); } /** *

Disables the standards specified by the provided * StandardsSubscriptionArns.

For more information, see Security * Standards section of the Security Hub User Guide.

See * Also:

AWS * API Reference

*/ virtual Model::BatchDisableStandardsOutcome BatchDisableStandards(const Model::BatchDisableStandardsRequest& request) const; /** * A Callable wrapper for BatchDisableStandards that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::BatchDisableStandardsOutcomeCallable BatchDisableStandardsCallable(const BatchDisableStandardsRequestT& request) const { return SubmitCallable(&SecurityHubClient::BatchDisableStandards, request); } /** * An Async wrapper for BatchDisableStandards that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void BatchDisableStandardsAsync(const BatchDisableStandardsRequestT& request, const BatchDisableStandardsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SecurityHubClient::BatchDisableStandards, request, handler, context); } /** *

Enables the standards specified by the provided StandardsArn. To * obtain the ARN for a standard, use the DescribeStandards * operation.

For more information, see the Security * Standards section of the Security Hub User Guide.

See * Also:

AWS * API Reference

*/ virtual Model::BatchEnableStandardsOutcome BatchEnableStandards(const Model::BatchEnableStandardsRequest& request) const; /** * A Callable wrapper for BatchEnableStandards that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::BatchEnableStandardsOutcomeCallable BatchEnableStandardsCallable(const BatchEnableStandardsRequestT& request) const { return SubmitCallable(&SecurityHubClient::BatchEnableStandards, request); } /** * An Async wrapper for BatchEnableStandards that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void BatchEnableStandardsAsync(const BatchEnableStandardsRequestT& request, const BatchEnableStandardsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SecurityHubClient::BatchEnableStandards, request, handler, context); } /** *

Retrieves a list of details for automation rules based on rule Amazon * Resource Names (ARNs).

See Also:

AWS * API Reference

*/ virtual Model::BatchGetAutomationRulesOutcome BatchGetAutomationRules(const Model::BatchGetAutomationRulesRequest& request) const; /** * A Callable wrapper for BatchGetAutomationRules that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::BatchGetAutomationRulesOutcomeCallable BatchGetAutomationRulesCallable(const BatchGetAutomationRulesRequestT& request) const { return SubmitCallable(&SecurityHubClient::BatchGetAutomationRules, request); } /** * An Async wrapper for BatchGetAutomationRules that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void BatchGetAutomationRulesAsync(const BatchGetAutomationRulesRequestT& request, const BatchGetAutomationRulesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SecurityHubClient::BatchGetAutomationRules, request, handler, context); } /** *

Provides details about a batch of security controls for the current Amazon * Web Services account and Amazon Web Services Region.

See Also:

* AWS * API Reference

*/ virtual Model::BatchGetSecurityControlsOutcome BatchGetSecurityControls(const Model::BatchGetSecurityControlsRequest& request) const; /** * A Callable wrapper for BatchGetSecurityControls that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::BatchGetSecurityControlsOutcomeCallable BatchGetSecurityControlsCallable(const BatchGetSecurityControlsRequestT& request) const { return SubmitCallable(&SecurityHubClient::BatchGetSecurityControls, request); } /** * An Async wrapper for BatchGetSecurityControls that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void BatchGetSecurityControlsAsync(const BatchGetSecurityControlsRequestT& request, const BatchGetSecurityControlsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SecurityHubClient::BatchGetSecurityControls, request, handler, context); } /** *

For a batch of security controls and standards, identifies whether each * control is currently enabled or disabled in a standard.

See * Also:

AWS * API Reference

*/ virtual Model::BatchGetStandardsControlAssociationsOutcome BatchGetStandardsControlAssociations(const Model::BatchGetStandardsControlAssociationsRequest& request) const; /** * A Callable wrapper for BatchGetStandardsControlAssociations that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::BatchGetStandardsControlAssociationsOutcomeCallable BatchGetStandardsControlAssociationsCallable(const BatchGetStandardsControlAssociationsRequestT& request) const { return SubmitCallable(&SecurityHubClient::BatchGetStandardsControlAssociations, request); } /** * An Async wrapper for BatchGetStandardsControlAssociations that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void BatchGetStandardsControlAssociationsAsync(const BatchGetStandardsControlAssociationsRequestT& request, const BatchGetStandardsControlAssociationsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SecurityHubClient::BatchGetStandardsControlAssociations, request, handler, context); } /** *

Imports security findings generated by a finding provider into Security Hub. * This action is requested by the finding provider to import its findings into * Security Hub.

BatchImportFindings must be called by one of * the following:

  • The Amazon Web Services account that is * associated with a finding if you are using the default * product ARN or are a partner sending findings from within a customer's * Amazon Web Services account. In these cases, the identifier of the account that * you are calling BatchImportFindings from needs to be the same as * the AwsAccountId attribute for the finding.

  • An * Amazon Web Services account that Security Hub has allow-listed for an official * partner integration. In this case, you can call BatchImportFindings * from the allow-listed account and send findings from different customer accounts * in the same batch.

The maximum allowed size for a finding is * 240 Kb. An error is returned for any finding larger than 240 Kb.

After a * finding is created, BatchImportFindings cannot be used to update * the following finding fields and objects, which Security Hub customers use to * manage their investigation workflow.

  • Note

    *

  • UserDefinedFields

  • * VerificationState

  • Workflow

    *

Finding providers also should not use * BatchImportFindings to update the following attributes.

    *

  • Confidence

  • Criticality *

  • RelatedFindings

  • * Severity

  • Types

*

Instead, finding providers use FindingProviderFields to provide * values for these attributes.

See Also:

AWS * API Reference

*/ virtual Model::BatchImportFindingsOutcome BatchImportFindings(const Model::BatchImportFindingsRequest& request) const; /** * A Callable wrapper for BatchImportFindings that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::BatchImportFindingsOutcomeCallable BatchImportFindingsCallable(const BatchImportFindingsRequestT& request) const { return SubmitCallable(&SecurityHubClient::BatchImportFindings, request); } /** * An Async wrapper for BatchImportFindings that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void BatchImportFindingsAsync(const BatchImportFindingsRequestT& request, const BatchImportFindingsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SecurityHubClient::BatchImportFindings, request, handler, context); } /** *

Updates one or more automation rules based on rule Amazon Resource Names * (ARNs) and input parameters.

See Also:

AWS * API Reference

*/ virtual Model::BatchUpdateAutomationRulesOutcome BatchUpdateAutomationRules(const Model::BatchUpdateAutomationRulesRequest& request) const; /** * A Callable wrapper for BatchUpdateAutomationRules that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::BatchUpdateAutomationRulesOutcomeCallable BatchUpdateAutomationRulesCallable(const BatchUpdateAutomationRulesRequestT& request) const { return SubmitCallable(&SecurityHubClient::BatchUpdateAutomationRules, request); } /** * An Async wrapper for BatchUpdateAutomationRules that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void BatchUpdateAutomationRulesAsync(const BatchUpdateAutomationRulesRequestT& request, const BatchUpdateAutomationRulesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SecurityHubClient::BatchUpdateAutomationRules, request, handler, context); } /** *

Used by Security Hub customers to update information about their * investigation into a finding. Requested by administrator accounts or member * accounts. Administrator accounts can update findings for their account and their * member accounts. Member accounts can update findings for their account.

*

Updates from BatchUpdateFindings do not affect the value of * UpdatedAt for a finding.

Administrator and member accounts * can use BatchUpdateFindings to update the following finding fields * and objects.

  • Confidence

  • * Criticality

  • Note

  • *

    RelatedFindings

  • Severity

    *

  • Types

  • * UserDefinedFields

  • * VerificationState

  • Workflow

    *

You can configure IAM policies to restrict access to fields and * field values. For example, you might not want member accounts to be able to * suppress findings or change the finding severity. See Configuring * access to BatchUpdateFindings in the Security Hub User * Guide.

See Also:

AWS * API Reference

*/ virtual Model::BatchUpdateFindingsOutcome BatchUpdateFindings(const Model::BatchUpdateFindingsRequest& request) const; /** * A Callable wrapper for BatchUpdateFindings that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::BatchUpdateFindingsOutcomeCallable BatchUpdateFindingsCallable(const BatchUpdateFindingsRequestT& request) const { return SubmitCallable(&SecurityHubClient::BatchUpdateFindings, request); } /** * An Async wrapper for BatchUpdateFindings that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void BatchUpdateFindingsAsync(const BatchUpdateFindingsRequestT& request, const BatchUpdateFindingsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SecurityHubClient::BatchUpdateFindings, request, handler, context); } /** *

For a batch of security controls and standards, this operation updates the * enablement status of a control in a standard.

See Also:

AWS * API Reference

*/ virtual Model::BatchUpdateStandardsControlAssociationsOutcome BatchUpdateStandardsControlAssociations(const Model::BatchUpdateStandardsControlAssociationsRequest& request) const; /** * A Callable wrapper for BatchUpdateStandardsControlAssociations that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::BatchUpdateStandardsControlAssociationsOutcomeCallable BatchUpdateStandardsControlAssociationsCallable(const BatchUpdateStandardsControlAssociationsRequestT& request) const { return SubmitCallable(&SecurityHubClient::BatchUpdateStandardsControlAssociations, request); } /** * An Async wrapper for BatchUpdateStandardsControlAssociations that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void BatchUpdateStandardsControlAssociationsAsync(const BatchUpdateStandardsControlAssociationsRequestT& request, const BatchUpdateStandardsControlAssociationsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SecurityHubClient::BatchUpdateStandardsControlAssociations, request, handler, context); } /** *

Creates a custom action target in Security Hub.

You can use custom * actions on findings and insights in Security Hub to trigger target actions in * Amazon CloudWatch Events.

See Also:

AWS * API Reference

*/ virtual Model::CreateActionTargetOutcome CreateActionTarget(const Model::CreateActionTargetRequest& request) const; /** * A Callable wrapper for CreateActionTarget that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateActionTargetOutcomeCallable CreateActionTargetCallable(const CreateActionTargetRequestT& request) const { return SubmitCallable(&SecurityHubClient::CreateActionTarget, request); } /** * An Async wrapper for CreateActionTarget that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateActionTargetAsync(const CreateActionTargetRequestT& request, const CreateActionTargetResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SecurityHubClient::CreateActionTarget, request, handler, context); } /** *

Creates an automation rule based on input parameters.

See * Also:

AWS * API Reference

*/ virtual Model::CreateAutomationRuleOutcome CreateAutomationRule(const Model::CreateAutomationRuleRequest& request) const; /** * A Callable wrapper for CreateAutomationRule that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateAutomationRuleOutcomeCallable CreateAutomationRuleCallable(const CreateAutomationRuleRequestT& request) const { return SubmitCallable(&SecurityHubClient::CreateAutomationRule, request); } /** * An Async wrapper for CreateAutomationRule that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateAutomationRuleAsync(const CreateAutomationRuleRequestT& request, const CreateAutomationRuleResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SecurityHubClient::CreateAutomationRule, request, handler, context); } /** *

Used to enable finding aggregation. Must be called from the aggregation * Region.

For more details about cross-Region replication, see Configuring * finding aggregation in the Security Hub User Guide.

See * Also:

AWS * API Reference

*/ virtual Model::CreateFindingAggregatorOutcome CreateFindingAggregator(const Model::CreateFindingAggregatorRequest& request) const; /** * A Callable wrapper for CreateFindingAggregator that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateFindingAggregatorOutcomeCallable CreateFindingAggregatorCallable(const CreateFindingAggregatorRequestT& request) const { return SubmitCallable(&SecurityHubClient::CreateFindingAggregator, request); } /** * An Async wrapper for CreateFindingAggregator that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateFindingAggregatorAsync(const CreateFindingAggregatorRequestT& request, const CreateFindingAggregatorResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SecurityHubClient::CreateFindingAggregator, request, handler, context); } /** *

Creates a custom insight in Security Hub. An insight is a consolidation of * findings that relate to a security issue that requires attention or * remediation.

To group the related findings in the insight, use the * GroupByAttribute.

See Also:

AWS * API Reference

*/ virtual Model::CreateInsightOutcome CreateInsight(const Model::CreateInsightRequest& request) const; /** * A Callable wrapper for CreateInsight that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateInsightOutcomeCallable CreateInsightCallable(const CreateInsightRequestT& request) const { return SubmitCallable(&SecurityHubClient::CreateInsight, request); } /** * An Async wrapper for CreateInsight that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateInsightAsync(const CreateInsightRequestT& request, const CreateInsightResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SecurityHubClient::CreateInsight, request, handler, context); } /** *

Creates a member association in Security Hub between the specified accounts * and the account used to make the request, which is the administrator account. If * you are integrated with Organizations, then the administrator account is * designated by the organization management account.

* CreateMembers is always used to add accounts that are not * organization members.

For accounts that are managed using Organizations, * CreateMembers is only used in the following cases:

  • *

    Security Hub is not configured to automatically add new organization * accounts.

  • The account was disassociated or deleted in Security * Hub.

This action can only be used by an account that has * Security Hub enabled. To enable Security Hub, you can use the * EnableSecurityHub operation.

For accounts that are not * organization members, you create the account association and then send an * invitation to the member account. To send the invitation, you use the * InviteMembers operation. If the account owner accepts the * invitation, the account becomes a member account in Security Hub.

*

Accounts that are managed using Organizations do not receive an invitation. * They automatically become a member account in Security Hub.

  • If * the organization account does not have Security Hub enabled, then Security Hub * and the default standards are automatically enabled. Note that Security Hub * cannot be enabled automatically for the organization management account. The * organization management account must enable Security Hub before the * administrator account enables it as a member account.

  • For * organization accounts that already have Security Hub enabled, Security Hub does * not make any other changes to those accounts. It does not change their enabled * standards or controls.

A permissions policy is added that * permits the administrator account to view the findings generated in the member * account.

To remove the association between the administrator and member * accounts, use the DisassociateFromMasterAccount or * DisassociateMembers operation.

See Also:

AWS * API Reference

*/ virtual Model::CreateMembersOutcome CreateMembers(const Model::CreateMembersRequest& request) const; /** * A Callable wrapper for CreateMembers that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateMembersOutcomeCallable CreateMembersCallable(const CreateMembersRequestT& request) const { return SubmitCallable(&SecurityHubClient::CreateMembers, request); } /** * An Async wrapper for CreateMembers that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateMembersAsync(const CreateMembersRequestT& request, const CreateMembersResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SecurityHubClient::CreateMembers, request, handler, context); } /** *

Declines invitations to become a member account.

A prospective member * account uses this operation to decline an invitation to become a member.

*

This operation is only called by member accounts that aren't part of an * organization. Organization accounts don't receive invitations.

See * Also:

AWS * API Reference

*/ virtual Model::DeclineInvitationsOutcome DeclineInvitations(const Model::DeclineInvitationsRequest& request) const; /** * A Callable wrapper for DeclineInvitations that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeclineInvitationsOutcomeCallable DeclineInvitationsCallable(const DeclineInvitationsRequestT& request) const { return SubmitCallable(&SecurityHubClient::DeclineInvitations, request); } /** * An Async wrapper for DeclineInvitations that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeclineInvitationsAsync(const DeclineInvitationsRequestT& request, const DeclineInvitationsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SecurityHubClient::DeclineInvitations, request, handler, context); } /** *

Deletes a custom action target from Security Hub.

Deleting a custom * action target does not affect any findings or insights that were already sent to * Amazon CloudWatch Events using the custom action.

See Also:

AWS * API Reference

*/ virtual Model::DeleteActionTargetOutcome DeleteActionTarget(const Model::DeleteActionTargetRequest& request) const; /** * A Callable wrapper for DeleteActionTarget that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteActionTargetOutcomeCallable DeleteActionTargetCallable(const DeleteActionTargetRequestT& request) const { return SubmitCallable(&SecurityHubClient::DeleteActionTarget, request); } /** * An Async wrapper for DeleteActionTarget that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteActionTargetAsync(const DeleteActionTargetRequestT& request, const DeleteActionTargetResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SecurityHubClient::DeleteActionTarget, request, handler, context); } /** *

Deletes a finding aggregator. When you delete the finding aggregator, you * stop finding aggregation.

When you stop finding aggregation, findings * that were already aggregated to the aggregation Region are still visible from * the aggregation Region. New findings and finding updates are not aggregated. *

See Also:

AWS * API Reference

*/ virtual Model::DeleteFindingAggregatorOutcome DeleteFindingAggregator(const Model::DeleteFindingAggregatorRequest& request) const; /** * A Callable wrapper for DeleteFindingAggregator that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteFindingAggregatorOutcomeCallable DeleteFindingAggregatorCallable(const DeleteFindingAggregatorRequestT& request) const { return SubmitCallable(&SecurityHubClient::DeleteFindingAggregator, request); } /** * An Async wrapper for DeleteFindingAggregator that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteFindingAggregatorAsync(const DeleteFindingAggregatorRequestT& request, const DeleteFindingAggregatorResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SecurityHubClient::DeleteFindingAggregator, request, handler, context); } /** *

Deletes the insight specified by the InsightArn.

See * Also:

AWS * API Reference

*/ virtual Model::DeleteInsightOutcome DeleteInsight(const Model::DeleteInsightRequest& request) const; /** * A Callable wrapper for DeleteInsight that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteInsightOutcomeCallable DeleteInsightCallable(const DeleteInsightRequestT& request) const { return SubmitCallable(&SecurityHubClient::DeleteInsight, request); } /** * An Async wrapper for DeleteInsight that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteInsightAsync(const DeleteInsightRequestT& request, const DeleteInsightResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SecurityHubClient::DeleteInsight, request, handler, context); } /** *

Deletes invitations received by the Amazon Web Services account to become a * member account.

A Security Hub administrator account can use this * operation to delete invitations sent to one or more member accounts.

This * operation is only used to delete invitations that are sent to member accounts * that aren't part of an organization. Organization accounts don't receive * invitations.

See Also:

AWS * API Reference

*/ virtual Model::DeleteInvitationsOutcome DeleteInvitations(const Model::DeleteInvitationsRequest& request) const; /** * A Callable wrapper for DeleteInvitations that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteInvitationsOutcomeCallable DeleteInvitationsCallable(const DeleteInvitationsRequestT& request) const { return SubmitCallable(&SecurityHubClient::DeleteInvitations, request); } /** * An Async wrapper for DeleteInvitations that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteInvitationsAsync(const DeleteInvitationsRequestT& request, const DeleteInvitationsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SecurityHubClient::DeleteInvitations, request, handler, context); } /** *

Deletes the specified member accounts from Security Hub.

Can be used * to delete member accounts that belong to an organization as well as member * accounts that were invited manually.

See Also:

AWS * API Reference

*/ virtual Model::DeleteMembersOutcome DeleteMembers(const Model::DeleteMembersRequest& request) const; /** * A Callable wrapper for DeleteMembers that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteMembersOutcomeCallable DeleteMembersCallable(const DeleteMembersRequestT& request) const { return SubmitCallable(&SecurityHubClient::DeleteMembers, request); } /** * An Async wrapper for DeleteMembers that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteMembersAsync(const DeleteMembersRequestT& request, const DeleteMembersResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SecurityHubClient::DeleteMembers, request, handler, context); } /** *

Returns a list of the custom action targets in Security Hub in your * account.

See Also:

AWS * API Reference

*/ virtual Model::DescribeActionTargetsOutcome DescribeActionTargets(const Model::DescribeActionTargetsRequest& request) const; /** * A Callable wrapper for DescribeActionTargets that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeActionTargetsOutcomeCallable DescribeActionTargetsCallable(const DescribeActionTargetsRequestT& request) const { return SubmitCallable(&SecurityHubClient::DescribeActionTargets, request); } /** * An Async wrapper for DescribeActionTargets that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeActionTargetsAsync(const DescribeActionTargetsRequestT& request, const DescribeActionTargetsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SecurityHubClient::DescribeActionTargets, request, handler, context); } /** *

Returns details about the Hub resource in your account, including the * HubArn and the time when you enabled Security Hub.

See * Also:

AWS * API Reference

*/ virtual Model::DescribeHubOutcome DescribeHub(const Model::DescribeHubRequest& request) const; /** * A Callable wrapper for DescribeHub that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeHubOutcomeCallable DescribeHubCallable(const DescribeHubRequestT& request) const { return SubmitCallable(&SecurityHubClient::DescribeHub, request); } /** * An Async wrapper for DescribeHub that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeHubAsync(const DescribeHubRequestT& request, const DescribeHubResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SecurityHubClient::DescribeHub, request, handler, context); } /** *

Returns information about the Organizations configuration for Security Hub. * Can only be called from a Security Hub administrator account.

See * Also:

AWS * API Reference

*/ virtual Model::DescribeOrganizationConfigurationOutcome DescribeOrganizationConfiguration(const Model::DescribeOrganizationConfigurationRequest& request) const; /** * A Callable wrapper for DescribeOrganizationConfiguration that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeOrganizationConfigurationOutcomeCallable DescribeOrganizationConfigurationCallable(const DescribeOrganizationConfigurationRequestT& request) const { return SubmitCallable(&SecurityHubClient::DescribeOrganizationConfiguration, request); } /** * An Async wrapper for DescribeOrganizationConfiguration that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeOrganizationConfigurationAsync(const DescribeOrganizationConfigurationRequestT& request, const DescribeOrganizationConfigurationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SecurityHubClient::DescribeOrganizationConfiguration, request, handler, context); } /** *

Returns information about product integrations in Security Hub.

You * can optionally provide an integration ARN. If you provide an integration ARN, * then the results only include that integration.

If you do not provide an * integration ARN, then the results include all of the available product * integrations.

See Also:

AWS * API Reference

*/ virtual Model::DescribeProductsOutcome DescribeProducts(const Model::DescribeProductsRequest& request) const; /** * A Callable wrapper for DescribeProducts that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeProductsOutcomeCallable DescribeProductsCallable(const DescribeProductsRequestT& request) const { return SubmitCallable(&SecurityHubClient::DescribeProducts, request); } /** * An Async wrapper for DescribeProducts that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeProductsAsync(const DescribeProductsRequestT& request, const DescribeProductsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SecurityHubClient::DescribeProducts, request, handler, context); } /** *

Returns a list of the available standards in Security Hub.

For each * standard, the results include the standard ARN, the name, and a description. *

See Also:

AWS * API Reference

*/ virtual Model::DescribeStandardsOutcome DescribeStandards(const Model::DescribeStandardsRequest& request) const; /** * A Callable wrapper for DescribeStandards that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeStandardsOutcomeCallable DescribeStandardsCallable(const DescribeStandardsRequestT& request) const { return SubmitCallable(&SecurityHubClient::DescribeStandards, request); } /** * An Async wrapper for DescribeStandards that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeStandardsAsync(const DescribeStandardsRequestT& request, const DescribeStandardsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SecurityHubClient::DescribeStandards, request, handler, context); } /** *

Returns a list of security standards controls.

For each control, the * results include information about whether it is currently enabled, the severity, * and a link to remediation information.

See Also:

AWS * API Reference

*/ virtual Model::DescribeStandardsControlsOutcome DescribeStandardsControls(const Model::DescribeStandardsControlsRequest& request) const; /** * A Callable wrapper for DescribeStandardsControls that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeStandardsControlsOutcomeCallable DescribeStandardsControlsCallable(const DescribeStandardsControlsRequestT& request) const { return SubmitCallable(&SecurityHubClient::DescribeStandardsControls, request); } /** * An Async wrapper for DescribeStandardsControls that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeStandardsControlsAsync(const DescribeStandardsControlsRequestT& request, const DescribeStandardsControlsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SecurityHubClient::DescribeStandardsControls, request, handler, context); } /** *

Disables the integration of the specified product with Security Hub. After * the integration is disabled, findings from that product are no longer sent to * Security Hub.

See Also:

AWS * API Reference

*/ virtual Model::DisableImportFindingsForProductOutcome DisableImportFindingsForProduct(const Model::DisableImportFindingsForProductRequest& request) const; /** * A Callable wrapper for DisableImportFindingsForProduct that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DisableImportFindingsForProductOutcomeCallable DisableImportFindingsForProductCallable(const DisableImportFindingsForProductRequestT& request) const { return SubmitCallable(&SecurityHubClient::DisableImportFindingsForProduct, request); } /** * An Async wrapper for DisableImportFindingsForProduct that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DisableImportFindingsForProductAsync(const DisableImportFindingsForProductRequestT& request, const DisableImportFindingsForProductResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SecurityHubClient::DisableImportFindingsForProduct, request, handler, context); } /** *

Disables a Security Hub administrator account. Can only be called by the * organization management account.

See Also:

AWS * API Reference

*/ virtual Model::DisableOrganizationAdminAccountOutcome DisableOrganizationAdminAccount(const Model::DisableOrganizationAdminAccountRequest& request) const; /** * A Callable wrapper for DisableOrganizationAdminAccount that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DisableOrganizationAdminAccountOutcomeCallable DisableOrganizationAdminAccountCallable(const DisableOrganizationAdminAccountRequestT& request) const { return SubmitCallable(&SecurityHubClient::DisableOrganizationAdminAccount, request); } /** * An Async wrapper for DisableOrganizationAdminAccount that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DisableOrganizationAdminAccountAsync(const DisableOrganizationAdminAccountRequestT& request, const DisableOrganizationAdminAccountResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SecurityHubClient::DisableOrganizationAdminAccount, request, handler, context); } /** *

Disables Security Hub in your account only in the current Region. To disable * Security Hub in all Regions, you must submit one request per Region where you * have enabled Security Hub.

When you disable Security Hub for an * administrator account, it doesn't disable Security Hub for any associated member * accounts.

When you disable Security Hub, your existing findings and * insights and any Security Hub configuration settings are deleted after 90 days * and cannot be recovered. Any standards that were enabled are disabled, and your * administrator and member account associations are removed.

If you want to * save your existing findings, you must export them before you disable Security * Hub.

See Also:

AWS * API Reference

*/ virtual Model::DisableSecurityHubOutcome DisableSecurityHub(const Model::DisableSecurityHubRequest& request) const; /** * A Callable wrapper for DisableSecurityHub that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DisableSecurityHubOutcomeCallable DisableSecurityHubCallable(const DisableSecurityHubRequestT& request) const { return SubmitCallable(&SecurityHubClient::DisableSecurityHub, request); } /** * An Async wrapper for DisableSecurityHub that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DisableSecurityHubAsync(const DisableSecurityHubRequestT& request, const DisableSecurityHubResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SecurityHubClient::DisableSecurityHub, request, handler, context); } /** *

Disassociates the current Security Hub member account from the associated * administrator account.

This operation is only used by accounts that are * not part of an organization. For organization accounts, only the administrator * account can disassociate a member account.

See Also:

AWS * API Reference

*/ virtual Model::DisassociateFromAdministratorAccountOutcome DisassociateFromAdministratorAccount(const Model::DisassociateFromAdministratorAccountRequest& request) const; /** * A Callable wrapper for DisassociateFromAdministratorAccount that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DisassociateFromAdministratorAccountOutcomeCallable DisassociateFromAdministratorAccountCallable(const DisassociateFromAdministratorAccountRequestT& request) const { return SubmitCallable(&SecurityHubClient::DisassociateFromAdministratorAccount, request); } /** * An Async wrapper for DisassociateFromAdministratorAccount that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DisassociateFromAdministratorAccountAsync(const DisassociateFromAdministratorAccountRequestT& request, const DisassociateFromAdministratorAccountResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SecurityHubClient::DisassociateFromAdministratorAccount, request, handler, context); } /** *

Disassociates the specified member accounts from the associated administrator * account.

Can be used to disassociate both accounts that are managed using * Organizations and accounts that were invited manually.

See Also:

* AWS * API Reference

*/ virtual Model::DisassociateMembersOutcome DisassociateMembers(const Model::DisassociateMembersRequest& request) const; /** * A Callable wrapper for DisassociateMembers that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DisassociateMembersOutcomeCallable DisassociateMembersCallable(const DisassociateMembersRequestT& request) const { return SubmitCallable(&SecurityHubClient::DisassociateMembers, request); } /** * An Async wrapper for DisassociateMembers that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DisassociateMembersAsync(const DisassociateMembersRequestT& request, const DisassociateMembersResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SecurityHubClient::DisassociateMembers, request, handler, context); } /** *

Enables the integration of a partner product with Security Hub. Integrated * products send findings to Security Hub.

When you enable a product * integration, a permissions policy that grants permission for the product to send * findings to Security Hub is applied.

See Also:

AWS * API Reference

*/ virtual Model::EnableImportFindingsForProductOutcome EnableImportFindingsForProduct(const Model::EnableImportFindingsForProductRequest& request) const; /** * A Callable wrapper for EnableImportFindingsForProduct that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::EnableImportFindingsForProductOutcomeCallable EnableImportFindingsForProductCallable(const EnableImportFindingsForProductRequestT& request) const { return SubmitCallable(&SecurityHubClient::EnableImportFindingsForProduct, request); } /** * An Async wrapper for EnableImportFindingsForProduct that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void EnableImportFindingsForProductAsync(const EnableImportFindingsForProductRequestT& request, const EnableImportFindingsForProductResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SecurityHubClient::EnableImportFindingsForProduct, request, handler, context); } /** *

Designates the Security Hub administrator account for an organization. Can * only be called by the organization management account.

See Also:

* AWS * API Reference

*/ virtual Model::EnableOrganizationAdminAccountOutcome EnableOrganizationAdminAccount(const Model::EnableOrganizationAdminAccountRequest& request) const; /** * A Callable wrapper for EnableOrganizationAdminAccount that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::EnableOrganizationAdminAccountOutcomeCallable EnableOrganizationAdminAccountCallable(const EnableOrganizationAdminAccountRequestT& request) const { return SubmitCallable(&SecurityHubClient::EnableOrganizationAdminAccount, request); } /** * An Async wrapper for EnableOrganizationAdminAccount that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void EnableOrganizationAdminAccountAsync(const EnableOrganizationAdminAccountRequestT& request, const EnableOrganizationAdminAccountResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SecurityHubClient::EnableOrganizationAdminAccount, request, handler, context); } /** *

Enables Security Hub for your account in the current Region or the Region you * specify in the request.

When you enable Security Hub, you grant to * Security Hub the permissions necessary to gather findings from other services * that are integrated with Security Hub.

When you use the * EnableSecurityHub operation to enable Security Hub, you also * automatically enable the following standards:

  • Center for * Internet Security (CIS) Amazon Web Services Foundations Benchmark v1.2.0

    *

  • Amazon Web Services Foundational Security Best Practices

    • *

Other standards are not automatically enabled.

To opt out of * automatically enabled standards, set EnableDefaultStandards to * false.

After you enable Security Hub, to enable a standard, * use the BatchEnableStandards operation. To disable a standard, use * the BatchDisableStandards operation.

To learn more, see the * setup * information in the Security Hub User Guide.

See Also:

* AWS * API Reference

*/ virtual Model::EnableSecurityHubOutcome EnableSecurityHub(const Model::EnableSecurityHubRequest& request) const; /** * A Callable wrapper for EnableSecurityHub that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::EnableSecurityHubOutcomeCallable EnableSecurityHubCallable(const EnableSecurityHubRequestT& request) const { return SubmitCallable(&SecurityHubClient::EnableSecurityHub, request); } /** * An Async wrapper for EnableSecurityHub that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void EnableSecurityHubAsync(const EnableSecurityHubRequestT& request, const EnableSecurityHubResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SecurityHubClient::EnableSecurityHub, request, handler, context); } /** *

Provides the details for the Security Hub administrator account for the * current member account.

Can be used by both member accounts that are * managed using Organizations and accounts that were invited * manually.

See Also:

AWS * API Reference

*/ virtual Model::GetAdministratorAccountOutcome GetAdministratorAccount(const Model::GetAdministratorAccountRequest& request) const; /** * A Callable wrapper for GetAdministratorAccount that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetAdministratorAccountOutcomeCallable GetAdministratorAccountCallable(const GetAdministratorAccountRequestT& request) const { return SubmitCallable(&SecurityHubClient::GetAdministratorAccount, request); } /** * An Async wrapper for GetAdministratorAccount that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetAdministratorAccountAsync(const GetAdministratorAccountRequestT& request, const GetAdministratorAccountResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SecurityHubClient::GetAdministratorAccount, request, handler, context); } /** *

Returns a list of the standards that are currently enabled.

See * Also:

AWS * API Reference

*/ virtual Model::GetEnabledStandardsOutcome GetEnabledStandards(const Model::GetEnabledStandardsRequest& request) const; /** * A Callable wrapper for GetEnabledStandards that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetEnabledStandardsOutcomeCallable GetEnabledStandardsCallable(const GetEnabledStandardsRequestT& request) const { return SubmitCallable(&SecurityHubClient::GetEnabledStandards, request); } /** * An Async wrapper for GetEnabledStandards that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetEnabledStandardsAsync(const GetEnabledStandardsRequestT& request, const GetEnabledStandardsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SecurityHubClient::GetEnabledStandards, request, handler, context); } /** *

Returns the current finding aggregation configuration.

See * Also:

AWS * API Reference

*/ virtual Model::GetFindingAggregatorOutcome GetFindingAggregator(const Model::GetFindingAggregatorRequest& request) const; /** * A Callable wrapper for GetFindingAggregator that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetFindingAggregatorOutcomeCallable GetFindingAggregatorCallable(const GetFindingAggregatorRequestT& request) const { return SubmitCallable(&SecurityHubClient::GetFindingAggregator, request); } /** * An Async wrapper for GetFindingAggregator that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetFindingAggregatorAsync(const GetFindingAggregatorRequestT& request, const GetFindingAggregatorResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SecurityHubClient::GetFindingAggregator, request, handler, context); } /** *

Returns history for a Security Hub finding in the last 90 days. The history * includes changes made to any fields in the Amazon Web Services Security Finding * Format (ASFF).

See Also:

AWS * API Reference

*/ virtual Model::GetFindingHistoryOutcome GetFindingHistory(const Model::GetFindingHistoryRequest& request) const; /** * A Callable wrapper for GetFindingHistory that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetFindingHistoryOutcomeCallable GetFindingHistoryCallable(const GetFindingHistoryRequestT& request) const { return SubmitCallable(&SecurityHubClient::GetFindingHistory, request); } /** * An Async wrapper for GetFindingHistory that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetFindingHistoryAsync(const GetFindingHistoryRequestT& request, const GetFindingHistoryResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SecurityHubClient::GetFindingHistory, request, handler, context); } /** *

Returns a list of findings that match the specified criteria.

If * finding aggregation is enabled, then when you call GetFindings from * the aggregation Region, the results include all of the matching findings from * both the aggregation Region and the linked Regions.

See Also:

* AWS * API Reference

*/ virtual Model::GetFindingsOutcome GetFindings(const Model::GetFindingsRequest& request) const; /** * A Callable wrapper for GetFindings that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetFindingsOutcomeCallable GetFindingsCallable(const GetFindingsRequestT& request) const { return SubmitCallable(&SecurityHubClient::GetFindings, request); } /** * An Async wrapper for GetFindings that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetFindingsAsync(const GetFindingsRequestT& request, const GetFindingsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SecurityHubClient::GetFindings, request, handler, context); } /** *

Lists the results of the Security Hub insight specified by the insight * ARN.

See Also:

AWS * API Reference

*/ virtual Model::GetInsightResultsOutcome GetInsightResults(const Model::GetInsightResultsRequest& request) const; /** * A Callable wrapper for GetInsightResults that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetInsightResultsOutcomeCallable GetInsightResultsCallable(const GetInsightResultsRequestT& request) const { return SubmitCallable(&SecurityHubClient::GetInsightResults, request); } /** * An Async wrapper for GetInsightResults that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetInsightResultsAsync(const GetInsightResultsRequestT& request, const GetInsightResultsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SecurityHubClient::GetInsightResults, request, handler, context); } /** *

Lists and describes insights for the specified insight ARNs.

See * Also:

AWS * API Reference

*/ virtual Model::GetInsightsOutcome GetInsights(const Model::GetInsightsRequest& request) const; /** * A Callable wrapper for GetInsights that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetInsightsOutcomeCallable GetInsightsCallable(const GetInsightsRequestT& request) const { return SubmitCallable(&SecurityHubClient::GetInsights, request); } /** * An Async wrapper for GetInsights that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetInsightsAsync(const GetInsightsRequestT& request, const GetInsightsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SecurityHubClient::GetInsights, request, handler, context); } /** *

Returns the count of all Security Hub membership invitations that were sent * to the current member account, not including the currently accepted invitation. *

See Also:

AWS * API Reference

*/ virtual Model::GetInvitationsCountOutcome GetInvitationsCount(const Model::GetInvitationsCountRequest& request) const; /** * A Callable wrapper for GetInvitationsCount that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetInvitationsCountOutcomeCallable GetInvitationsCountCallable(const GetInvitationsCountRequestT& request) const { return SubmitCallable(&SecurityHubClient::GetInvitationsCount, request); } /** * An Async wrapper for GetInvitationsCount that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetInvitationsCountAsync(const GetInvitationsCountRequestT& request, const GetInvitationsCountResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SecurityHubClient::GetInvitationsCount, request, handler, context); } /** *

Returns the details for the Security Hub member accounts for the specified * account IDs.

An administrator account can be either the delegated * Security Hub administrator account for an organization or an administrator * account that enabled Security Hub manually.

The results include both * member accounts that are managed using Organizations and accounts that were * invited manually.

See Also:

AWS * API Reference

*/ virtual Model::GetMembersOutcome GetMembers(const Model::GetMembersRequest& request) const; /** * A Callable wrapper for GetMembers that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetMembersOutcomeCallable GetMembersCallable(const GetMembersRequestT& request) const { return SubmitCallable(&SecurityHubClient::GetMembers, request); } /** * An Async wrapper for GetMembers that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetMembersAsync(const GetMembersRequestT& request, const GetMembersResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SecurityHubClient::GetMembers, request, handler, context); } /** *

Invites other Amazon Web Services accounts to become member accounts for the * Security Hub administrator account that the invitation is sent from.

This * operation is only used to invite accounts that do not belong to an organization. * Organization accounts do not receive invitations.

Before you can use this * action to invite a member, you must first use the CreateMembers * action to create the member account in Security Hub.

When the account * owner enables Security Hub and accepts the invitation to become a member * account, the administrator account can view the findings generated from the * member account.

See Also:

AWS * API Reference

*/ virtual Model::InviteMembersOutcome InviteMembers(const Model::InviteMembersRequest& request) const; /** * A Callable wrapper for InviteMembers that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::InviteMembersOutcomeCallable InviteMembersCallable(const InviteMembersRequestT& request) const { return SubmitCallable(&SecurityHubClient::InviteMembers, request); } /** * An Async wrapper for InviteMembers that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void InviteMembersAsync(const InviteMembersRequestT& request, const InviteMembersResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SecurityHubClient::InviteMembers, request, handler, context); } /** *

A list of automation rules and their metadata for the calling account. *

See Also:

AWS * API Reference

*/ virtual Model::ListAutomationRulesOutcome ListAutomationRules(const Model::ListAutomationRulesRequest& request) const; /** * A Callable wrapper for ListAutomationRules that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListAutomationRulesOutcomeCallable ListAutomationRulesCallable(const ListAutomationRulesRequestT& request) const { return SubmitCallable(&SecurityHubClient::ListAutomationRules, request); } /** * An Async wrapper for ListAutomationRules that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListAutomationRulesAsync(const ListAutomationRulesRequestT& request, const ListAutomationRulesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SecurityHubClient::ListAutomationRules, request, handler, context); } /** *

Lists all findings-generating solutions (products) that you are subscribed to * receive findings from in Security Hub.

See Also:

AWS * API Reference

*/ virtual Model::ListEnabledProductsForImportOutcome ListEnabledProductsForImport(const Model::ListEnabledProductsForImportRequest& request) const; /** * A Callable wrapper for ListEnabledProductsForImport that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListEnabledProductsForImportOutcomeCallable ListEnabledProductsForImportCallable(const ListEnabledProductsForImportRequestT& request) const { return SubmitCallable(&SecurityHubClient::ListEnabledProductsForImport, request); } /** * An Async wrapper for ListEnabledProductsForImport that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListEnabledProductsForImportAsync(const ListEnabledProductsForImportRequestT& request, const ListEnabledProductsForImportResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SecurityHubClient::ListEnabledProductsForImport, request, handler, context); } /** *

If finding aggregation is enabled, then ListFindingAggregators * returns the ARN of the finding aggregator. You can run this operation from any * Region.

See Also:

AWS * API Reference

*/ virtual Model::ListFindingAggregatorsOutcome ListFindingAggregators(const Model::ListFindingAggregatorsRequest& request) const; /** * A Callable wrapper for ListFindingAggregators that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListFindingAggregatorsOutcomeCallable ListFindingAggregatorsCallable(const ListFindingAggregatorsRequestT& request) const { return SubmitCallable(&SecurityHubClient::ListFindingAggregators, request); } /** * An Async wrapper for ListFindingAggregators that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListFindingAggregatorsAsync(const ListFindingAggregatorsRequestT& request, const ListFindingAggregatorsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SecurityHubClient::ListFindingAggregators, request, handler, context); } /** *

Lists all Security Hub membership invitations that were sent to the current * Amazon Web Services account.

This operation is only used by accounts that * are managed by invitation. Accounts that are managed using the integration with * Organizations do not receive invitations.

See Also:

AWS * API Reference

*/ virtual Model::ListInvitationsOutcome ListInvitations(const Model::ListInvitationsRequest& request) const; /** * A Callable wrapper for ListInvitations that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListInvitationsOutcomeCallable ListInvitationsCallable(const ListInvitationsRequestT& request) const { return SubmitCallable(&SecurityHubClient::ListInvitations, request); } /** * An Async wrapper for ListInvitations that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListInvitationsAsync(const ListInvitationsRequestT& request, const ListInvitationsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SecurityHubClient::ListInvitations, request, handler, context); } /** *

Lists details about all member accounts for the current Security Hub * administrator account.

The results include both member accounts that * belong to an organization and member accounts that were invited * manually.

See Also:

AWS * API Reference

*/ virtual Model::ListMembersOutcome ListMembers(const Model::ListMembersRequest& request) const; /** * A Callable wrapper for ListMembers that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListMembersOutcomeCallable ListMembersCallable(const ListMembersRequestT& request) const { return SubmitCallable(&SecurityHubClient::ListMembers, request); } /** * An Async wrapper for ListMembers that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListMembersAsync(const ListMembersRequestT& request, const ListMembersResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SecurityHubClient::ListMembers, request, handler, context); } /** *

Lists the Security Hub administrator accounts. Can only be called by the * organization management account.

See Also:

AWS * API Reference

*/ virtual Model::ListOrganizationAdminAccountsOutcome ListOrganizationAdminAccounts(const Model::ListOrganizationAdminAccountsRequest& request) const; /** * A Callable wrapper for ListOrganizationAdminAccounts that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListOrganizationAdminAccountsOutcomeCallable ListOrganizationAdminAccountsCallable(const ListOrganizationAdminAccountsRequestT& request) const { return SubmitCallable(&SecurityHubClient::ListOrganizationAdminAccounts, request); } /** * An Async wrapper for ListOrganizationAdminAccounts that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListOrganizationAdminAccountsAsync(const ListOrganizationAdminAccountsRequestT& request, const ListOrganizationAdminAccountsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SecurityHubClient::ListOrganizationAdminAccounts, request, handler, context); } /** *

Lists all of the security controls that apply to a specified standard. *

See Also:

AWS * API Reference

*/ virtual Model::ListSecurityControlDefinitionsOutcome ListSecurityControlDefinitions(const Model::ListSecurityControlDefinitionsRequest& request) const; /** * A Callable wrapper for ListSecurityControlDefinitions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListSecurityControlDefinitionsOutcomeCallable ListSecurityControlDefinitionsCallable(const ListSecurityControlDefinitionsRequestT& request) const { return SubmitCallable(&SecurityHubClient::ListSecurityControlDefinitions, request); } /** * An Async wrapper for ListSecurityControlDefinitions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListSecurityControlDefinitionsAsync(const ListSecurityControlDefinitionsRequestT& request, const ListSecurityControlDefinitionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SecurityHubClient::ListSecurityControlDefinitions, request, handler, context); } /** *

Specifies whether a control is currently enabled or disabled in each enabled * standard in the calling account.

See Also:

AWS * API Reference

*/ virtual Model::ListStandardsControlAssociationsOutcome ListStandardsControlAssociations(const Model::ListStandardsControlAssociationsRequest& request) const; /** * A Callable wrapper for ListStandardsControlAssociations that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListStandardsControlAssociationsOutcomeCallable ListStandardsControlAssociationsCallable(const ListStandardsControlAssociationsRequestT& request) const { return SubmitCallable(&SecurityHubClient::ListStandardsControlAssociations, request); } /** * An Async wrapper for ListStandardsControlAssociations that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListStandardsControlAssociationsAsync(const ListStandardsControlAssociationsRequestT& request, const ListStandardsControlAssociationsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SecurityHubClient::ListStandardsControlAssociations, request, handler, context); } /** *

Returns a list of tags associated with a resource.

See Also:

* AWS * API Reference

*/ virtual Model::ListTagsForResourceOutcome ListTagsForResource(const Model::ListTagsForResourceRequest& request) const; /** * A Callable wrapper for ListTagsForResource that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListTagsForResourceOutcomeCallable ListTagsForResourceCallable(const ListTagsForResourceRequestT& request) const { return SubmitCallable(&SecurityHubClient::ListTagsForResource, request); } /** * An Async wrapper for ListTagsForResource that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListTagsForResourceAsync(const ListTagsForResourceRequestT& request, const ListTagsForResourceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SecurityHubClient::ListTagsForResource, request, handler, context); } /** *

Adds one or more tags to a resource.

See Also:

AWS * API Reference

*/ virtual Model::TagResourceOutcome TagResource(const Model::TagResourceRequest& request) const; /** * A Callable wrapper for TagResource that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::TagResourceOutcomeCallable TagResourceCallable(const TagResourceRequestT& request) const { return SubmitCallable(&SecurityHubClient::TagResource, request); } /** * An Async wrapper for TagResource that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void TagResourceAsync(const TagResourceRequestT& request, const TagResourceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SecurityHubClient::TagResource, request, handler, context); } /** *

Removes one or more tags from a resource.

See Also:

AWS * API Reference

*/ virtual Model::UntagResourceOutcome UntagResource(const Model::UntagResourceRequest& request) const; /** * A Callable wrapper for UntagResource that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UntagResourceOutcomeCallable UntagResourceCallable(const UntagResourceRequestT& request) const { return SubmitCallable(&SecurityHubClient::UntagResource, request); } /** * An Async wrapper for UntagResource that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UntagResourceAsync(const UntagResourceRequestT& request, const UntagResourceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SecurityHubClient::UntagResource, request, handler, context); } /** *

Updates the name and description of a custom action target in Security * Hub.

See Also:

AWS * API Reference

*/ virtual Model::UpdateActionTargetOutcome UpdateActionTarget(const Model::UpdateActionTargetRequest& request) const; /** * A Callable wrapper for UpdateActionTarget that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateActionTargetOutcomeCallable UpdateActionTargetCallable(const UpdateActionTargetRequestT& request) const { return SubmitCallable(&SecurityHubClient::UpdateActionTarget, request); } /** * An Async wrapper for UpdateActionTarget that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateActionTargetAsync(const UpdateActionTargetRequestT& request, const UpdateActionTargetResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SecurityHubClient::UpdateActionTarget, request, handler, context); } /** *

Updates the finding aggregation configuration. Used to update the Region * linking mode and the list of included or excluded Regions. You cannot use * UpdateFindingAggregator to change the aggregation Region.

*

You must run UpdateFindingAggregator from the current * aggregation Region.

See Also:

AWS * API Reference

*/ virtual Model::UpdateFindingAggregatorOutcome UpdateFindingAggregator(const Model::UpdateFindingAggregatorRequest& request) const; /** * A Callable wrapper for UpdateFindingAggregator that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateFindingAggregatorOutcomeCallable UpdateFindingAggregatorCallable(const UpdateFindingAggregatorRequestT& request) const { return SubmitCallable(&SecurityHubClient::UpdateFindingAggregator, request); } /** * An Async wrapper for UpdateFindingAggregator that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateFindingAggregatorAsync(const UpdateFindingAggregatorRequestT& request, const UpdateFindingAggregatorResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SecurityHubClient::UpdateFindingAggregator, request, handler, context); } /** *

UpdateFindings is deprecated. Instead of * UpdateFindings, use BatchUpdateFindings.

*

Updates the Note and RecordState of the Security * Hub-aggregated findings that the filter attributes specify. Any member account * that can view the finding also sees the update to the finding.

See * Also:

AWS * API Reference

*/ virtual Model::UpdateFindingsOutcome UpdateFindings(const Model::UpdateFindingsRequest& request) const; /** * A Callable wrapper for UpdateFindings that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateFindingsOutcomeCallable UpdateFindingsCallable(const UpdateFindingsRequestT& request) const { return SubmitCallable(&SecurityHubClient::UpdateFindings, request); } /** * An Async wrapper for UpdateFindings that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateFindingsAsync(const UpdateFindingsRequestT& request, const UpdateFindingsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SecurityHubClient::UpdateFindings, request, handler, context); } /** *

Updates the Security Hub insight identified by the specified insight * ARN.

See Also:

AWS * API Reference

*/ virtual Model::UpdateInsightOutcome UpdateInsight(const Model::UpdateInsightRequest& request) const; /** * A Callable wrapper for UpdateInsight that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateInsightOutcomeCallable UpdateInsightCallable(const UpdateInsightRequestT& request) const { return SubmitCallable(&SecurityHubClient::UpdateInsight, request); } /** * An Async wrapper for UpdateInsight that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateInsightAsync(const UpdateInsightRequestT& request, const UpdateInsightResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SecurityHubClient::UpdateInsight, request, handler, context); } /** *

Used to update the configuration related to Organizations. Can only be called * from a Security Hub administrator account.

See Also:

AWS * API Reference

*/ virtual Model::UpdateOrganizationConfigurationOutcome UpdateOrganizationConfiguration(const Model::UpdateOrganizationConfigurationRequest& request) const; /** * A Callable wrapper for UpdateOrganizationConfiguration that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateOrganizationConfigurationOutcomeCallable UpdateOrganizationConfigurationCallable(const UpdateOrganizationConfigurationRequestT& request) const { return SubmitCallable(&SecurityHubClient::UpdateOrganizationConfiguration, request); } /** * An Async wrapper for UpdateOrganizationConfiguration that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateOrganizationConfigurationAsync(const UpdateOrganizationConfigurationRequestT& request, const UpdateOrganizationConfigurationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SecurityHubClient::UpdateOrganizationConfiguration, request, handler, context); } /** *

Updates configuration options for Security Hub.

See Also:

AWS * API Reference

*/ virtual Model::UpdateSecurityHubConfigurationOutcome UpdateSecurityHubConfiguration(const Model::UpdateSecurityHubConfigurationRequest& request) const; /** * A Callable wrapper for UpdateSecurityHubConfiguration that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateSecurityHubConfigurationOutcomeCallable UpdateSecurityHubConfigurationCallable(const UpdateSecurityHubConfigurationRequestT& request) const { return SubmitCallable(&SecurityHubClient::UpdateSecurityHubConfiguration, request); } /** * An Async wrapper for UpdateSecurityHubConfiguration that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateSecurityHubConfigurationAsync(const UpdateSecurityHubConfigurationRequestT& request, const UpdateSecurityHubConfigurationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SecurityHubClient::UpdateSecurityHubConfiguration, request, handler, context); } /** *

Used to control whether an individual security standard control is enabled or * disabled.

See Also:

AWS * API Reference

*/ virtual Model::UpdateStandardsControlOutcome UpdateStandardsControl(const Model::UpdateStandardsControlRequest& request) const; /** * A Callable wrapper for UpdateStandardsControl that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateStandardsControlOutcomeCallable UpdateStandardsControlCallable(const UpdateStandardsControlRequestT& request) const { return SubmitCallable(&SecurityHubClient::UpdateStandardsControl, request); } /** * An Async wrapper for UpdateStandardsControl that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateStandardsControlAsync(const UpdateStandardsControlRequestT& request, const UpdateStandardsControlResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SecurityHubClient::UpdateStandardsControl, request, handler, context); } void OverrideEndpoint(const Aws::String& endpoint); std::shared_ptr& accessEndpointProvider(); private: friend class Aws::Client::ClientWithAsyncTemplateMethods; void init(const SecurityHubClientConfiguration& clientConfiguration); SecurityHubClientConfiguration m_clientConfiguration; std::shared_ptr m_executor; std::shared_ptr m_endpointProvider; }; } // namespace SecurityHub } // namespace Aws