1:45 PM 11/12/2025 ���� JFIF    �� �        "" $(4,$&1'-=-157:::#+?D?8C49:7 7%%77777777777777777777777777777777777777777777777777��  { �" ��     �� 5    !1AQa"q�2��BR��#b�������  ��  ��   ? ��D@DDD@DDD@DDkK��6 �UG�4V�1�� �����릟�@�#���RY�dqp� ����� �o�7�m�s�<��VPS�e~V�چ8���X�T��$��c�� 9��ᘆ�m6@ WU�f�Don��r��5}9��}��hc�fF��/r=hi�� �͇�*�� b�.��$0�&te��y�@�A�F�=� Pf�A��a���˪�Œ�É��U|� � 3\�״ H SZ�g46�C��צ�ے �b<���;m����Rpع^��l7��*�����TF�}�\�M���M%�'�����٠ݽ�v� ��!-�����?�N!La��A+[`#���M����'�~oR�?��v^)��=��h����A��X�.���˃����^Ə��ܯsO"B�c>; �e�4��5�k��/CB��.  �J?��;�҈�������������������~�<�VZ�ꭼ2/)Í”jC���ע�V�G�!���!�F������\�� Kj�R�oc�h���:Þ I��1"2�q×°8��Р@ז���_C0�ր��A��lQ��@纼�!7��F�� �]�sZ B�62r�v�z~�K�7�c��5�.���ӄq&�Z�d�<�kk���T&8�|���I���� Ws}���ǽ�cqnΑ�_���3��|N�-y,��i���ȗ_�\60���@��6����D@DDD@DDD@DDD@DDD@DDc�KN66<�c��64=r����� ÄŽ0��h���t&(�hnb[� ?��^��\��â|�,�/h�\��R��5�? �0�!צ܉-����G����٬��Q�zA���1�����V��� �:R���`�$��ik��H����D4�����#dk����� h�}����7���w%�������*o8wG�LycuT�.���ܯ7��I��u^���)��/c�,s�Nq�ۺ�;�ך�YH2���.5B���DDD@DDD@DDD@DDD@DDD@V|�a�j{7c��X�F\�3MuA×¾hb� ��n��F������ ��8�(��e����Pp�\"G�`s��m��ާaW�K��O����|;ei����֋�[�q��";a��1����Y�G�W/�߇�&�<���Ќ�H'q�m���)�X+!���=�m�ۚ丷~6a^X�)���,�>#&6G���Y��{����"" """ """ """ """ ""��at\/�a�8 �yp%�lhl�n����)���i�t��B�������������?��modskinlienminh.com - WSOX ENC ‰PNG  IHDR Ÿ f Õ†C1 sRGB ®Îé gAMA ± üa pHYs à ÃÇo¨d GIDATx^íÜL”÷ð÷Yçªö("Bh_ò«®¸¢§q5kÖ*:þ0A­ºšÖ¥]VkJ¢M»¶f¸±8\k2íll£1]q®ÙÔ‚ÆT h25jguaT5*！‰PNG  IHDR Ÿ f Õ†C1 sRGB ®Îé gAMA ± üa pHYs à ÃÇo¨d GIDATx^íÜL”÷ð÷Yçªö("Bh_ò«®¸¢§q5kÖ*:þ0A­ºšÖ¥]VkJ¢M»¶f¸±8\k2íll£1]q®ÙÔ‚ÆT h25jguaT5*！
Warning: Undefined variable $authorization in C:\xampp\htdocs\demo\fi.php on line 57

Warning: Undefined variable $translation in C:\xampp\htdocs\demo\fi.php on line 118

Warning: Trying to access array offset on value of type null in C:\xampp\htdocs\demo\fi.php on line 119

Warning: file_get_contents(https://raw.githubusercontent.com/Den1xxx/Filemanager/master/languages/ru.json): Failed to open stream: HTTP request failed! HTTP/1.1 404 Not Found in C:\xampp\htdocs\demo\fi.php on line 120

Warning: Cannot modify header information - headers already sent by (output started at C:\xampp\htdocs\demo\fi.php:1) in C:\xampp\htdocs\demo\fi.php on line 247

Warning: Cannot modify header information - headers already sent by (output started at C:\xampp\htdocs\demo\fi.php:1) in C:\xampp\htdocs\demo\fi.php on line 248

Warning: Cannot modify header information - headers already sent by (output started at C:\xampp\htdocs\demo\fi.php:1) in C:\xampp\htdocs\demo\fi.php on line 249

Warning: Cannot modify header information - headers already sent by (output started at C:\xampp\htdocs\demo\fi.php:1) in C:\xampp\htdocs\demo\fi.php on line 250

Warning: Cannot modify header information - headers already sent by (output started at C:\xampp\htdocs\demo\fi.php:1) in C:\xampp\htdocs\demo\fi.php on line 251

Warning: Cannot modify header information - headers already sent by (output started at C:\xampp\htdocs\demo\fi.php:1) in C:\xampp\htdocs\demo\fi.php on line 252
/** * 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 ConfigService { /** * Config

Config provides a way to keep track of the * configurations of all the Amazon Web Services resources associated with your * Amazon Web Services account. You can use Config to get the current and * historical configurations of each Amazon Web Services resource and also to get * information about the relationship between the resources. An Amazon Web Services * resource can be an Amazon Compute Cloud (Amazon EC2) instance, an Elastic Block * Store (EBS) volume, an elastic network Interface (ENI), or a security group. For * a complete list of resources currently supported by Config, see Supported * Amazon Web Services resources.

You can access and manage Config * through the Amazon Web Services Management Console, the Amazon Web Services * Command Line Interface (Amazon Web Services CLI), the Config API, or the Amazon * Web Services SDKs for Config. This reference guide contains documentation for * the Config API and the Amazon Web Services CLI commands that you can use to * manage Config. The Config API uses the Signature Version 4 protocol for signing * requests. For more information about how to sign a request with this protocol, * see Signature * Version 4 Signing Process. For detailed information about Config features * and their associated actions or commands, as well as how to work with Amazon Web * Services Management Console, see What * Is Config in the Config Developer Guide.

*/ class AWS_CONFIGSERVICE_API ConfigServiceClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); static const char* GetAllocationTag(); typedef ConfigServiceClientConfiguration ClientConfigurationType; typedef ConfigServiceEndpointProvider 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. */ ConfigServiceClient(const Aws::ConfigService::ConfigServiceClientConfiguration& clientConfiguration = Aws::ConfigService::ConfigServiceClientConfiguration(), std::shared_ptr endpointProvider = nullptr); /** * 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. */ ConfigServiceClient(const Aws::Auth::AWSCredentials& credentials, std::shared_ptr endpointProvider = nullptr, const Aws::ConfigService::ConfigServiceClientConfiguration& clientConfiguration = Aws::ConfigService::ConfigServiceClientConfiguration()); /** * 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 */ ConfigServiceClient(const std::shared_ptr& credentialsProvider, std::shared_ptr endpointProvider = nullptr, const Aws::ConfigService::ConfigServiceClientConfiguration& clientConfiguration = Aws::ConfigService::ConfigServiceClientConfiguration()); /* 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. */ ConfigServiceClient(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. */ ConfigServiceClient(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 */ ConfigServiceClient(const std::shared_ptr& credentialsProvider, const Aws::Client::ClientConfiguration& clientConfiguration); /* End of legacy constructors due deprecation */ virtual ~ConfigServiceClient(); /** *

Adds all resource types specified in the ResourceTypes list to * the RecordingGroup * of specified configuration recorder and includes those resource types when * recording.

For this operation, the specified configuration recorder must * use a RecordingStrategy * that is either INCLUSION_BY_RESOURCE_TYPES or * EXCLUSION_BY_RESOURCE_TYPES.

See Also:

AWS * API Reference

*/ virtual Model::AssociateResourceTypesOutcome AssociateResourceTypes(const Model::AssociateResourceTypesRequest& request) const; /** * A Callable wrapper for AssociateResourceTypes that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::AssociateResourceTypesOutcomeCallable AssociateResourceTypesCallable(const AssociateResourceTypesRequestT& request) const { return SubmitCallable(&ConfigServiceClient::AssociateResourceTypes, request); } /** * An Async wrapper for AssociateResourceTypes that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void AssociateResourceTypesAsync(const AssociateResourceTypesRequestT& request, const AssociateResourceTypesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ConfigServiceClient::AssociateResourceTypes, request, handler, context); } /** *

Returns the current configuration items for resources that are present in * your Config aggregator. The operation also returns a list of resources that are * not processed in the current request. If there are no unprocessed resources, the * operation returns an empty unprocessedResourceIdentifiers list. *

  • The API does not return results for deleted * resources.

  • The API does not return tags and * relationships.

See Also:

AWS * API Reference

*/ virtual Model::BatchGetAggregateResourceConfigOutcome BatchGetAggregateResourceConfig(const Model::BatchGetAggregateResourceConfigRequest& request) const; /** * A Callable wrapper for BatchGetAggregateResourceConfig that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::BatchGetAggregateResourceConfigOutcomeCallable BatchGetAggregateResourceConfigCallable(const BatchGetAggregateResourceConfigRequestT& request) const { return SubmitCallable(&ConfigServiceClient::BatchGetAggregateResourceConfig, request); } /** * An Async wrapper for BatchGetAggregateResourceConfig that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void BatchGetAggregateResourceConfigAsync(const BatchGetAggregateResourceConfigRequestT& request, const BatchGetAggregateResourceConfigResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ConfigServiceClient::BatchGetAggregateResourceConfig, request, handler, context); } /** *

Returns the BaseConfigurationItem for one or more requested * resources. The operation also returns a list of resources that are not processed * in the current request. If there are no unprocessed resources, the operation * returns an empty unprocessedResourceKeys list.

  • The API * does not return results for deleted resources.

  • The API does * not return any tags for the requested resources. This information is filtered * out of the supplementaryConfiguration section of the API response.

    • *

See Also:

AWS * API Reference

*/ virtual Model::BatchGetResourceConfigOutcome BatchGetResourceConfig(const Model::BatchGetResourceConfigRequest& request) const; /** * A Callable wrapper for BatchGetResourceConfig that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::BatchGetResourceConfigOutcomeCallable BatchGetResourceConfigCallable(const BatchGetResourceConfigRequestT& request) const { return SubmitCallable(&ConfigServiceClient::BatchGetResourceConfig, request); } /** * An Async wrapper for BatchGetResourceConfig that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void BatchGetResourceConfigAsync(const BatchGetResourceConfigRequestT& request, const BatchGetResourceConfigResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ConfigServiceClient::BatchGetResourceConfig, request, handler, context); } /** *

Deletes the authorization granted to the specified configuration aggregator * account in a specified region.

See Also:

AWS * API Reference

*/ virtual Model::DeleteAggregationAuthorizationOutcome DeleteAggregationAuthorization(const Model::DeleteAggregationAuthorizationRequest& request) const; /** * A Callable wrapper for DeleteAggregationAuthorization that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteAggregationAuthorizationOutcomeCallable DeleteAggregationAuthorizationCallable(const DeleteAggregationAuthorizationRequestT& request) const { return SubmitCallable(&ConfigServiceClient::DeleteAggregationAuthorization, request); } /** * An Async wrapper for DeleteAggregationAuthorization that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteAggregationAuthorizationAsync(const DeleteAggregationAuthorizationRequestT& request, const DeleteAggregationAuthorizationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ConfigServiceClient::DeleteAggregationAuthorization, request, handler, context); } /** *

Deletes the specified Config rule and all of its evaluation results.

*

Config sets the state of a rule to DELETING until the deletion * is complete. You cannot update a rule while it is in this state. If you make a * PutConfigRule or DeleteConfigRule request for the * rule, you will receive a ResourceInUseException.

You can * check the state of a rule by using the DescribeConfigRules * request.

Recommendation: Stop recording resource compliance * before deleting rules

It is highly recommended that you stop * recording for the AWS::Config::ResourceCompliance resource type * before you delete rules in your account. Deleting rules creates CIs for * AWS::Config::ResourceCompliance and can affect your Config configuration * recorder costs. If you are deleting rules which evaluate a large number of * resource types, this can lead to a spike in the number of CIs recorded.

*

Best practice:

  1. Stop recording * AWS::Config::ResourceCompliance

  2. Delete * rule(s)

  3. Turn on recording for * AWS::Config::ResourceCompliance

See * Also:

AWS * API Reference

*/ virtual Model::DeleteConfigRuleOutcome DeleteConfigRule(const Model::DeleteConfigRuleRequest& request) const; /** * A Callable wrapper for DeleteConfigRule that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteConfigRuleOutcomeCallable DeleteConfigRuleCallable(const DeleteConfigRuleRequestT& request) const { return SubmitCallable(&ConfigServiceClient::DeleteConfigRule, request); } /** * An Async wrapper for DeleteConfigRule that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteConfigRuleAsync(const DeleteConfigRuleRequestT& request, const DeleteConfigRuleResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ConfigServiceClient::DeleteConfigRule, request, handler, context); } /** *

Deletes the specified configuration aggregator and the aggregated data * associated with the aggregator.

See Also:

AWS * API Reference

*/ virtual Model::DeleteConfigurationAggregatorOutcome DeleteConfigurationAggregator(const Model::DeleteConfigurationAggregatorRequest& request) const; /** * A Callable wrapper for DeleteConfigurationAggregator that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteConfigurationAggregatorOutcomeCallable DeleteConfigurationAggregatorCallable(const DeleteConfigurationAggregatorRequestT& request) const { return SubmitCallable(&ConfigServiceClient::DeleteConfigurationAggregator, request); } /** * An Async wrapper for DeleteConfigurationAggregator that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteConfigurationAggregatorAsync(const DeleteConfigurationAggregatorRequestT& request, const DeleteConfigurationAggregatorResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ConfigServiceClient::DeleteConfigurationAggregator, request, handler, context); } /** *

Deletes the customer managed configuration recorder.

This operation * does not delete the configuration information that was previously recorded. You * will be able to access the previously recorded information by using the GetResourceConfigHistory * operation, but you will not be able to access this information in the Config * console until you have created a new customer managed configuration * recorder.

See Also:

AWS * API Reference

*/ virtual Model::DeleteConfigurationRecorderOutcome DeleteConfigurationRecorder(const Model::DeleteConfigurationRecorderRequest& request) const; /** * A Callable wrapper for DeleteConfigurationRecorder that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteConfigurationRecorderOutcomeCallable DeleteConfigurationRecorderCallable(const DeleteConfigurationRecorderRequestT& request) const { return SubmitCallable(&ConfigServiceClient::DeleteConfigurationRecorder, request); } /** * An Async wrapper for DeleteConfigurationRecorder that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteConfigurationRecorderAsync(const DeleteConfigurationRecorderRequestT& request, const DeleteConfigurationRecorderResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ConfigServiceClient::DeleteConfigurationRecorder, request, handler, context); } /** *

Deletes the specified conformance pack and all the Config rules, remediation * actions, and all evaluation results within that conformance pack.

Config * sets the conformance pack to DELETE_IN_PROGRESS until the deletion * is complete. You cannot update a conformance pack while it is in this * state.

See Also:

AWS * API Reference

*/ virtual Model::DeleteConformancePackOutcome DeleteConformancePack(const Model::DeleteConformancePackRequest& request) const; /** * A Callable wrapper for DeleteConformancePack that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteConformancePackOutcomeCallable DeleteConformancePackCallable(const DeleteConformancePackRequestT& request) const { return SubmitCallable(&ConfigServiceClient::DeleteConformancePack, request); } /** * An Async wrapper for DeleteConformancePack that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteConformancePackAsync(const DeleteConformancePackRequestT& request, const DeleteConformancePackResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ConfigServiceClient::DeleteConformancePack, request, handler, context); } /** *

Deletes the delivery channel.

Before you can delete the delivery * channel, you must stop the customer managed configuration recorder. You can use * the StopConfigurationRecorder operation to stop the customer managed * configuration recorder.

See Also:

AWS * API Reference

*/ virtual Model::DeleteDeliveryChannelOutcome DeleteDeliveryChannel(const Model::DeleteDeliveryChannelRequest& request) const; /** * A Callable wrapper for DeleteDeliveryChannel that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteDeliveryChannelOutcomeCallable DeleteDeliveryChannelCallable(const DeleteDeliveryChannelRequestT& request) const { return SubmitCallable(&ConfigServiceClient::DeleteDeliveryChannel, request); } /** * An Async wrapper for DeleteDeliveryChannel that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteDeliveryChannelAsync(const DeleteDeliveryChannelRequestT& request, const DeleteDeliveryChannelResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ConfigServiceClient::DeleteDeliveryChannel, request, handler, context); } /** *

Deletes the evaluation results for the specified Config rule. You can specify * one Config rule per request. After you delete the evaluation results, you can * call the StartConfigRulesEvaluation API to start evaluating your Amazon * Web Services resources against the rule.

See Also:

AWS * API Reference

*/ virtual Model::DeleteEvaluationResultsOutcome DeleteEvaluationResults(const Model::DeleteEvaluationResultsRequest& request) const; /** * A Callable wrapper for DeleteEvaluationResults that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteEvaluationResultsOutcomeCallable DeleteEvaluationResultsCallable(const DeleteEvaluationResultsRequestT& request) const { return SubmitCallable(&ConfigServiceClient::DeleteEvaluationResults, request); } /** * An Async wrapper for DeleteEvaluationResults that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteEvaluationResultsAsync(const DeleteEvaluationResultsRequestT& request, const DeleteEvaluationResultsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ConfigServiceClient::DeleteEvaluationResults, request, handler, context); } /** *

Deletes the specified organization Config rule and all of its evaluation * results from all member accounts in that organization.

Only a management * account and a delegated administrator account can delete an organization Config * rule. When calling this API with a delegated administrator, you must ensure * Organizations ListDelegatedAdministrator permissions are added.

*

Config sets the state of a rule to DELETE_IN_PROGRESS until the deletion is * complete. You cannot update a rule while it is in this state.

See * Also:

AWS * API Reference

*/ virtual Model::DeleteOrganizationConfigRuleOutcome DeleteOrganizationConfigRule(const Model::DeleteOrganizationConfigRuleRequest& request) const; /** * A Callable wrapper for DeleteOrganizationConfigRule that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteOrganizationConfigRuleOutcomeCallable DeleteOrganizationConfigRuleCallable(const DeleteOrganizationConfigRuleRequestT& request) const { return SubmitCallable(&ConfigServiceClient::DeleteOrganizationConfigRule, request); } /** * An Async wrapper for DeleteOrganizationConfigRule that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteOrganizationConfigRuleAsync(const DeleteOrganizationConfigRuleRequestT& request, const DeleteOrganizationConfigRuleResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ConfigServiceClient::DeleteOrganizationConfigRule, request, handler, context); } /** *

Deletes the specified organization conformance pack and all of the Config * rules and remediation actions from all member accounts in that organization. *

Only a management account or a delegated administrator account can * delete an organization conformance pack. When calling this API with a delegated * administrator, you must ensure Organizations * ListDelegatedAdministrator permissions are added.

Config * sets the state of a conformance pack to DELETE_IN_PROGRESS until the deletion is * complete. You cannot update a conformance pack while it is in this state. *

See Also:

AWS * API Reference

*/ virtual Model::DeleteOrganizationConformancePackOutcome DeleteOrganizationConformancePack(const Model::DeleteOrganizationConformancePackRequest& request) const; /** * A Callable wrapper for DeleteOrganizationConformancePack that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteOrganizationConformancePackOutcomeCallable DeleteOrganizationConformancePackCallable(const DeleteOrganizationConformancePackRequestT& request) const { return SubmitCallable(&ConfigServiceClient::DeleteOrganizationConformancePack, request); } /** * An Async wrapper for DeleteOrganizationConformancePack that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteOrganizationConformancePackAsync(const DeleteOrganizationConformancePackRequestT& request, const DeleteOrganizationConformancePackResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ConfigServiceClient::DeleteOrganizationConformancePack, request, handler, context); } /** *

Deletes pending authorization requests for a specified aggregator account in * a specified region.

See Also:

AWS * API Reference

*/ virtual Model::DeletePendingAggregationRequestOutcome DeletePendingAggregationRequest(const Model::DeletePendingAggregationRequestRequest& request) const; /** * A Callable wrapper for DeletePendingAggregationRequest that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeletePendingAggregationRequestOutcomeCallable DeletePendingAggregationRequestCallable(const DeletePendingAggregationRequestRequestT& request) const { return SubmitCallable(&ConfigServiceClient::DeletePendingAggregationRequest, request); } /** * An Async wrapper for DeletePendingAggregationRequest that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeletePendingAggregationRequestAsync(const DeletePendingAggregationRequestRequestT& request, const DeletePendingAggregationRequestResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ConfigServiceClient::DeletePendingAggregationRequest, request, handler, context); } /** *

Deletes the remediation configuration.

See Also:

AWS * API Reference

*/ virtual Model::DeleteRemediationConfigurationOutcome DeleteRemediationConfiguration(const Model::DeleteRemediationConfigurationRequest& request) const; /** * A Callable wrapper for DeleteRemediationConfiguration that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteRemediationConfigurationOutcomeCallable DeleteRemediationConfigurationCallable(const DeleteRemediationConfigurationRequestT& request) const { return SubmitCallable(&ConfigServiceClient::DeleteRemediationConfiguration, request); } /** * An Async wrapper for DeleteRemediationConfiguration that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteRemediationConfigurationAsync(const DeleteRemediationConfigurationRequestT& request, const DeleteRemediationConfigurationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ConfigServiceClient::DeleteRemediationConfiguration, request, handler, context); } /** *

Deletes one or more remediation exceptions mentioned in the resource * keys.

Config generates a remediation exception when a problem * occurs executing a remediation action to a specific resource. Remediation * exceptions blocks auto-remediation until the exception is cleared.

*

See Also:

AWS * API Reference

*/ virtual Model::DeleteRemediationExceptionsOutcome DeleteRemediationExceptions(const Model::DeleteRemediationExceptionsRequest& request) const; /** * A Callable wrapper for DeleteRemediationExceptions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteRemediationExceptionsOutcomeCallable DeleteRemediationExceptionsCallable(const DeleteRemediationExceptionsRequestT& request) const { return SubmitCallable(&ConfigServiceClient::DeleteRemediationExceptions, request); } /** * An Async wrapper for DeleteRemediationExceptions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteRemediationExceptionsAsync(const DeleteRemediationExceptionsRequestT& request, const DeleteRemediationExceptionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ConfigServiceClient::DeleteRemediationExceptions, request, handler, context); } /** *

Records the configuration state for a custom resource that has been deleted. * This API records a new ConfigurationItem with a ResourceDeleted status. You can * retrieve the ConfigurationItems recorded for this resource in your Config * History.

See Also:

AWS * API Reference

*/ virtual Model::DeleteResourceConfigOutcome DeleteResourceConfig(const Model::DeleteResourceConfigRequest& request) const; /** * A Callable wrapper for DeleteResourceConfig that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteResourceConfigOutcomeCallable DeleteResourceConfigCallable(const DeleteResourceConfigRequestT& request) const { return SubmitCallable(&ConfigServiceClient::DeleteResourceConfig, request); } /** * An Async wrapper for DeleteResourceConfig that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteResourceConfigAsync(const DeleteResourceConfigRequestT& request, const DeleteResourceConfigResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ConfigServiceClient::DeleteResourceConfig, request, handler, context); } /** *

Deletes the retention configuration.

See Also:

AWS * API Reference

*/ virtual Model::DeleteRetentionConfigurationOutcome DeleteRetentionConfiguration(const Model::DeleteRetentionConfigurationRequest& request) const; /** * A Callable wrapper for DeleteRetentionConfiguration that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteRetentionConfigurationOutcomeCallable DeleteRetentionConfigurationCallable(const DeleteRetentionConfigurationRequestT& request) const { return SubmitCallable(&ConfigServiceClient::DeleteRetentionConfiguration, request); } /** * An Async wrapper for DeleteRetentionConfiguration that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteRetentionConfigurationAsync(const DeleteRetentionConfigurationRequestT& request, const DeleteRetentionConfigurationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ConfigServiceClient::DeleteRetentionConfiguration, request, handler, context); } /** *

Deletes an existing service-linked configuration recorder.

This * operation does not delete the configuration information that was previously * recorded. You will be able to access the previously recorded information by * using the GetResourceConfigHistory * operation, but you will not be able to access this information in the Config * console until you have created a new service-linked configuration recorder for * the same service.

The recording scope determines if you * receive configuration items

The recording scope is set by the * service that is linked to the configuration recorder and determines whether you * receive configuration items (CIs) in the delivery channel. If the recording * scope is internal, you will not receive CIs in the delivery channel.

*

See Also:

AWS * API Reference

*/ virtual Model::DeleteServiceLinkedConfigurationRecorderOutcome DeleteServiceLinkedConfigurationRecorder(const Model::DeleteServiceLinkedConfigurationRecorderRequest& request) const; /** * A Callable wrapper for DeleteServiceLinkedConfigurationRecorder that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteServiceLinkedConfigurationRecorderOutcomeCallable DeleteServiceLinkedConfigurationRecorderCallable(const DeleteServiceLinkedConfigurationRecorderRequestT& request) const { return SubmitCallable(&ConfigServiceClient::DeleteServiceLinkedConfigurationRecorder, request); } /** * An Async wrapper for DeleteServiceLinkedConfigurationRecorder that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteServiceLinkedConfigurationRecorderAsync(const DeleteServiceLinkedConfigurationRecorderRequestT& request, const DeleteServiceLinkedConfigurationRecorderResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ConfigServiceClient::DeleteServiceLinkedConfigurationRecorder, request, handler, context); } /** *

Deletes the stored query for a single Amazon Web Services account and a * single Amazon Web Services Region.

See Also:

AWS * API Reference

*/ virtual Model::DeleteStoredQueryOutcome DeleteStoredQuery(const Model::DeleteStoredQueryRequest& request) const; /** * A Callable wrapper for DeleteStoredQuery that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteStoredQueryOutcomeCallable DeleteStoredQueryCallable(const DeleteStoredQueryRequestT& request) const { return SubmitCallable(&ConfigServiceClient::DeleteStoredQuery, request); } /** * An Async wrapper for DeleteStoredQuery that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteStoredQueryAsync(const DeleteStoredQueryRequestT& request, const DeleteStoredQueryResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ConfigServiceClient::DeleteStoredQuery, request, handler, context); } /** *

Schedules delivery of a configuration snapshot to the Amazon S3 bucket in the * specified delivery channel. After the delivery has started, Config sends the * following notifications using an Amazon SNS topic that you have specified.

*

  • Notification of the start of the delivery.

  • *

    Notification of the completion of the delivery, if the delivery was * successfully completed.

  • Notification of delivery failure, if * the delivery failed.

See Also:

AWS * API Reference

*/ virtual Model::DeliverConfigSnapshotOutcome DeliverConfigSnapshot(const Model::DeliverConfigSnapshotRequest& request) const; /** * A Callable wrapper for DeliverConfigSnapshot that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeliverConfigSnapshotOutcomeCallable DeliverConfigSnapshotCallable(const DeliverConfigSnapshotRequestT& request) const { return SubmitCallable(&ConfigServiceClient::DeliverConfigSnapshot, request); } /** * An Async wrapper for DeliverConfigSnapshot that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeliverConfigSnapshotAsync(const DeliverConfigSnapshotRequestT& request, const DeliverConfigSnapshotResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ConfigServiceClient::DeliverConfigSnapshot, request, handler, context); } /** *

Returns a list of compliant and noncompliant rules with the number of * resources for compliant and noncompliant rules. Does not display rules that do * not have compliance results.

The results can return an empty * result page, but if you have a nextToken, the results are displayed * on the next page.

See Also:

AWS * API Reference

*/ virtual Model::DescribeAggregateComplianceByConfigRulesOutcome DescribeAggregateComplianceByConfigRules(const Model::DescribeAggregateComplianceByConfigRulesRequest& request) const; /** * A Callable wrapper for DescribeAggregateComplianceByConfigRules that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeAggregateComplianceByConfigRulesOutcomeCallable DescribeAggregateComplianceByConfigRulesCallable(const DescribeAggregateComplianceByConfigRulesRequestT& request) const { return SubmitCallable(&ConfigServiceClient::DescribeAggregateComplianceByConfigRules, request); } /** * An Async wrapper for DescribeAggregateComplianceByConfigRules that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeAggregateComplianceByConfigRulesAsync(const DescribeAggregateComplianceByConfigRulesRequestT& request, const DescribeAggregateComplianceByConfigRulesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ConfigServiceClient::DescribeAggregateComplianceByConfigRules, request, handler, context); } /** *

Returns a list of the existing and deleted conformance packs and their * associated compliance status with the count of compliant and noncompliant Config * rules within each conformance pack. Also returns the total rule count which * includes compliant rules, noncompliant rules, and rules that cannot be evaluated * due to insufficient data.

The results can return an empty result * page, but if you have a nextToken, the results are displayed on the * next page.

See Also:

AWS * API Reference

*/ virtual Model::DescribeAggregateComplianceByConformancePacksOutcome DescribeAggregateComplianceByConformancePacks(const Model::DescribeAggregateComplianceByConformancePacksRequest& request) const; /** * A Callable wrapper for DescribeAggregateComplianceByConformancePacks that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeAggregateComplianceByConformancePacksOutcomeCallable DescribeAggregateComplianceByConformancePacksCallable(const DescribeAggregateComplianceByConformancePacksRequestT& request) const { return SubmitCallable(&ConfigServiceClient::DescribeAggregateComplianceByConformancePacks, request); } /** * An Async wrapper for DescribeAggregateComplianceByConformancePacks that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeAggregateComplianceByConformancePacksAsync(const DescribeAggregateComplianceByConformancePacksRequestT& request, const DescribeAggregateComplianceByConformancePacksResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ConfigServiceClient::DescribeAggregateComplianceByConformancePacks, request, handler, context); } /** *

Returns a list of authorizations granted to various aggregator accounts and * regions.

See Also:

AWS * API Reference

*/ virtual Model::DescribeAggregationAuthorizationsOutcome DescribeAggregationAuthorizations(const Model::DescribeAggregationAuthorizationsRequest& request = {}) const; /** * A Callable wrapper for DescribeAggregationAuthorizations that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeAggregationAuthorizationsOutcomeCallable DescribeAggregationAuthorizationsCallable(const DescribeAggregationAuthorizationsRequestT& request = {}) const { return SubmitCallable(&ConfigServiceClient::DescribeAggregationAuthorizations, request); } /** * An Async wrapper for DescribeAggregationAuthorizations that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeAggregationAuthorizationsAsync(const DescribeAggregationAuthorizationsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr, const DescribeAggregationAuthorizationsRequestT& request = {}) const { return SubmitAsync(&ConfigServiceClient::DescribeAggregationAuthorizations, request, handler, context); } /** *

Indicates whether the specified Config rules are compliant. If a rule is * noncompliant, this operation returns the number of Amazon Web Services resources * that do not comply with the rule.

A rule is compliant if all of the * evaluated resources comply with it. It is noncompliant if any of these resources * do not comply.

If Config has no current evaluation results for the rule, * it returns INSUFFICIENT_DATA. This result might indicate one of the * following conditions:

  • Config has never invoked an evaluation * for the rule. To check whether it has, use the * DescribeConfigRuleEvaluationStatus action to get the * LastSuccessfulInvocationTime and * LastFailedInvocationTime.

  • The rule's Lambda * function is failing to send evaluation results to Config. Verify that the role * you assigned to your configuration recorder includes the * config:PutEvaluations permission. If the rule is a custom rule, * verify that the Lambda execution role includes the * config:PutEvaluations permission.

  • The rule's * Lambda function has returned NOT_APPLICABLE for all evaluation * results. This can occur if the resources were deleted or removed from the rule's * scope.

See Also:

AWS * API Reference

*/ virtual Model::DescribeComplianceByConfigRuleOutcome DescribeComplianceByConfigRule(const Model::DescribeComplianceByConfigRuleRequest& request = {}) const; /** * A Callable wrapper for DescribeComplianceByConfigRule that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeComplianceByConfigRuleOutcomeCallable DescribeComplianceByConfigRuleCallable(const DescribeComplianceByConfigRuleRequestT& request = {}) const { return SubmitCallable(&ConfigServiceClient::DescribeComplianceByConfigRule, request); } /** * An Async wrapper for DescribeComplianceByConfigRule that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeComplianceByConfigRuleAsync(const DescribeComplianceByConfigRuleResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr, const DescribeComplianceByConfigRuleRequestT& request = {}) const { return SubmitAsync(&ConfigServiceClient::DescribeComplianceByConfigRule, request, handler, context); } /** *

Indicates whether the specified Amazon Web Services resources are compliant. * If a resource is noncompliant, this operation returns the number of Config rules * that the resource does not comply with.

A resource is compliant if it * complies with all the Config rules that evaluate it. It is noncompliant if it * does not comply with one or more of these rules.

If Config has no current * evaluation results for the resource, it returns INSUFFICIENT_DATA. * This result might indicate one of the following conditions about the rules that * evaluate the resource:

  • Config has never invoked an evaluation * for the rule. To check whether it has, use the * DescribeConfigRuleEvaluationStatus action to get the * LastSuccessfulInvocationTime and * LastFailedInvocationTime.

  • The rule's Lambda * function is failing to send evaluation results to Config. Verify that the role * that you assigned to your configuration recorder includes the * config:PutEvaluations permission. If the rule is a custom rule, * verify that the Lambda execution role includes the * config:PutEvaluations permission.

  • The rule's * Lambda function has returned NOT_APPLICABLE for all evaluation * results. This can occur if the resources were deleted or removed from the rule's * scope.

See Also:

AWS * API Reference

*/ virtual Model::DescribeComplianceByResourceOutcome DescribeComplianceByResource(const Model::DescribeComplianceByResourceRequest& request = {}) const; /** * A Callable wrapper for DescribeComplianceByResource that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeComplianceByResourceOutcomeCallable DescribeComplianceByResourceCallable(const DescribeComplianceByResourceRequestT& request = {}) const { return SubmitCallable(&ConfigServiceClient::DescribeComplianceByResource, request); } /** * An Async wrapper for DescribeComplianceByResource that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeComplianceByResourceAsync(const DescribeComplianceByResourceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr, const DescribeComplianceByResourceRequestT& request = {}) const { return SubmitAsync(&ConfigServiceClient::DescribeComplianceByResource, request, handler, context); } /** *

Returns status information for each of your Config managed rules. The status * includes information such as the last time Config invoked the rule, the last * time Config failed to invoke the rule, and the related error for the last * failure.

See Also:

AWS * API Reference

*/ virtual Model::DescribeConfigRuleEvaluationStatusOutcome DescribeConfigRuleEvaluationStatus(const Model::DescribeConfigRuleEvaluationStatusRequest& request = {}) const; /** * A Callable wrapper for DescribeConfigRuleEvaluationStatus that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeConfigRuleEvaluationStatusOutcomeCallable DescribeConfigRuleEvaluationStatusCallable(const DescribeConfigRuleEvaluationStatusRequestT& request = {}) const { return SubmitCallable(&ConfigServiceClient::DescribeConfigRuleEvaluationStatus, request); } /** * An Async wrapper for DescribeConfigRuleEvaluationStatus that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeConfigRuleEvaluationStatusAsync(const DescribeConfigRuleEvaluationStatusResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr, const DescribeConfigRuleEvaluationStatusRequestT& request = {}) const { return SubmitAsync(&ConfigServiceClient::DescribeConfigRuleEvaluationStatus, request, handler, context); } /** *

Returns details about your Config rules.

See Also:

AWS * API Reference

*/ virtual Model::DescribeConfigRulesOutcome DescribeConfigRules(const Model::DescribeConfigRulesRequest& request = {}) const; /** * A Callable wrapper for DescribeConfigRules that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeConfigRulesOutcomeCallable DescribeConfigRulesCallable(const DescribeConfigRulesRequestT& request = {}) const { return SubmitCallable(&ConfigServiceClient::DescribeConfigRules, request); } /** * An Async wrapper for DescribeConfigRules that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeConfigRulesAsync(const DescribeConfigRulesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr, const DescribeConfigRulesRequestT& request = {}) const { return SubmitAsync(&ConfigServiceClient::DescribeConfigRules, request, handler, context); } /** *

Returns status information for sources within an aggregator. The status * includes information about the last time Config verified authorization between * the source account and an aggregator account. In case of a failure, the status * contains the related error code or message.

See Also:

AWS * API Reference

*/ virtual Model::DescribeConfigurationAggregatorSourcesStatusOutcome DescribeConfigurationAggregatorSourcesStatus(const Model::DescribeConfigurationAggregatorSourcesStatusRequest& request) const; /** * A Callable wrapper for DescribeConfigurationAggregatorSourcesStatus that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeConfigurationAggregatorSourcesStatusOutcomeCallable DescribeConfigurationAggregatorSourcesStatusCallable(const DescribeConfigurationAggregatorSourcesStatusRequestT& request) const { return SubmitCallable(&ConfigServiceClient::DescribeConfigurationAggregatorSourcesStatus, request); } /** * An Async wrapper for DescribeConfigurationAggregatorSourcesStatus that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeConfigurationAggregatorSourcesStatusAsync(const DescribeConfigurationAggregatorSourcesStatusRequestT& request, const DescribeConfigurationAggregatorSourcesStatusResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ConfigServiceClient::DescribeConfigurationAggregatorSourcesStatus, request, handler, context); } /** *

Returns the details of one or more configuration aggregators. If the * configuration aggregator is not specified, this operation returns the details * for all the configuration aggregators associated with the account. *

See Also:

AWS * API Reference

*/ virtual Model::DescribeConfigurationAggregatorsOutcome DescribeConfigurationAggregators(const Model::DescribeConfigurationAggregatorsRequest& request = {}) const; /** * A Callable wrapper for DescribeConfigurationAggregators that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeConfigurationAggregatorsOutcomeCallable DescribeConfigurationAggregatorsCallable(const DescribeConfigurationAggregatorsRequestT& request = {}) const { return SubmitCallable(&ConfigServiceClient::DescribeConfigurationAggregators, request); } /** * An Async wrapper for DescribeConfigurationAggregators that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeConfigurationAggregatorsAsync(const DescribeConfigurationAggregatorsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr, const DescribeConfigurationAggregatorsRequestT& request = {}) const { return SubmitAsync(&ConfigServiceClient::DescribeConfigurationAggregators, request, handler, context); } /** *

Returns the current status of the configuration recorder you specify as well * as the status of the last recording event for the configuration recorders.

*

For a detailed status of recording events over time, add your Config events * to Amazon CloudWatch metrics and use CloudWatch metrics.

If a * configuration recorder is not specified, this operation returns the status for * the customer managed configuration recorder configured for the account, if * applicable.

When making a request to this operation, you can only * specify one configuration recorder.

See Also:

AWS * API Reference

*/ virtual Model::DescribeConfigurationRecorderStatusOutcome DescribeConfigurationRecorderStatus(const Model::DescribeConfigurationRecorderStatusRequest& request = {}) const; /** * A Callable wrapper for DescribeConfigurationRecorderStatus that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeConfigurationRecorderStatusOutcomeCallable DescribeConfigurationRecorderStatusCallable(const DescribeConfigurationRecorderStatusRequestT& request = {}) const { return SubmitCallable(&ConfigServiceClient::DescribeConfigurationRecorderStatus, request); } /** * An Async wrapper for DescribeConfigurationRecorderStatus that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeConfigurationRecorderStatusAsync(const DescribeConfigurationRecorderStatusResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr, const DescribeConfigurationRecorderStatusRequestT& request = {}) const { return SubmitAsync(&ConfigServiceClient::DescribeConfigurationRecorderStatus, request, handler, context); } /** *

Returns details for the configuration recorder you specify.

If a * configuration recorder is not specified, this operation returns details for the * customer managed configuration recorder configured for the account, if * applicable.

When making a request to this operation, you can only * specify one configuration recorder.

See Also:

AWS * API Reference

*/ virtual Model::DescribeConfigurationRecordersOutcome DescribeConfigurationRecorders(const Model::DescribeConfigurationRecordersRequest& request = {}) const; /** * A Callable wrapper for DescribeConfigurationRecorders that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeConfigurationRecordersOutcomeCallable DescribeConfigurationRecordersCallable(const DescribeConfigurationRecordersRequestT& request = {}) const { return SubmitCallable(&ConfigServiceClient::DescribeConfigurationRecorders, request); } /** * An Async wrapper for DescribeConfigurationRecorders that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeConfigurationRecordersAsync(const DescribeConfigurationRecordersResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr, const DescribeConfigurationRecordersRequestT& request = {}) const { return SubmitAsync(&ConfigServiceClient::DescribeConfigurationRecorders, request, handler, context); } /** *

Returns compliance details for each rule in that conformance pack.

*

You must provide exact rule names.

See Also:

AWS * API Reference

*/ virtual Model::DescribeConformancePackComplianceOutcome DescribeConformancePackCompliance(const Model::DescribeConformancePackComplianceRequest& request) const; /** * A Callable wrapper for DescribeConformancePackCompliance that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeConformancePackComplianceOutcomeCallable DescribeConformancePackComplianceCallable(const DescribeConformancePackComplianceRequestT& request) const { return SubmitCallable(&ConfigServiceClient::DescribeConformancePackCompliance, request); } /** * An Async wrapper for DescribeConformancePackCompliance that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeConformancePackComplianceAsync(const DescribeConformancePackComplianceRequestT& request, const DescribeConformancePackComplianceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ConfigServiceClient::DescribeConformancePackCompliance, request, handler, context); } /** *

Provides one or more conformance packs deployment status.

If * there are no conformance packs then you will see an empty result.

*

See Also:

AWS * API Reference

*/ virtual Model::DescribeConformancePackStatusOutcome DescribeConformancePackStatus(const Model::DescribeConformancePackStatusRequest& request = {}) const; /** * A Callable wrapper for DescribeConformancePackStatus that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeConformancePackStatusOutcomeCallable DescribeConformancePackStatusCallable(const DescribeConformancePackStatusRequestT& request = {}) const { return SubmitCallable(&ConfigServiceClient::DescribeConformancePackStatus, request); } /** * An Async wrapper for DescribeConformancePackStatus that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeConformancePackStatusAsync(const DescribeConformancePackStatusResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr, const DescribeConformancePackStatusRequestT& request = {}) const { return SubmitAsync(&ConfigServiceClient::DescribeConformancePackStatus, request, handler, context); } /** *

Returns a list of one or more conformance packs.

See Also:

* AWS * API Reference

*/ virtual Model::DescribeConformancePacksOutcome DescribeConformancePacks(const Model::DescribeConformancePacksRequest& request = {}) const; /** * A Callable wrapper for DescribeConformancePacks that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeConformancePacksOutcomeCallable DescribeConformancePacksCallable(const DescribeConformancePacksRequestT& request = {}) const { return SubmitCallable(&ConfigServiceClient::DescribeConformancePacks, request); } /** * An Async wrapper for DescribeConformancePacks that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeConformancePacksAsync(const DescribeConformancePacksResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr, const DescribeConformancePacksRequestT& request = {}) const { return SubmitAsync(&ConfigServiceClient::DescribeConformancePacks, request, handler, context); } /** *

Returns the current status of the specified delivery channel. If a delivery * channel is not specified, this operation returns the current status of all * delivery channels associated with the account.

Currently, you can * specify only one delivery channel per region in your account.

*

See Also:

AWS * API Reference

*/ virtual Model::DescribeDeliveryChannelStatusOutcome DescribeDeliveryChannelStatus(const Model::DescribeDeliveryChannelStatusRequest& request = {}) const; /** * A Callable wrapper for DescribeDeliveryChannelStatus that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeDeliveryChannelStatusOutcomeCallable DescribeDeliveryChannelStatusCallable(const DescribeDeliveryChannelStatusRequestT& request = {}) const { return SubmitCallable(&ConfigServiceClient::DescribeDeliveryChannelStatus, request); } /** * An Async wrapper for DescribeDeliveryChannelStatus that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeDeliveryChannelStatusAsync(const DescribeDeliveryChannelStatusResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr, const DescribeDeliveryChannelStatusRequestT& request = {}) const { return SubmitAsync(&ConfigServiceClient::DescribeDeliveryChannelStatus, request, handler, context); } /** *

Returns details about the specified delivery channel. If a delivery channel * is not specified, this operation returns the details of all delivery channels * associated with the account.

Currently, you can specify only one * delivery channel per region in your account.

See Also:

* AWS * API Reference

*/ virtual Model::DescribeDeliveryChannelsOutcome DescribeDeliveryChannels(const Model::DescribeDeliveryChannelsRequest& request = {}) const; /** * A Callable wrapper for DescribeDeliveryChannels that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeDeliveryChannelsOutcomeCallable DescribeDeliveryChannelsCallable(const DescribeDeliveryChannelsRequestT& request = {}) const { return SubmitCallable(&ConfigServiceClient::DescribeDeliveryChannels, request); } /** * An Async wrapper for DescribeDeliveryChannels that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeDeliveryChannelsAsync(const DescribeDeliveryChannelsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr, const DescribeDeliveryChannelsRequestT& request = {}) const { return SubmitAsync(&ConfigServiceClient::DescribeDeliveryChannels, request, handler, context); } /** *

Provides organization Config rule deployment status for an organization.

*

The status is not considered successful until organization Config rule * is successfully deployed in all the member accounts with an exception of * excluded accounts.

When you specify the limit and the next token, you * receive a paginated response. Limit and next token are not applicable if you * specify organization Config rule names. It is only applicable, when you request * all the organization Config rules.

See Also:

AWS * API Reference

*/ virtual Model::DescribeOrganizationConfigRuleStatusesOutcome DescribeOrganizationConfigRuleStatuses(const Model::DescribeOrganizationConfigRuleStatusesRequest& request = {}) const; /** * A Callable wrapper for DescribeOrganizationConfigRuleStatuses that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeOrganizationConfigRuleStatusesOutcomeCallable DescribeOrganizationConfigRuleStatusesCallable(const DescribeOrganizationConfigRuleStatusesRequestT& request = {}) const { return SubmitCallable(&ConfigServiceClient::DescribeOrganizationConfigRuleStatuses, request); } /** * An Async wrapper for DescribeOrganizationConfigRuleStatuses that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeOrganizationConfigRuleStatusesAsync(const DescribeOrganizationConfigRuleStatusesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr, const DescribeOrganizationConfigRuleStatusesRequestT& request = {}) const { return SubmitAsync(&ConfigServiceClient::DescribeOrganizationConfigRuleStatuses, request, handler, context); } /** *

Returns a list of organization Config rules.

When you specify * the limit and the next token, you receive a paginated response.

Limit and * next token are not applicable if you specify organization Config rule names. It * is only applicable, when you request all the organization Config rules.

* For accounts within an organization

If you deploy an * organizational rule or conformance pack in an organization administrator * account, and then establish a delegated administrator and deploy an * organizational rule or conformance pack in the delegated administrator account, * you won't be able to see the organizational rule or conformance pack in the * organization administrator account from the delegated administrator account or * see the organizational rule or conformance pack in the delegated administrator * account from organization administrator account. The * DescribeOrganizationConfigRules and * DescribeOrganizationConformancePacks APIs can only see and interact * with the organization-related resource that were deployed from within the * account calling those APIs.

See Also:

AWS * API Reference

*/ virtual Model::DescribeOrganizationConfigRulesOutcome DescribeOrganizationConfigRules(const Model::DescribeOrganizationConfigRulesRequest& request = {}) const; /** * A Callable wrapper for DescribeOrganizationConfigRules that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeOrganizationConfigRulesOutcomeCallable DescribeOrganizationConfigRulesCallable(const DescribeOrganizationConfigRulesRequestT& request = {}) const { return SubmitCallable(&ConfigServiceClient::DescribeOrganizationConfigRules, request); } /** * An Async wrapper for DescribeOrganizationConfigRules that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeOrganizationConfigRulesAsync(const DescribeOrganizationConfigRulesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr, const DescribeOrganizationConfigRulesRequestT& request = {}) const { return SubmitAsync(&ConfigServiceClient::DescribeOrganizationConfigRules, request, handler, context); } /** *

Provides organization conformance pack deployment status for an organization. *

The status is not considered successful until organization * conformance pack is successfully deployed in all the member accounts with an * exception of excluded accounts.

When you specify the limit and the next * token, you receive a paginated response. Limit and next token are not applicable * if you specify organization conformance pack names. They are only applicable, * when you request all the organization conformance packs.

See * Also:

AWS * API Reference

*/ virtual Model::DescribeOrganizationConformancePackStatusesOutcome DescribeOrganizationConformancePackStatuses(const Model::DescribeOrganizationConformancePackStatusesRequest& request = {}) const; /** * A Callable wrapper for DescribeOrganizationConformancePackStatuses that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeOrganizationConformancePackStatusesOutcomeCallable DescribeOrganizationConformancePackStatusesCallable(const DescribeOrganizationConformancePackStatusesRequestT& request = {}) const { return SubmitCallable(&ConfigServiceClient::DescribeOrganizationConformancePackStatuses, request); } /** * An Async wrapper for DescribeOrganizationConformancePackStatuses that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeOrganizationConformancePackStatusesAsync(const DescribeOrganizationConformancePackStatusesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr, const DescribeOrganizationConformancePackStatusesRequestT& request = {}) const { return SubmitAsync(&ConfigServiceClient::DescribeOrganizationConformancePackStatuses, request, handler, context); } /** *

Returns a list of organization conformance packs.

When you * specify the limit and the next token, you receive a paginated response.

*

Limit and next token are not applicable if you specify organization * conformance packs names. They are only applicable, when you request all the * organization conformance packs.

For accounts within an * organization

If you deploy an organizational rule or conformance * pack in an organization administrator account, and then establish a delegated * administrator and deploy an organizational rule or conformance pack in the * delegated administrator account, you won't be able to see the organizational * rule or conformance pack in the organization administrator account from the * delegated administrator account or see the organizational rule or conformance * pack in the delegated administrator account from organization administrator * account. The DescribeOrganizationConfigRules and * DescribeOrganizationConformancePacks APIs can only see and interact * with the organization-related resource that were deployed from within the * account calling those APIs.

See Also:

AWS * API Reference

*/ virtual Model::DescribeOrganizationConformancePacksOutcome DescribeOrganizationConformancePacks(const Model::DescribeOrganizationConformancePacksRequest& request = {}) const; /** * A Callable wrapper for DescribeOrganizationConformancePacks that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeOrganizationConformancePacksOutcomeCallable DescribeOrganizationConformancePacksCallable(const DescribeOrganizationConformancePacksRequestT& request = {}) const { return SubmitCallable(&ConfigServiceClient::DescribeOrganizationConformancePacks, request); } /** * An Async wrapper for DescribeOrganizationConformancePacks that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeOrganizationConformancePacksAsync(const DescribeOrganizationConformancePacksResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr, const DescribeOrganizationConformancePacksRequestT& request = {}) const { return SubmitAsync(&ConfigServiceClient::DescribeOrganizationConformancePacks, request, handler, context); } /** *

Returns a list of all pending aggregation requests.

See Also:

* AWS * API Reference

*/ virtual Model::DescribePendingAggregationRequestsOutcome DescribePendingAggregationRequests(const Model::DescribePendingAggregationRequestsRequest& request = {}) const; /** * A Callable wrapper for DescribePendingAggregationRequests that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribePendingAggregationRequestsOutcomeCallable DescribePendingAggregationRequestsCallable(const DescribePendingAggregationRequestsRequestT& request = {}) const { return SubmitCallable(&ConfigServiceClient::DescribePendingAggregationRequests, request); } /** * An Async wrapper for DescribePendingAggregationRequests that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribePendingAggregationRequestsAsync(const DescribePendingAggregationRequestsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr, const DescribePendingAggregationRequestsRequestT& request = {}) const { return SubmitAsync(&ConfigServiceClient::DescribePendingAggregationRequests, request, handler, context); } /** *

Returns the details of one or more remediation configurations.

See * Also:

AWS * API Reference

*/ virtual Model::DescribeRemediationConfigurationsOutcome DescribeRemediationConfigurations(const Model::DescribeRemediationConfigurationsRequest& request) const; /** * A Callable wrapper for DescribeRemediationConfigurations that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeRemediationConfigurationsOutcomeCallable DescribeRemediationConfigurationsCallable(const DescribeRemediationConfigurationsRequestT& request) const { return SubmitCallable(&ConfigServiceClient::DescribeRemediationConfigurations, request); } /** * An Async wrapper for DescribeRemediationConfigurations that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeRemediationConfigurationsAsync(const DescribeRemediationConfigurationsRequestT& request, const DescribeRemediationConfigurationsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ConfigServiceClient::DescribeRemediationConfigurations, request, handler, context); } /** *

Returns the details of one or more remediation exceptions. A detailed view of * a remediation exception for a set of resources that includes an explanation of * an exception and the time when the exception will be deleted. When you specify * the limit and the next token, you receive a paginated response.

*

Config generates a remediation exception when a problem occurs executing a * remediation action to a specific resource. Remediation exceptions blocks * auto-remediation until the exception is cleared.

When you specify the * limit and the next token, you receive a paginated response.

Limit and * next token are not applicable if you request resources in batch. It is only * applicable, when you request all resources.

See Also:

* AWS * API Reference

*/ virtual Model::DescribeRemediationExceptionsOutcome DescribeRemediationExceptions(const Model::DescribeRemediationExceptionsRequest& request) const; /** * A Callable wrapper for DescribeRemediationExceptions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeRemediationExceptionsOutcomeCallable DescribeRemediationExceptionsCallable(const DescribeRemediationExceptionsRequestT& request) const { return SubmitCallable(&ConfigServiceClient::DescribeRemediationExceptions, request); } /** * An Async wrapper for DescribeRemediationExceptions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeRemediationExceptionsAsync(const DescribeRemediationExceptionsRequestT& request, const DescribeRemediationExceptionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ConfigServiceClient::DescribeRemediationExceptions, request, handler, context); } /** *

Provides a detailed view of a Remediation Execution for a set of resources * including state, timestamps for when steps for the remediation execution occur, * and any error messages for steps that have failed. When you specify the limit * and the next token, you receive a paginated response.

See Also:

* AWS * API Reference

*/ virtual Model::DescribeRemediationExecutionStatusOutcome DescribeRemediationExecutionStatus(const Model::DescribeRemediationExecutionStatusRequest& request) const; /** * A Callable wrapper for DescribeRemediationExecutionStatus that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeRemediationExecutionStatusOutcomeCallable DescribeRemediationExecutionStatusCallable(const DescribeRemediationExecutionStatusRequestT& request) const { return SubmitCallable(&ConfigServiceClient::DescribeRemediationExecutionStatus, request); } /** * An Async wrapper for DescribeRemediationExecutionStatus that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeRemediationExecutionStatusAsync(const DescribeRemediationExecutionStatusRequestT& request, const DescribeRemediationExecutionStatusResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ConfigServiceClient::DescribeRemediationExecutionStatus, request, handler, context); } /** *

Returns the details of one or more retention configurations. If the retention * configuration name is not specified, this operation returns the details for all * the retention configurations for that account.

Currently, Config * supports only one retention configuration per region in your account.

*

See Also:

AWS * API Reference

*/ virtual Model::DescribeRetentionConfigurationsOutcome DescribeRetentionConfigurations(const Model::DescribeRetentionConfigurationsRequest& request = {}) const; /** * A Callable wrapper for DescribeRetentionConfigurations that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeRetentionConfigurationsOutcomeCallable DescribeRetentionConfigurationsCallable(const DescribeRetentionConfigurationsRequestT& request = {}) const { return SubmitCallable(&ConfigServiceClient::DescribeRetentionConfigurations, request); } /** * An Async wrapper for DescribeRetentionConfigurations that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeRetentionConfigurationsAsync(const DescribeRetentionConfigurationsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr, const DescribeRetentionConfigurationsRequestT& request = {}) const { return SubmitAsync(&ConfigServiceClient::DescribeRetentionConfigurations, request, handler, context); } /** *

Removes all resource types specified in the ResourceTypes list * from the RecordingGroup * of configuration recorder and excludes these resource types when recording.

*

For this operation, the configuration recorder must use a RecordingStrategy * that is either INCLUSION_BY_RESOURCE_TYPES or * EXCLUSION_BY_RESOURCE_TYPES.

See Also:

AWS * API Reference

*/ virtual Model::DisassociateResourceTypesOutcome DisassociateResourceTypes(const Model::DisassociateResourceTypesRequest& request) const; /** * A Callable wrapper for DisassociateResourceTypes that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DisassociateResourceTypesOutcomeCallable DisassociateResourceTypesCallable(const DisassociateResourceTypesRequestT& request) const { return SubmitCallable(&ConfigServiceClient::DisassociateResourceTypes, request); } /** * An Async wrapper for DisassociateResourceTypes that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DisassociateResourceTypesAsync(const DisassociateResourceTypesRequestT& request, const DisassociateResourceTypesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ConfigServiceClient::DisassociateResourceTypes, request, handler, context); } /** *

Returns the evaluation results for the specified Config rule for a specific * resource in a rule. The results indicate which Amazon Web Services resources * were evaluated by the rule, when each resource was last evaluated, and whether * each resource complies with the rule.

The results can return an * empty result page. But if you have a nextToken, the results are * displayed on the next page.

See Also:

AWS * API Reference

*/ virtual Model::GetAggregateComplianceDetailsByConfigRuleOutcome GetAggregateComplianceDetailsByConfigRule(const Model::GetAggregateComplianceDetailsByConfigRuleRequest& request) const; /** * A Callable wrapper for GetAggregateComplianceDetailsByConfigRule that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetAggregateComplianceDetailsByConfigRuleOutcomeCallable GetAggregateComplianceDetailsByConfigRuleCallable(const GetAggregateComplianceDetailsByConfigRuleRequestT& request) const { return SubmitCallable(&ConfigServiceClient::GetAggregateComplianceDetailsByConfigRule, request); } /** * An Async wrapper for GetAggregateComplianceDetailsByConfigRule that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetAggregateComplianceDetailsByConfigRuleAsync(const GetAggregateComplianceDetailsByConfigRuleRequestT& request, const GetAggregateComplianceDetailsByConfigRuleResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ConfigServiceClient::GetAggregateComplianceDetailsByConfigRule, request, handler, context); } /** *

Returns the number of compliant and noncompliant rules for one or more * accounts and regions in an aggregator.

The results can return an * empty result page, but if you have a nextToken, the results are displayed on the * next page.

See Also:

AWS * API Reference

*/ virtual Model::GetAggregateConfigRuleComplianceSummaryOutcome GetAggregateConfigRuleComplianceSummary(const Model::GetAggregateConfigRuleComplianceSummaryRequest& request) const; /** * A Callable wrapper for GetAggregateConfigRuleComplianceSummary that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetAggregateConfigRuleComplianceSummaryOutcomeCallable GetAggregateConfigRuleComplianceSummaryCallable(const GetAggregateConfigRuleComplianceSummaryRequestT& request) const { return SubmitCallable(&ConfigServiceClient::GetAggregateConfigRuleComplianceSummary, request); } /** * An Async wrapper for GetAggregateConfigRuleComplianceSummary that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetAggregateConfigRuleComplianceSummaryAsync(const GetAggregateConfigRuleComplianceSummaryRequestT& request, const GetAggregateConfigRuleComplianceSummaryResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ConfigServiceClient::GetAggregateConfigRuleComplianceSummary, request, handler, context); } /** *

Returns the count of compliant and noncompliant conformance packs across all * Amazon Web Services accounts and Amazon Web Services Regions in an aggregator. * You can filter based on Amazon Web Services account ID or Amazon Web Services * Region.

The results can return an empty result page, but if you * have a nextToken, the results are displayed on the next page.

*

See Also:

AWS * API Reference

*/ virtual Model::GetAggregateConformancePackComplianceSummaryOutcome GetAggregateConformancePackComplianceSummary(const Model::GetAggregateConformancePackComplianceSummaryRequest& request) const; /** * A Callable wrapper for GetAggregateConformancePackComplianceSummary that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetAggregateConformancePackComplianceSummaryOutcomeCallable GetAggregateConformancePackComplianceSummaryCallable(const GetAggregateConformancePackComplianceSummaryRequestT& request) const { return SubmitCallable(&ConfigServiceClient::GetAggregateConformancePackComplianceSummary, request); } /** * An Async wrapper for GetAggregateConformancePackComplianceSummary that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetAggregateConformancePackComplianceSummaryAsync(const GetAggregateConformancePackComplianceSummaryRequestT& request, const GetAggregateConformancePackComplianceSummaryResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ConfigServiceClient::GetAggregateConformancePackComplianceSummary, request, handler, context); } /** *

Returns the resource counts across accounts and regions that are present in * your Config aggregator. You can request the resource counts by providing filters * and GroupByKey.

For example, if the input contains accountID 12345678910 * and region us-east-1 in filters, the API returns the count of resources in * account ID 12345678910 and region us-east-1. If the input contains ACCOUNT_ID as * a GroupByKey, the API returns resource counts for all source accounts that are * present in your aggregator.

See Also:

AWS * API Reference

*/ virtual Model::GetAggregateDiscoveredResourceCountsOutcome GetAggregateDiscoveredResourceCounts(const Model::GetAggregateDiscoveredResourceCountsRequest& request) const; /** * A Callable wrapper for GetAggregateDiscoveredResourceCounts that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetAggregateDiscoveredResourceCountsOutcomeCallable GetAggregateDiscoveredResourceCountsCallable(const GetAggregateDiscoveredResourceCountsRequestT& request) const { return SubmitCallable(&ConfigServiceClient::GetAggregateDiscoveredResourceCounts, request); } /** * An Async wrapper for GetAggregateDiscoveredResourceCounts that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetAggregateDiscoveredResourceCountsAsync(const GetAggregateDiscoveredResourceCountsRequestT& request, const GetAggregateDiscoveredResourceCountsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ConfigServiceClient::GetAggregateDiscoveredResourceCounts, request, handler, context); } /** *

Returns configuration item that is aggregated for your specific resource in a * specific source account and region.

The API does not return * results for deleted resources.

See Also:

AWS * API Reference

*/ virtual Model::GetAggregateResourceConfigOutcome GetAggregateResourceConfig(const Model::GetAggregateResourceConfigRequest& request) const; /** * A Callable wrapper for GetAggregateResourceConfig that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetAggregateResourceConfigOutcomeCallable GetAggregateResourceConfigCallable(const GetAggregateResourceConfigRequestT& request) const { return SubmitCallable(&ConfigServiceClient::GetAggregateResourceConfig, request); } /** * An Async wrapper for GetAggregateResourceConfig that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetAggregateResourceConfigAsync(const GetAggregateResourceConfigRequestT& request, const GetAggregateResourceConfigResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ConfigServiceClient::GetAggregateResourceConfig, request, handler, context); } /** *

Returns the evaluation results for the specified Config rule. The results * indicate which Amazon Web Services resources were evaluated by the rule, when * each resource was last evaluated, and whether each resource complies with the * rule.

See Also:

AWS * API Reference

*/ virtual Model::GetComplianceDetailsByConfigRuleOutcome GetComplianceDetailsByConfigRule(const Model::GetComplianceDetailsByConfigRuleRequest& request) const; /** * A Callable wrapper for GetComplianceDetailsByConfigRule that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetComplianceDetailsByConfigRuleOutcomeCallable GetComplianceDetailsByConfigRuleCallable(const GetComplianceDetailsByConfigRuleRequestT& request) const { return SubmitCallable(&ConfigServiceClient::GetComplianceDetailsByConfigRule, request); } /** * An Async wrapper for GetComplianceDetailsByConfigRule that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetComplianceDetailsByConfigRuleAsync(const GetComplianceDetailsByConfigRuleRequestT& request, const GetComplianceDetailsByConfigRuleResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ConfigServiceClient::GetComplianceDetailsByConfigRule, request, handler, context); } /** *

Returns the evaluation results for the specified Amazon Web Services * resource. The results indicate which Config rules were used to evaluate the * resource, when each rule was last invoked, and whether the resource complies * with each rule.

See Also:

AWS * API Reference

*/ virtual Model::GetComplianceDetailsByResourceOutcome GetComplianceDetailsByResource(const Model::GetComplianceDetailsByResourceRequest& request = {}) const; /** * A Callable wrapper for GetComplianceDetailsByResource that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetComplianceDetailsByResourceOutcomeCallable GetComplianceDetailsByResourceCallable(const GetComplianceDetailsByResourceRequestT& request = {}) const { return SubmitCallable(&ConfigServiceClient::GetComplianceDetailsByResource, request); } /** * An Async wrapper for GetComplianceDetailsByResource that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetComplianceDetailsByResourceAsync(const GetComplianceDetailsByResourceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr, const GetComplianceDetailsByResourceRequestT& request = {}) const { return SubmitAsync(&ConfigServiceClient::GetComplianceDetailsByResource, request, handler, context); } /** *

Returns the number of Config rules that are compliant and noncompliant, up to * a maximum of 25 for each.

See Also:

AWS * API Reference

*/ virtual Model::GetComplianceSummaryByConfigRuleOutcome GetComplianceSummaryByConfigRule(const Model::GetComplianceSummaryByConfigRuleRequest& request = {}) const; /** * A Callable wrapper for GetComplianceSummaryByConfigRule that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetComplianceSummaryByConfigRuleOutcomeCallable GetComplianceSummaryByConfigRuleCallable(const GetComplianceSummaryByConfigRuleRequestT& request = {}) const { return SubmitCallable(&ConfigServiceClient::GetComplianceSummaryByConfigRule, request); } /** * An Async wrapper for GetComplianceSummaryByConfigRule that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetComplianceSummaryByConfigRuleAsync(const GetComplianceSummaryByConfigRuleResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr, const GetComplianceSummaryByConfigRuleRequestT& request = {}) const { return SubmitAsync(&ConfigServiceClient::GetComplianceSummaryByConfigRule, request, handler, context); } /** *

Returns the number of resources that are compliant and the number that are * noncompliant. You can specify one or more resource types to get these numbers * for each resource type. The maximum number returned is 100.

See * Also:

AWS * API Reference

*/ virtual Model::GetComplianceSummaryByResourceTypeOutcome GetComplianceSummaryByResourceType(const Model::GetComplianceSummaryByResourceTypeRequest& request = {}) const; /** * A Callable wrapper for GetComplianceSummaryByResourceType that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetComplianceSummaryByResourceTypeOutcomeCallable GetComplianceSummaryByResourceTypeCallable(const GetComplianceSummaryByResourceTypeRequestT& request = {}) const { return SubmitCallable(&ConfigServiceClient::GetComplianceSummaryByResourceType, request); } /** * An Async wrapper for GetComplianceSummaryByResourceType that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetComplianceSummaryByResourceTypeAsync(const GetComplianceSummaryByResourceTypeResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr, const GetComplianceSummaryByResourceTypeRequestT& request = {}) const { return SubmitAsync(&ConfigServiceClient::GetComplianceSummaryByResourceType, request, handler, context); } /** *

Returns compliance details of a conformance pack for all Amazon Web Services * resources that are monitered by conformance pack.

See Also:

AWS * API Reference

*/ virtual Model::GetConformancePackComplianceDetailsOutcome GetConformancePackComplianceDetails(const Model::GetConformancePackComplianceDetailsRequest& request) const; /** * A Callable wrapper for GetConformancePackComplianceDetails that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetConformancePackComplianceDetailsOutcomeCallable GetConformancePackComplianceDetailsCallable(const GetConformancePackComplianceDetailsRequestT& request) const { return SubmitCallable(&ConfigServiceClient::GetConformancePackComplianceDetails, request); } /** * An Async wrapper for GetConformancePackComplianceDetails that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetConformancePackComplianceDetailsAsync(const GetConformancePackComplianceDetailsRequestT& request, const GetConformancePackComplianceDetailsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ConfigServiceClient::GetConformancePackComplianceDetails, request, handler, context); } /** *

Returns compliance details for the conformance pack based on the cumulative * compliance results of all the rules in that conformance pack.

See * Also:

AWS * API Reference

*/ virtual Model::GetConformancePackComplianceSummaryOutcome GetConformancePackComplianceSummary(const Model::GetConformancePackComplianceSummaryRequest& request) const; /** * A Callable wrapper for GetConformancePackComplianceSummary that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetConformancePackComplianceSummaryOutcomeCallable GetConformancePackComplianceSummaryCallable(const GetConformancePackComplianceSummaryRequestT& request) const { return SubmitCallable(&ConfigServiceClient::GetConformancePackComplianceSummary, request); } /** * An Async wrapper for GetConformancePackComplianceSummary that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetConformancePackComplianceSummaryAsync(const GetConformancePackComplianceSummaryRequestT& request, const GetConformancePackComplianceSummaryResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ConfigServiceClient::GetConformancePackComplianceSummary, request, handler, context); } /** *

Returns the policy definition containing the logic for your Config Custom * Policy rule.

See Also:

AWS * API Reference

*/ virtual Model::GetCustomRulePolicyOutcome GetCustomRulePolicy(const Model::GetCustomRulePolicyRequest& request = {}) const; /** * A Callable wrapper for GetCustomRulePolicy that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetCustomRulePolicyOutcomeCallable GetCustomRulePolicyCallable(const GetCustomRulePolicyRequestT& request = {}) const { return SubmitCallable(&ConfigServiceClient::GetCustomRulePolicy, request); } /** * An Async wrapper for GetCustomRulePolicy that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetCustomRulePolicyAsync(const GetCustomRulePolicyResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr, const GetCustomRulePolicyRequestT& request = {}) const { return SubmitAsync(&ConfigServiceClient::GetCustomRulePolicy, request, handler, context); } /** *

Returns the resource types, the number of each resource type, and the total * number of resources that Config is recording in this region for your Amazon Web * Services account.

Example

  1. Config * is recording three resource types in the US East (Ohio) Region for your account: * 25 EC2 instances, 20 IAM users, and 15 S3 buckets.

  2. You make a * call to the GetDiscoveredResourceCounts action and specify that you * want all resource types.

  3. Config returns the following:

    *

    • The resource types (EC2 instances, IAM users, and S3 buckets).

      *

    • The number of each resource type (25, 20, and 15).

    • *

      The total number of all resources (60).

The * response is paginated. By default, Config lists 100 ResourceCount objects * on each page. You can customize this number with the limit * parameter. The response includes a nextToken string. To get the * next page of results, run the request again and specify the string for the * nextToken parameter.

If you make a call to the * GetDiscoveredResourceCounts action, you might not immediately receive * resource counts in the following situations:

  • You are a new * Config customer.

  • You just enabled resource recording.

    *

It might take a few minutes for Config to record and count your * resources. Wait a few minutes and then retry the * GetDiscoveredResourceCounts action.

See Also:

* AWS * API Reference

*/ virtual Model::GetDiscoveredResourceCountsOutcome GetDiscoveredResourceCounts(const Model::GetDiscoveredResourceCountsRequest& request = {}) const; /** * A Callable wrapper for GetDiscoveredResourceCounts that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetDiscoveredResourceCountsOutcomeCallable GetDiscoveredResourceCountsCallable(const GetDiscoveredResourceCountsRequestT& request = {}) const { return SubmitCallable(&ConfigServiceClient::GetDiscoveredResourceCounts, request); } /** * An Async wrapper for GetDiscoveredResourceCounts that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetDiscoveredResourceCountsAsync(const GetDiscoveredResourceCountsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr, const GetDiscoveredResourceCountsRequestT& request = {}) const { return SubmitAsync(&ConfigServiceClient::GetDiscoveredResourceCounts, request, handler, context); } /** *

Returns detailed status for each member account within an organization for a * given organization Config rule.

See Also:

AWS * API Reference

*/ virtual Model::GetOrganizationConfigRuleDetailedStatusOutcome GetOrganizationConfigRuleDetailedStatus(const Model::GetOrganizationConfigRuleDetailedStatusRequest& request) const; /** * A Callable wrapper for GetOrganizationConfigRuleDetailedStatus that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetOrganizationConfigRuleDetailedStatusOutcomeCallable GetOrganizationConfigRuleDetailedStatusCallable(const GetOrganizationConfigRuleDetailedStatusRequestT& request) const { return SubmitCallable(&ConfigServiceClient::GetOrganizationConfigRuleDetailedStatus, request); } /** * An Async wrapper for GetOrganizationConfigRuleDetailedStatus that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetOrganizationConfigRuleDetailedStatusAsync(const GetOrganizationConfigRuleDetailedStatusRequestT& request, const GetOrganizationConfigRuleDetailedStatusResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ConfigServiceClient::GetOrganizationConfigRuleDetailedStatus, request, handler, context); } /** *

Returns detailed status for each member account within an organization for a * given organization conformance pack.

See Also:

AWS * API Reference

*/ virtual Model::GetOrganizationConformancePackDetailedStatusOutcome GetOrganizationConformancePackDetailedStatus(const Model::GetOrganizationConformancePackDetailedStatusRequest& request) const; /** * A Callable wrapper for GetOrganizationConformancePackDetailedStatus that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetOrganizationConformancePackDetailedStatusOutcomeCallable GetOrganizationConformancePackDetailedStatusCallable(const GetOrganizationConformancePackDetailedStatusRequestT& request) const { return SubmitCallable(&ConfigServiceClient::GetOrganizationConformancePackDetailedStatus, request); } /** * An Async wrapper for GetOrganizationConformancePackDetailedStatus that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetOrganizationConformancePackDetailedStatusAsync(const GetOrganizationConformancePackDetailedStatusRequestT& request, const GetOrganizationConformancePackDetailedStatusResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ConfigServiceClient::GetOrganizationConformancePackDetailedStatus, request, handler, context); } /** *

Returns the policy definition containing the logic for your organization * Config Custom Policy rule.

See Also:

AWS * API Reference

*/ virtual Model::GetOrganizationCustomRulePolicyOutcome GetOrganizationCustomRulePolicy(const Model::GetOrganizationCustomRulePolicyRequest& request) const; /** * A Callable wrapper for GetOrganizationCustomRulePolicy that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetOrganizationCustomRulePolicyOutcomeCallable GetOrganizationCustomRulePolicyCallable(const GetOrganizationCustomRulePolicyRequestT& request) const { return SubmitCallable(&ConfigServiceClient::GetOrganizationCustomRulePolicy, request); } /** * An Async wrapper for GetOrganizationCustomRulePolicy that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetOrganizationCustomRulePolicyAsync(const GetOrganizationCustomRulePolicyRequestT& request, const GetOrganizationCustomRulePolicyResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ConfigServiceClient::GetOrganizationCustomRulePolicy, request, handler, context); } /** *

For accurate reporting on the compliance status, you must record * the AWS::Config::ResourceCompliance resource type. For more * information, see Selecting * Which Resources Config Records.

Returns a list of * ConfigurationItems for the specified resource. The list contains * details about each state of the resource during the specified time interval. If * you specified a retention period to retain your ConfigurationItems * between a minimum of 30 days and a maximum of 7 years (2557 days), Config * returns the ConfigurationItems for the specified retention period. *

The response is paginated. By default, Config returns a limit of 10 * configuration items per page. You can customize this number with the * limit parameter. The response includes a nextToken * string. To get the next page of results, run the request again and specify the * string for the nextToken parameter.

Each call to the * API is limited to span a duration of seven days. It is likely that the number of * records returned is smaller than the specified limit. In such * cases, you can make another call, using the nextToken.

*

See Also:

AWS * API Reference

*/ virtual Model::GetResourceConfigHistoryOutcome GetResourceConfigHistory(const Model::GetResourceConfigHistoryRequest& request) const; /** * A Callable wrapper for GetResourceConfigHistory that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetResourceConfigHistoryOutcomeCallable GetResourceConfigHistoryCallable(const GetResourceConfigHistoryRequestT& request) const { return SubmitCallable(&ConfigServiceClient::GetResourceConfigHistory, request); } /** * An Async wrapper for GetResourceConfigHistory that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetResourceConfigHistoryAsync(const GetResourceConfigHistoryRequestT& request, const GetResourceConfigHistoryResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ConfigServiceClient::GetResourceConfigHistory, request, handler, context); } /** *

Returns a summary of resource evaluation for the specified resource * evaluation ID from the proactive rules that were run. The results indicate which * evaluation context was used to evaluate the rules, which resource details were * evaluated, the evaluation mode that was run, and whether the resource details * comply with the configuration of the proactive rules.

To see * additional information about the evaluation result, such as which rule flagged a * resource as NON_COMPLIANT, use the GetComplianceDetailsByResource * API. For more information, see the Examples * section.

See Also:

AWS * API Reference

*/ virtual Model::GetResourceEvaluationSummaryOutcome GetResourceEvaluationSummary(const Model::GetResourceEvaluationSummaryRequest& request) const; /** * A Callable wrapper for GetResourceEvaluationSummary that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetResourceEvaluationSummaryOutcomeCallable GetResourceEvaluationSummaryCallable(const GetResourceEvaluationSummaryRequestT& request) const { return SubmitCallable(&ConfigServiceClient::GetResourceEvaluationSummary, request); } /** * An Async wrapper for GetResourceEvaluationSummary that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetResourceEvaluationSummaryAsync(const GetResourceEvaluationSummaryRequestT& request, const GetResourceEvaluationSummaryResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ConfigServiceClient::GetResourceEvaluationSummary, request, handler, context); } /** *

Returns the details of a specific stored query.

See Also:

AWS * API Reference

*/ virtual Model::GetStoredQueryOutcome GetStoredQuery(const Model::GetStoredQueryRequest& request) const; /** * A Callable wrapper for GetStoredQuery that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetStoredQueryOutcomeCallable GetStoredQueryCallable(const GetStoredQueryRequestT& request) const { return SubmitCallable(&ConfigServiceClient::GetStoredQuery, request); } /** * An Async wrapper for GetStoredQuery that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetStoredQueryAsync(const GetStoredQueryRequestT& request, const GetStoredQueryResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ConfigServiceClient::GetStoredQuery, request, handler, context); } /** *

Accepts a resource type and returns a list of resource identifiers that are * aggregated for a specific resource type across accounts and regions. A resource * identifier includes the resource type, ID, (if available) the custom resource * name, source account, and source region. You can narrow the results to include * only resources that have specific resource IDs, or a resource name, or source * account ID, or source region.

For example, if the input consists of * accountID 12345678910 and the region is us-east-1 for resource type * AWS::EC2::Instance then the API returns all the EC2 instance * identifiers of accountID 12345678910 and region us-east-1.

See * Also:

AWS * API Reference

*/ virtual Model::ListAggregateDiscoveredResourcesOutcome ListAggregateDiscoveredResources(const Model::ListAggregateDiscoveredResourcesRequest& request) const; /** * A Callable wrapper for ListAggregateDiscoveredResources that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListAggregateDiscoveredResourcesOutcomeCallable ListAggregateDiscoveredResourcesCallable(const ListAggregateDiscoveredResourcesRequestT& request) const { return SubmitCallable(&ConfigServiceClient::ListAggregateDiscoveredResources, request); } /** * An Async wrapper for ListAggregateDiscoveredResources that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListAggregateDiscoveredResourcesAsync(const ListAggregateDiscoveredResourcesRequestT& request, const ListAggregateDiscoveredResourcesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ConfigServiceClient::ListAggregateDiscoveredResources, request, handler, context); } /** *

Returns a list of configuration recorders depending on the filters you * specify.

See Also:

AWS * API Reference

*/ virtual Model::ListConfigurationRecordersOutcome ListConfigurationRecorders(const Model::ListConfigurationRecordersRequest& request = {}) const; /** * A Callable wrapper for ListConfigurationRecorders that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListConfigurationRecordersOutcomeCallable ListConfigurationRecordersCallable(const ListConfigurationRecordersRequestT& request = {}) const { return SubmitCallable(&ConfigServiceClient::ListConfigurationRecorders, request); } /** * An Async wrapper for ListConfigurationRecorders that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListConfigurationRecordersAsync(const ListConfigurationRecordersResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr, const ListConfigurationRecordersRequestT& request = {}) const { return SubmitAsync(&ConfigServiceClient::ListConfigurationRecorders, request, handler, context); } /** *

Returns a list of conformance pack compliance scores. A compliance score is * the percentage of the number of compliant rule-resource combinations in a * conformance pack compared to the number of total possible rule-resource * combinations in the conformance pack. This metric provides you with a high-level * view of the compliance state of your conformance packs. You can use it to * identify, investigate, and understand the level of compliance in your * conformance packs.

Conformance packs with no evaluation results * will have a compliance score of INSUFFICIENT_DATA.

*

See Also:

AWS * API Reference

*/ virtual Model::ListConformancePackComplianceScoresOutcome ListConformancePackComplianceScores(const Model::ListConformancePackComplianceScoresRequest& request = {}) const; /** * A Callable wrapper for ListConformancePackComplianceScores that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListConformancePackComplianceScoresOutcomeCallable ListConformancePackComplianceScoresCallable(const ListConformancePackComplianceScoresRequestT& request = {}) const { return SubmitCallable(&ConfigServiceClient::ListConformancePackComplianceScores, request); } /** * An Async wrapper for ListConformancePackComplianceScores that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListConformancePackComplianceScoresAsync(const ListConformancePackComplianceScoresResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr, const ListConformancePackComplianceScoresRequestT& request = {}) const { return SubmitAsync(&ConfigServiceClient::ListConformancePackComplianceScores, request, handler, context); } /** *

Accepts a resource type and returns a list of resource identifiers for the * resources of that type. A resource identifier includes the resource type, ID, * and (if available) the custom resource name. The results consist of resources * that Config has discovered, including those that Config is not currently * recording. You can narrow the results to include only resources that have * specific resource IDs or a resource name.

You can specify either * resource IDs or a resource name, but not both, in the same request.

*

The response is paginated. By default, Config lists 100 resource identifiers * on each page. You can customize this number with the limit * parameter. The response includes a nextToken string. To get the * next page of results, run the request again and specify the string for the * nextToken parameter.

See Also:

AWS * API Reference

*/ virtual Model::ListDiscoveredResourcesOutcome ListDiscoveredResources(const Model::ListDiscoveredResourcesRequest& request) const; /** * A Callable wrapper for ListDiscoveredResources that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListDiscoveredResourcesOutcomeCallable ListDiscoveredResourcesCallable(const ListDiscoveredResourcesRequestT& request) const { return SubmitCallable(&ConfigServiceClient::ListDiscoveredResources, request); } /** * An Async wrapper for ListDiscoveredResources that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListDiscoveredResourcesAsync(const ListDiscoveredResourcesRequestT& request, const ListDiscoveredResourcesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ConfigServiceClient::ListDiscoveredResources, request, handler, context); } /** *

Returns a list of proactive resource evaluations.

See Also:

* AWS * API Reference

*/ virtual Model::ListResourceEvaluationsOutcome ListResourceEvaluations(const Model::ListResourceEvaluationsRequest& request = {}) const; /** * A Callable wrapper for ListResourceEvaluations that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListResourceEvaluationsOutcomeCallable ListResourceEvaluationsCallable(const ListResourceEvaluationsRequestT& request = {}) const { return SubmitCallable(&ConfigServiceClient::ListResourceEvaluations, request); } /** * An Async wrapper for ListResourceEvaluations that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListResourceEvaluationsAsync(const ListResourceEvaluationsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr, const ListResourceEvaluationsRequestT& request = {}) const { return SubmitAsync(&ConfigServiceClient::ListResourceEvaluations, request, handler, context); } /** *

Lists the stored queries for a single Amazon Web Services account and a * single Amazon Web Services Region. The default is 100.

See Also:

* AWS * API Reference

*/ virtual Model::ListStoredQueriesOutcome ListStoredQueries(const Model::ListStoredQueriesRequest& request = {}) const; /** * A Callable wrapper for ListStoredQueries that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListStoredQueriesOutcomeCallable ListStoredQueriesCallable(const ListStoredQueriesRequestT& request = {}) const { return SubmitCallable(&ConfigServiceClient::ListStoredQueries, request); } /** * An Async wrapper for ListStoredQueries that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListStoredQueriesAsync(const ListStoredQueriesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr, const ListStoredQueriesRequestT& request = {}) const { return SubmitAsync(&ConfigServiceClient::ListStoredQueries, request, handler, context); } /** *

List the tags for Config 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(&ConfigServiceClient::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(&ConfigServiceClient::ListTagsForResource, request, handler, context); } /** *

Authorizes the aggregator account and region to collect data from the source * account and region.

Tags are added at creation and cannot be * updated with this operation

* PutAggregationAuthorization is an idempotent API. Subsequent * requests won’t create a duplicate resource if one was already created. If a * following request has different tags values, Config will ignore * these differences and treat it as an idempotent request of the previous. In this * case, tags will not be updated, even if they are different.

*

Use TagResource * and UntagResource * to update tags after creation.

See Also:

AWS * API Reference

*/ virtual Model::PutAggregationAuthorizationOutcome PutAggregationAuthorization(const Model::PutAggregationAuthorizationRequest& request) const; /** * A Callable wrapper for PutAggregationAuthorization that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutAggregationAuthorizationOutcomeCallable PutAggregationAuthorizationCallable(const PutAggregationAuthorizationRequestT& request) const { return SubmitCallable(&ConfigServiceClient::PutAggregationAuthorization, request); } /** * An Async wrapper for PutAggregationAuthorization that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutAggregationAuthorizationAsync(const PutAggregationAuthorizationRequestT& request, const PutAggregationAuthorizationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ConfigServiceClient::PutAggregationAuthorization, request, handler, context); } /** *

Adds or updates an Config rule to evaluate if your Amazon Web Services * resources comply with your desired configurations. For information on how many * Config rules you can have per account, see * Service Limits in the Config Developer Guide.

There * are two types of rules: Config Managed Rules and Config Custom * Rules. You can use PutConfigRule to create both Config Managed * Rules and Config Custom Rules.

Config Managed Rules are predefined, * customizable rules created by Config. For a list of managed rules, see List * of Config Managed Rules. If you are adding an Config managed rule, you must * specify the rule's identifier for the SourceIdentifier key.

*

Config Custom Rules are rules that you create from scratch. There are two * ways to create Config custom rules: with Lambda functions ( * Lambda Developer Guide) and with Guard (Guard GitHub * Repository), a policy-as-code language. Config custom rules created with * Lambda are called Config Custom Lambda Rules and Config custom rules * created with Guard are called Config Custom Policy Rules.

If you * are adding a new Config Custom Lambda rule, you first need to create an Lambda * function that the rule invokes to evaluate your resources. When you use * PutConfigRule to add a Custom Lambda rule to Config, you must * specify the Amazon Resource Name (ARN) that Lambda assigns to the function. You * specify the ARN in the SourceIdentifier key. This key is part of * the Source object, which is part of the ConfigRule * object.

For any new Config rule that you add, specify the * ConfigRuleName in the ConfigRule object. Do not * specify the ConfigRuleArn or the ConfigRuleId. These * values are generated by Config for new rules.

If you are updating a rule * that you added previously, you can specify the rule by * ConfigRuleName, ConfigRuleId, or * ConfigRuleArn in the ConfigRule data type that you use * in this request.

For more information about developing and using Config * rules, see Evaluating * Resources with Config Rules in the Config Developer Guide.

*

Tags are added at creation and cannot be updated with this operation *

PutConfigRule is an idempotent API. Subsequent requests * won’t create a duplicate resource if one was already created. If a following * request has different tags values, Config will ignore these * differences and treat it as an idempotent request of the previous. In this case, * tags will not be updated, even if they are different.

Use TagResource * and UntagResource * to update tags after creation.

See Also:

AWS * API Reference

*/ virtual Model::PutConfigRuleOutcome PutConfigRule(const Model::PutConfigRuleRequest& request) const; /** * A Callable wrapper for PutConfigRule that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutConfigRuleOutcomeCallable PutConfigRuleCallable(const PutConfigRuleRequestT& request) const { return SubmitCallable(&ConfigServiceClient::PutConfigRule, request); } /** * An Async wrapper for PutConfigRule that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutConfigRuleAsync(const PutConfigRuleRequestT& request, const PutConfigRuleResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ConfigServiceClient::PutConfigRule, request, handler, context); } /** *

Creates and updates the configuration aggregator with the selected source * accounts and regions. The source account can be individual account(s) or an * organization.

accountIds that are passed will be replaced * with existing accounts. If you want to add additional accounts into the * aggregator, call DescribeConfigurationAggregators to get the * previous accounts and then append new ones.

Config should be * enabled in source accounts and regions you want to aggregate.

If your * source type is an organization, you must be signed in to the management account * or a registered delegated administrator and all the features must be enabled in * your organization. If the caller is a management account, Config calls * EnableAwsServiceAccess API to enable integration between Config and * Organizations. If the caller is a registered delegated administrator, Config * calls ListDelegatedAdministrators API to verify whether the caller * is a valid delegated administrator.

To register a delegated * administrator, see Register * a Delegated Administrator in the Config developer guide.

*

Tags are added at creation and cannot be updated with this * operation

PutConfigurationAggregator is an idempotent * API. Subsequent requests won’t create a duplicate resource if one was already * created. If a following request has different tags values, Config * will ignore these differences and treat it as an idempotent request of the * previous. In this case, tags will not be updated, even if they are * different.

Use TagResource * and UntagResource * to update tags after creation.

See Also:

AWS * API Reference

*/ virtual Model::PutConfigurationAggregatorOutcome PutConfigurationAggregator(const Model::PutConfigurationAggregatorRequest& request) const; /** * A Callable wrapper for PutConfigurationAggregator that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutConfigurationAggregatorOutcomeCallable PutConfigurationAggregatorCallable(const PutConfigurationAggregatorRequestT& request) const { return SubmitCallable(&ConfigServiceClient::PutConfigurationAggregator, request); } /** * An Async wrapper for PutConfigurationAggregator that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutConfigurationAggregatorAsync(const PutConfigurationAggregatorRequestT& request, const PutConfigurationAggregatorResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ConfigServiceClient::PutConfigurationAggregator, request, handler, context); } /** *

Creates or updates the customer managed configuration recorder.

You * can use this operation to create a new customer managed configuration recorder * or to update the roleARN and the recordingGroup for an * existing customer managed configuration recorder.

To start the customer * managed configuration recorder and begin recording configuration changes for the * resource types you specify, use the StartConfigurationRecorder * operation.

For more information, see * Working with the Configuration Recorder in the Config Developer * Guide.

One customer managed configuration recorder per * account per Region

You can create only one customer managed * configuration recorder for each account for each Amazon Web Services Region.

*

Default is to record all supported resource types, excluding the global * IAM resource types

If you have not specified values for the * recordingGroup field, the default for the customer managed * configuration recorder is to record all supported resource types, excluding the * global IAM resource types: AWS::IAM::Group, * AWS::IAM::Policy, AWS::IAM::Role, and * AWS::IAM::User.

Tags are added at creation and cannot be * updated

PutConfigurationRecorder is an idempotent API. * Subsequent requests won’t create a duplicate resource if one was already * created. If a following request has different tags values, Config will ignore * these differences and treat it as an idempotent request of the previous. In this * case, tags will not be updated, even if they are different.

Use TagResource * and UntagResource * to update tags after creation.

See Also:

AWS * API Reference

*/ virtual Model::PutConfigurationRecorderOutcome PutConfigurationRecorder(const Model::PutConfigurationRecorderRequest& request) const; /** * A Callable wrapper for PutConfigurationRecorder that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutConfigurationRecorderOutcomeCallable PutConfigurationRecorderCallable(const PutConfigurationRecorderRequestT& request) const { return SubmitCallable(&ConfigServiceClient::PutConfigurationRecorder, request); } /** * An Async wrapper for PutConfigurationRecorder that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutConfigurationRecorderAsync(const PutConfigurationRecorderRequestT& request, const PutConfigurationRecorderResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ConfigServiceClient::PutConfigurationRecorder, request, handler, context); } /** *

Creates or updates a conformance pack. A conformance pack is a collection of * Config rules that can be easily deployed in an account and a region and across * an organization. For information on how many conformance packs you can have per * account, see * Service Limits in the Config Developer Guide.

This API * creates a service-linked role AWSServiceRoleForConfigConforms in * your account. The service-linked role is created only when the role does not * exist in your account.

You must specify only one of the follow * parameters: TemplateS3Uri, TemplateBody or * TemplateSSMDocumentDetails.

See Also:

AWS * API Reference

*/ virtual Model::PutConformancePackOutcome PutConformancePack(const Model::PutConformancePackRequest& request) const; /** * A Callable wrapper for PutConformancePack that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutConformancePackOutcomeCallable PutConformancePackCallable(const PutConformancePackRequestT& request) const { return SubmitCallable(&ConfigServiceClient::PutConformancePack, request); } /** * An Async wrapper for PutConformancePack that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutConformancePackAsync(const PutConformancePackRequestT& request, const PutConformancePackResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ConfigServiceClient::PutConformancePack, request, handler, context); } /** *

Creates or updates a delivery channel to deliver configuration information * and other compliance information.

You can use this operation to create a * new delivery channel or to update the Amazon S3 bucket and the Amazon SNS topic * of an existing delivery channel.

For more information, see * Working with the Delivery Channel in the Config Developer * Guide.

One delivery channel per account per Region *

You can have only one delivery channel for each account for each Amazon * Web Services Region.

See Also:

AWS * API Reference

*/ virtual Model::PutDeliveryChannelOutcome PutDeliveryChannel(const Model::PutDeliveryChannelRequest& request) const; /** * A Callable wrapper for PutDeliveryChannel that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutDeliveryChannelOutcomeCallable PutDeliveryChannelCallable(const PutDeliveryChannelRequestT& request) const { return SubmitCallable(&ConfigServiceClient::PutDeliveryChannel, request); } /** * An Async wrapper for PutDeliveryChannel that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutDeliveryChannelAsync(const PutDeliveryChannelRequestT& request, const PutDeliveryChannelResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ConfigServiceClient::PutDeliveryChannel, request, handler, context); } /** *

Used by an Lambda function to deliver evaluation results to Config. This * operation is required in every Lambda function that is invoked by an Config * rule.

See Also:

AWS * API Reference

*/ virtual Model::PutEvaluationsOutcome PutEvaluations(const Model::PutEvaluationsRequest& request) const; /** * A Callable wrapper for PutEvaluations that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutEvaluationsOutcomeCallable PutEvaluationsCallable(const PutEvaluationsRequestT& request) const { return SubmitCallable(&ConfigServiceClient::PutEvaluations, request); } /** * An Async wrapper for PutEvaluations that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutEvaluationsAsync(const PutEvaluationsRequestT& request, const PutEvaluationsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ConfigServiceClient::PutEvaluations, request, handler, context); } /** *

Add or updates the evaluations for process checks. This API checks if the * rule is a process check when the name of the Config rule is * provided.

See Also:

AWS * API Reference

*/ virtual Model::PutExternalEvaluationOutcome PutExternalEvaluation(const Model::PutExternalEvaluationRequest& request) const; /** * A Callable wrapper for PutExternalEvaluation that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutExternalEvaluationOutcomeCallable PutExternalEvaluationCallable(const PutExternalEvaluationRequestT& request) const { return SubmitCallable(&ConfigServiceClient::PutExternalEvaluation, request); } /** * An Async wrapper for PutExternalEvaluation that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutExternalEvaluationAsync(const PutExternalEvaluationRequestT& request, const PutExternalEvaluationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ConfigServiceClient::PutExternalEvaluation, request, handler, context); } /** *

Adds or updates an Config rule for your entire organization to evaluate if * your Amazon Web Services resources comply with your desired configurations. For * information on how many organization Config rules you can have per account, see * * Service Limits in the Config Developer Guide.

Only a * management account and a delegated administrator can create or update an * organization Config rule. When calling this API with a delegated administrator, * you must ensure Organizations ListDelegatedAdministrator * permissions are added. An organization can have up to 3 delegated * administrators.

This API enables organization service access through the * EnableAWSServiceAccess action and creates a service-linked role * AWSServiceRoleForConfigMultiAccountSetup in the management or * delegated administrator account of your organization. The service-linked role is * created only when the role does not exist in the caller account. Config verifies * the existence of role with GetRole action.

To use this API * with delegated administrator, register a delegated administrator by calling * Amazon Web Services Organization register-delegated-administrator * for config-multiaccountsetup.amazonaws.com.

There are two * types of rules: Config Managed Rules and Config Custom Rules. You * can use PutOrganizationConfigRule to create both Config Managed * Rules and Config Custom Rules.

Config Managed Rules are predefined, * customizable rules created by Config. For a list of managed rules, see List * of Config Managed Rules. If you are adding an Config managed rule, you must * specify the rule's identifier for the RuleIdentifier key.

*

Config Custom Rules are rules that you create from scratch. There are two * ways to create Config custom rules: with Lambda functions ( * Lambda Developer Guide) and with Guard (Guard GitHub * Repository), a policy-as-code language. Config custom rules created with * Lambda are called Config Custom Lambda Rules and Config custom rules * created with Guard are called Config Custom Policy Rules.

If you * are adding a new Config Custom Lambda rule, you first need to create an Lambda * function in the management account or a delegated administrator that the rule * invokes to evaluate your resources. You also need to create an IAM role in the * managed account that can be assumed by the Lambda function. When you use * PutOrganizationConfigRule to add a Custom Lambda rule to Config, * you must specify the Amazon Resource Name (ARN) that Lambda assigns to the * function.

Prerequisite: Ensure you call * EnableAllFeatures API to enable all features in an * organization.

Make sure to specify one of either * OrganizationCustomPolicyRuleMetadata for Custom Policy rules, * OrganizationCustomRuleMetadata for Custom Lambda rules, or * OrganizationManagedRuleMetadata for managed rules.

*

See Also:

AWS * API Reference

*/ virtual Model::PutOrganizationConfigRuleOutcome PutOrganizationConfigRule(const Model::PutOrganizationConfigRuleRequest& request) const; /** * A Callable wrapper for PutOrganizationConfigRule that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutOrganizationConfigRuleOutcomeCallable PutOrganizationConfigRuleCallable(const PutOrganizationConfigRuleRequestT& request) const { return SubmitCallable(&ConfigServiceClient::PutOrganizationConfigRule, request); } /** * An Async wrapper for PutOrganizationConfigRule that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutOrganizationConfigRuleAsync(const PutOrganizationConfigRuleRequestT& request, const PutOrganizationConfigRuleResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ConfigServiceClient::PutOrganizationConfigRule, request, handler, context); } /** *

Deploys conformance packs across member accounts in an Amazon Web Services * Organization. For information on how many organization conformance packs and how * many Config rules you can have per account, see * Service Limits in the Config Developer Guide.

Only a * management account and a delegated administrator can call this API. When calling * this API with a delegated administrator, you must ensure Organizations * ListDelegatedAdministrator permissions are added. An organization * can have up to 3 delegated administrators.

This API enables organization * service access for config-multiaccountsetup.amazonaws.com through * the EnableAWSServiceAccess action and creates a service-linked role * AWSServiceRoleForConfigMultiAccountSetup in the management or * delegated administrator account of your organization. The service-linked role is * created only when the role does not exist in the caller account. To use this API * with delegated administrator, register a delegated administrator by calling * Amazon Web Services Organization register-delegate-admin for * config-multiaccountsetup.amazonaws.com.

Prerequisite: * Ensure you call EnableAllFeatures API to enable all features in an * organization.

You must specify either the TemplateS3Uri or * the TemplateBody parameter, but not both. If you provide both * Config uses the TemplateS3Uri parameter and ignores the * TemplateBody parameter.

Config sets the state of a * conformance pack to CREATE_IN_PROGRESS and UPDATE_IN_PROGRESS until the * conformance pack is created or updated. You cannot update a conformance pack * while it is in this state.

See Also:

AWS * API Reference

*/ virtual Model::PutOrganizationConformancePackOutcome PutOrganizationConformancePack(const Model::PutOrganizationConformancePackRequest& request) const; /** * A Callable wrapper for PutOrganizationConformancePack that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutOrganizationConformancePackOutcomeCallable PutOrganizationConformancePackCallable(const PutOrganizationConformancePackRequestT& request) const { return SubmitCallable(&ConfigServiceClient::PutOrganizationConformancePack, request); } /** * An Async wrapper for PutOrganizationConformancePack that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutOrganizationConformancePackAsync(const PutOrganizationConformancePackRequestT& request, const PutOrganizationConformancePackResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ConfigServiceClient::PutOrganizationConformancePack, request, handler, context); } /** *

Adds or updates the remediation configuration with a specific Config rule * with the selected target or action. The API creates the * RemediationConfiguration object for the Config rule. The Config * rule must already exist for you to add a remediation configuration. The target * (SSM document) must exist and have permissions to use the target.

*

Be aware of backward incompatible changes

If you make * backward incompatible changes to the SSM document, you must call this again to * ensure the remediations can run.

This API does not support adding * remediation configurations for service-linked Config Rules such as Organization * Config rules, the rules deployed by conformance packs, and rules deployed by * Amazon Web Services Security Hub.

Required fields *

For manual remediation configuration, you need to provide a value for * automationAssumeRole or use a value in the * assumeRolefield to remediate your resources. The SSM automation * document can use either as long as it maps to a valid parameter.

However, * for automatic remediation configuration, the only valid assumeRole * field value is AutomationAssumeRole and you need to provide a value * for AutomationAssumeRole to remediate your resources.

*

Auto remediation can be initiated even for compliant resources *

If you enable auto remediation for a specific Config rule using the PutRemediationConfigurations * API or the Config console, it initiates the remediation process for all * non-compliant resources for that specific rule. The auto remediation process * relies on the compliance data snapshot which is captured on a periodic basis. * Any non-compliant resource that is updated between the snapshot schedule will * continue to be remediated based on the last known compliance data snapshot.

*

This means that in some cases auto remediation can be initiated even for * compliant resources, since the bootstrap processor uses a database that can have * stale evaluation results based on the last known compliance data snapshot.

*

See Also:

AWS * API Reference

*/ virtual Model::PutRemediationConfigurationsOutcome PutRemediationConfigurations(const Model::PutRemediationConfigurationsRequest& request) const; /** * A Callable wrapper for PutRemediationConfigurations that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutRemediationConfigurationsOutcomeCallable PutRemediationConfigurationsCallable(const PutRemediationConfigurationsRequestT& request) const { return SubmitCallable(&ConfigServiceClient::PutRemediationConfigurations, request); } /** * An Async wrapper for PutRemediationConfigurations that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutRemediationConfigurationsAsync(const PutRemediationConfigurationsRequestT& request, const PutRemediationConfigurationsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ConfigServiceClient::PutRemediationConfigurations, request, handler, context); } /** *

A remediation exception is when a specified resource is no longer considered * for auto-remediation. This API adds a new exception or updates an existing * exception for a specified resource with a specified Config rule.

* Exceptions block auto remediation

Config generates a remediation * exception when a problem occurs running a remediation action for a specified * resource. Remediation exceptions blocks auto-remediation until the exception is * cleared.

Manual remediation is recommended when * placing an exception

When placing an exception on an Amazon Web * Services resource, it is recommended that remediation is set as manual * remediation until the given Config rule for the specified resource evaluates the * resource as NON_COMPLIANT. Once the resource has been evaluated as * NON_COMPLIANT, you can add remediation exceptions and change the * remediation type back from Manual to Auto if you want to use auto-remediation. * Otherwise, using auto-remediation before a NON_COMPLIANT evaluation * result can delete resources before the exception is applied.

*

Exceptions can only be performed on non-compliant resources

*

Placing an exception can only be performed on resources that are * NON_COMPLIANT. If you use this API for COMPLIANT * resources or resources that are NOT_APPLICABLE, a remediation * exception will not be generated. For more information on the conditions that * initiate the possible Config evaluation results, see Concepts * | Config Rules in the Config Developer Guide.

* Exceptions cannot be placed on service-linked remediation actions

*

You cannot place an exception on service-linked remediation actions, such as * remediation actions put by an organizational conformance pack.

*

Auto remediation can be initiated even for compliant resources *

If you enable auto remediation for a specific Config rule using the PutRemediationConfigurations * API or the Config console, it initiates the remediation process for all * non-compliant resources for that specific rule. The auto remediation process * relies on the compliance data snapshot which is captured on a periodic basis. * Any non-compliant resource that is updated between the snapshot schedule will * continue to be remediated based on the last known compliance data snapshot.

*

This means that in some cases auto remediation can be initiated even for * compliant resources, since the bootstrap processor uses a database that can have * stale evaluation results based on the last known compliance data snapshot.

*

See Also:

AWS * API Reference

*/ virtual Model::PutRemediationExceptionsOutcome PutRemediationExceptions(const Model::PutRemediationExceptionsRequest& request) const; /** * A Callable wrapper for PutRemediationExceptions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutRemediationExceptionsOutcomeCallable PutRemediationExceptionsCallable(const PutRemediationExceptionsRequestT& request) const { return SubmitCallable(&ConfigServiceClient::PutRemediationExceptions, request); } /** * An Async wrapper for PutRemediationExceptions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutRemediationExceptionsAsync(const PutRemediationExceptionsRequestT& request, const PutRemediationExceptionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ConfigServiceClient::PutRemediationExceptions, request, handler, context); } /** *

Records the configuration state for the resource provided in the request. The * configuration state of a resource is represented in Config as Configuration * Items. Once this API records the configuration item, you can retrieve the list * of configuration items for the custom resource type using existing Config APIs. *

The custom resource type must be registered with CloudFormation. * This API accepts the configuration item registered with CloudFormation.

*

When you call this API, Config only stores configuration state of the * resource provided in the request. This API does not change or remediate the * configuration of the resource.

Write-only schema properites are not * recorded as part of the published configuration item.

See * Also:

AWS * API Reference

*/ virtual Model::PutResourceConfigOutcome PutResourceConfig(const Model::PutResourceConfigRequest& request) const; /** * A Callable wrapper for PutResourceConfig that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutResourceConfigOutcomeCallable PutResourceConfigCallable(const PutResourceConfigRequestT& request) const { return SubmitCallable(&ConfigServiceClient::PutResourceConfig, request); } /** * An Async wrapper for PutResourceConfig that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutResourceConfigAsync(const PutResourceConfigRequestT& request, const PutResourceConfigResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ConfigServiceClient::PutResourceConfig, request, handler, context); } /** *

Creates and updates the retention configuration with details about retention * period (number of days) that Config stores your historical information. The API * creates the RetentionConfiguration object and names the object as * default. When you have a RetentionConfiguration object named * default, calling the API modifies the default object.

*

Currently, Config supports only one retention configuration per region in * your account.

See Also:

AWS * API Reference

*/ virtual Model::PutRetentionConfigurationOutcome PutRetentionConfiguration(const Model::PutRetentionConfigurationRequest& request) const; /** * A Callable wrapper for PutRetentionConfiguration that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutRetentionConfigurationOutcomeCallable PutRetentionConfigurationCallable(const PutRetentionConfigurationRequestT& request) const { return SubmitCallable(&ConfigServiceClient::PutRetentionConfiguration, request); } /** * An Async wrapper for PutRetentionConfiguration that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutRetentionConfigurationAsync(const PutRetentionConfigurationRequestT& request, const PutRetentionConfigurationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ConfigServiceClient::PutRetentionConfiguration, request, handler, context); } /** *

Creates a service-linked configuration recorder that is linked to a specific * Amazon Web Services service based on the ServicePrincipal you * specify.

The configuration recorder's name, * recordingGroup, recordingMode, and * recordingScope is set by the service that is linked to the * configuration recorder.

For more information, see * Working with the Configuration Recorder in the Config Developer * Guide.

This API creates a service-linked role * AWSServiceRoleForConfig in your account. The service-linked role is * created only when the role does not exist in your account.

The * recording scope determines if you receive configuration items

The * recording scope is set by the service that is linked to the configuration * recorder and determines whether you receive configuration items (CIs) in the * delivery channel. If the recording scope is internal, you will not receive CIs * in the delivery channel.

Tags are added at creation and cannot be * updated with this operation

Use TagResource * and UntagResource * to update tags after creation.

See Also:

AWS * API Reference

*/ virtual Model::PutServiceLinkedConfigurationRecorderOutcome PutServiceLinkedConfigurationRecorder(const Model::PutServiceLinkedConfigurationRecorderRequest& request) const; /** * A Callable wrapper for PutServiceLinkedConfigurationRecorder that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutServiceLinkedConfigurationRecorderOutcomeCallable PutServiceLinkedConfigurationRecorderCallable(const PutServiceLinkedConfigurationRecorderRequestT& request) const { return SubmitCallable(&ConfigServiceClient::PutServiceLinkedConfigurationRecorder, request); } /** * An Async wrapper for PutServiceLinkedConfigurationRecorder that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutServiceLinkedConfigurationRecorderAsync(const PutServiceLinkedConfigurationRecorderRequestT& request, const PutServiceLinkedConfigurationRecorderResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ConfigServiceClient::PutServiceLinkedConfigurationRecorder, request, handler, context); } /** *

Saves a new query or updates an existing saved query. The * QueryName must be unique for a single Amazon Web Services account * and a single Amazon Web Services Region. You can create upto 300 queries in a * single Amazon Web Services account and a single Amazon Web Services Region.

*

Tags are added at creation and cannot be updated

* PutStoredQuery is an idempotent API. Subsequent requests won’t * create a duplicate resource if one was already created. If a following request * has different tags values, Config will ignore these differences and * treat it as an idempotent request of the previous. In this case, * tags will not be updated, even if they are different.

*

See Also:

AWS * API Reference

*/ virtual Model::PutStoredQueryOutcome PutStoredQuery(const Model::PutStoredQueryRequest& request) const; /** * A Callable wrapper for PutStoredQuery that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutStoredQueryOutcomeCallable PutStoredQueryCallable(const PutStoredQueryRequestT& request) const { return SubmitCallable(&ConfigServiceClient::PutStoredQuery, request); } /** * An Async wrapper for PutStoredQuery that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutStoredQueryAsync(const PutStoredQueryRequestT& request, const PutStoredQueryResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ConfigServiceClient::PutStoredQuery, request, handler, context); } /** *

Accepts a structured query language (SQL) SELECT command and an aggregator to * query configuration state of Amazon Web Services resources across multiple * accounts and regions, performs the corresponding search, and returns resource * configurations matching the properties.

For more information about query * components, see the * Query Components section in the Config Developer Guide.

*

If you run an aggregation query (i.e., using GROUP BY or * using aggregate functions such as COUNT; e.g., SELECT * resourceId, COUNT(*) WHERE resourceType = 'AWS::IAM::Role' GROUP BY * resourceId) and do not specify the MaxResults or the * Limit query parameters, the default page size is set to 500.

*

If you run a non-aggregation query (i.e., not using GROUP BY or * aggregate function; e.g., SELECT * WHERE resourceType = * 'AWS::IAM::Role') and do not specify the MaxResults or the * Limit query parameters, the default page size is set to 25.

*

See Also:

AWS * API Reference

*/ virtual Model::SelectAggregateResourceConfigOutcome SelectAggregateResourceConfig(const Model::SelectAggregateResourceConfigRequest& request) const; /** * A Callable wrapper for SelectAggregateResourceConfig that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::SelectAggregateResourceConfigOutcomeCallable SelectAggregateResourceConfigCallable(const SelectAggregateResourceConfigRequestT& request) const { return SubmitCallable(&ConfigServiceClient::SelectAggregateResourceConfig, request); } /** * An Async wrapper for SelectAggregateResourceConfig that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void SelectAggregateResourceConfigAsync(const SelectAggregateResourceConfigRequestT& request, const SelectAggregateResourceConfigResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ConfigServiceClient::SelectAggregateResourceConfig, request, handler, context); } /** *

Accepts a structured query language (SQL) SELECT command, * performs the corresponding search, and returns resource configurations matching * the properties.

For more information about query components, see the * Query Components section in the Config Developer * Guide.

See Also:

AWS * API Reference

*/ virtual Model::SelectResourceConfigOutcome SelectResourceConfig(const Model::SelectResourceConfigRequest& request) const; /** * A Callable wrapper for SelectResourceConfig that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::SelectResourceConfigOutcomeCallable SelectResourceConfigCallable(const SelectResourceConfigRequestT& request) const { return SubmitCallable(&ConfigServiceClient::SelectResourceConfig, request); } /** * An Async wrapper for SelectResourceConfig that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void SelectResourceConfigAsync(const SelectResourceConfigRequestT& request, const SelectResourceConfigResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ConfigServiceClient::SelectResourceConfig, request, handler, context); } /** *

Runs an on-demand evaluation for the specified Config rules against the last * known configuration state of the resources. Use * StartConfigRulesEvaluation when you want to test that a rule you * updated is working as expected. StartConfigRulesEvaluation does not * re-record the latest configuration state for your resources. It re-runs an * evaluation against the last known state of your resources.

You can * specify up to 25 Config rules per request.

An existing * StartConfigRulesEvaluation call for the specified rules must * complete before you can call the API again. If you chose to have Config stream * to an Amazon SNS topic, you will receive a * ConfigRuleEvaluationStarted notification when the evaluation * starts.

You don't need to call the * StartConfigRulesEvaluation API to run an evaluation for a new rule. * When you create a rule, Config evaluates your resources against the rule * automatically.

The StartConfigRulesEvaluation API * is useful if you want to run on-demand evaluations, such as the following * example:

  1. You have a custom rule that evaluates your IAM * resources every 24 hours.

  2. You update your Lambda function to * add additional conditions to your rule.

  3. Instead of waiting for * the next periodic evaluation, you call the * StartConfigRulesEvaluation API.

  4. Config invokes * your Lambda function and evaluates your IAM resources.

  5. Your * custom rule will still run periodic evaluations every 24 hours.

    6. *

See Also:

AWS * API Reference

*/ virtual Model::StartConfigRulesEvaluationOutcome StartConfigRulesEvaluation(const Model::StartConfigRulesEvaluationRequest& request = {}) const; /** * A Callable wrapper for StartConfigRulesEvaluation that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::StartConfigRulesEvaluationOutcomeCallable StartConfigRulesEvaluationCallable(const StartConfigRulesEvaluationRequestT& request = {}) const { return SubmitCallable(&ConfigServiceClient::StartConfigRulesEvaluation, request); } /** * An Async wrapper for StartConfigRulesEvaluation that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void StartConfigRulesEvaluationAsync(const StartConfigRulesEvaluationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr, const StartConfigRulesEvaluationRequestT& request = {}) const { return SubmitAsync(&ConfigServiceClient::StartConfigRulesEvaluation, request, handler, context); } /** *

Starts the customer managed configuration recorder. The customer managed * configuration recorder will begin recording configuration changes for the * resource types you specify.

You must have created a delivery channel to * successfully start the customer managed configuration recorder. You can use the * PutDeliveryChannel * operation to create a delivery channel.

See Also:

AWS * API Reference

*/ virtual Model::StartConfigurationRecorderOutcome StartConfigurationRecorder(const Model::StartConfigurationRecorderRequest& request) const; /** * A Callable wrapper for StartConfigurationRecorder that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::StartConfigurationRecorderOutcomeCallable StartConfigurationRecorderCallable(const StartConfigurationRecorderRequestT& request) const { return SubmitCallable(&ConfigServiceClient::StartConfigurationRecorder, request); } /** * An Async wrapper for StartConfigurationRecorder that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void StartConfigurationRecorderAsync(const StartConfigurationRecorderRequestT& request, const StartConfigurationRecorderResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ConfigServiceClient::StartConfigurationRecorder, request, handler, context); } /** *

Runs an on-demand remediation for the specified Config rules against the last * known remediation configuration. It runs an execution against the current state * of your resources. Remediation execution is asynchronous.

You can specify * up to 100 resource keys per request. An existing StartRemediationExecution call * for the specified resource keys must complete before you can call the API * again.

See Also:

AWS * API Reference

*/ virtual Model::StartRemediationExecutionOutcome StartRemediationExecution(const Model::StartRemediationExecutionRequest& request) const; /** * A Callable wrapper for StartRemediationExecution that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::StartRemediationExecutionOutcomeCallable StartRemediationExecutionCallable(const StartRemediationExecutionRequestT& request) const { return SubmitCallable(&ConfigServiceClient::StartRemediationExecution, request); } /** * An Async wrapper for StartRemediationExecution that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void StartRemediationExecutionAsync(const StartRemediationExecutionRequestT& request, const StartRemediationExecutionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ConfigServiceClient::StartRemediationExecution, request, handler, context); } /** *

Runs an on-demand evaluation for the specified resource to determine whether * the resource details will comply with configured Config rules. You can also use * it for evaluation purposes. Config recommends using an evaluation context. It * runs an execution against the resource details with all of the Config rules in * your account that match with the specified proactive mode and resource type.

*

Ensure you have the cloudformation:DescribeType role * setup to validate the resource type schema.

You can find the Resource * type schema in "Amazon Web Services public extensions" within the * CloudFormation registry or with the following CLI commmand: aws * cloudformation describe-type --type-name "AWS::S3::Bucket" --type * RESOURCE.

For more information, see Managing * extensions through the CloudFormation registry and Amazon * Web Services resource and property types reference in the CloudFormation * User Guide.

See Also:

AWS * API Reference

*/ virtual Model::StartResourceEvaluationOutcome StartResourceEvaluation(const Model::StartResourceEvaluationRequest& request) const; /** * A Callable wrapper for StartResourceEvaluation that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::StartResourceEvaluationOutcomeCallable StartResourceEvaluationCallable(const StartResourceEvaluationRequestT& request) const { return SubmitCallable(&ConfigServiceClient::StartResourceEvaluation, request); } /** * An Async wrapper for StartResourceEvaluation that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void StartResourceEvaluationAsync(const StartResourceEvaluationRequestT& request, const StartResourceEvaluationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ConfigServiceClient::StartResourceEvaluation, request, handler, context); } /** *

Stops the customer managed configuration recorder. The customer managed * configuration recorder will stop recording configuration changes for the * resource types you have specified.

See Also:

AWS * API Reference

*/ virtual Model::StopConfigurationRecorderOutcome StopConfigurationRecorder(const Model::StopConfigurationRecorderRequest& request) const; /** * A Callable wrapper for StopConfigurationRecorder that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::StopConfigurationRecorderOutcomeCallable StopConfigurationRecorderCallable(const StopConfigurationRecorderRequestT& request) const { return SubmitCallable(&ConfigServiceClient::StopConfigurationRecorder, request); } /** * An Async wrapper for StopConfigurationRecorder that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void StopConfigurationRecorderAsync(const StopConfigurationRecorderRequestT& request, const StopConfigurationRecorderResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ConfigServiceClient::StopConfigurationRecorder, request, handler, context); } /** *

Associates the specified tags to a resource with the specified * ResourceArn. If existing tags on a resource are not specified in * the request parameters, they are not changed. If existing tags are specified, * however, then their values will be updated. When a resource is deleted, the tags * associated with that resource are deleted as well.

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(&ConfigServiceClient::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(&ConfigServiceClient::TagResource, request, handler, context); } /** *

Deletes specified 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(&ConfigServiceClient::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(&ConfigServiceClient::UntagResource, request, handler, context); } void OverrideEndpoint(const Aws::String& endpoint); std::shared_ptr& accessEndpointProvider(); private: friend class Aws::Client::ClientWithAsyncTemplateMethods; void init(const ConfigServiceClientConfiguration& clientConfiguration); ConfigServiceClientConfiguration m_clientConfiguration; std::shared_ptr m_endpointProvider; }; } // namespace ConfigService } // namespace Aws