ConfigServiceClient.h

 
#pragma once
#include <aws/config/ConfigServicePaginationBase.h>
#include <aws/config/ConfigServiceServiceClientModel.h>
#include <aws/config/ConfigServiceWaiter.h>
#include <aws/config/ConfigService_EXPORTS.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/utils/json/JsonSerializer.h>
 
namespace Aws {
namespace ConfigService {
class AWS_CONFIGSERVICE_API ConfigServiceClient : public Aws::Client::AWSJsonClient,
                                                  public Aws::Client::ClientWithAsyncTemplateMethods<ConfigServiceClient>,
                                                  public ConfigServicePaginationBase<ConfigServiceClient>,
                                                  public ConfigServiceWaiter<ConfigServiceClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef ConfigServiceClientConfiguration ClientConfigurationType;
  typedef ConfigServiceEndpointProvider EndpointProviderType;
 
  ConfigServiceClient(const Aws::ConfigService::ConfigServiceClientConfiguration& clientConfiguration =
                          Aws::ConfigService::ConfigServiceClientConfiguration(),
                      std::shared_ptr<ConfigServiceEndpointProviderBase> endpointProvider = nullptr);
 
  ConfigServiceClient(const Aws::Auth::AWSCredentials& credentials,
                      std::shared_ptr<ConfigServiceEndpointProviderBase> endpointProvider = nullptr,
                      const Aws::ConfigService::ConfigServiceClientConfiguration& clientConfiguration =
                          Aws::ConfigService::ConfigServiceClientConfiguration());
 
  ConfigServiceClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                      std::shared_ptr<ConfigServiceEndpointProviderBase> endpointProvider = nullptr,
                      const Aws::ConfigService::ConfigServiceClientConfiguration& clientConfiguration =
                          Aws::ConfigService::ConfigServiceClientConfiguration());
 
  /* Legacy constructors due deprecation */
  ConfigServiceClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  ConfigServiceClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  ConfigServiceClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                      const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~ConfigServiceClient();
 
  virtual Model::AssociateResourceTypesOutcome AssociateResourceTypes(const Model::AssociateResourceTypesRequest& request) const;
 
  template <typename AssociateResourceTypesRequestT = Model::AssociateResourceTypesRequest>
  Model::AssociateResourceTypesOutcomeCallable AssociateResourceTypesCallable(const AssociateResourceTypesRequestT& request) const {
    return SubmitCallable(&ConfigServiceClient::AssociateResourceTypes, request);
  }
 
  template <typename AssociateResourceTypesRequestT = Model::AssociateResourceTypesRequest>
  void AssociateResourceTypesAsync(const AssociateResourceTypesRequestT& request,
                                   const AssociateResourceTypesResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConfigServiceClient::AssociateResourceTypes, request, handler, context);
  }
 
  virtual Model::BatchGetAggregateResourceConfigOutcome BatchGetAggregateResourceConfig(
      const Model::BatchGetAggregateResourceConfigRequest& request) const;
 
  template <typename BatchGetAggregateResourceConfigRequestT = Model::BatchGetAggregateResourceConfigRequest>
  Model::BatchGetAggregateResourceConfigOutcomeCallable BatchGetAggregateResourceConfigCallable(
      const BatchGetAggregateResourceConfigRequestT& request) const {
    return SubmitCallable(&ConfigServiceClient::BatchGetAggregateResourceConfig, request);
  }
 
  template <typename BatchGetAggregateResourceConfigRequestT = Model::BatchGetAggregateResourceConfigRequest>
  void BatchGetAggregateResourceConfigAsync(const BatchGetAggregateResourceConfigRequestT& request,
                                            const BatchGetAggregateResourceConfigResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConfigServiceClient::BatchGetAggregateResourceConfig, request, handler, context);
  }
 
  virtual Model::BatchGetResourceConfigOutcome BatchGetResourceConfig(const Model::BatchGetResourceConfigRequest& request) const;
 
  template <typename BatchGetResourceConfigRequestT = Model::BatchGetResourceConfigRequest>
  Model::BatchGetResourceConfigOutcomeCallable BatchGetResourceConfigCallable(const BatchGetResourceConfigRequestT& request) const {
    return SubmitCallable(&ConfigServiceClient::BatchGetResourceConfig, request);
  }
 
  template <typename BatchGetResourceConfigRequestT = Model::BatchGetResourceConfigRequest>
  void BatchGetResourceConfigAsync(const BatchGetResourceConfigRequestT& request,
                                   const BatchGetResourceConfigResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConfigServiceClient::BatchGetResourceConfig, request, handler, context);
  }
 
  virtual Model::DeleteAggregationAuthorizationOutcome DeleteAggregationAuthorization(
      const Model::DeleteAggregationAuthorizationRequest& request) const;
 
  template <typename DeleteAggregationAuthorizationRequestT = Model::DeleteAggregationAuthorizationRequest>
  Model::DeleteAggregationAuthorizationOutcomeCallable DeleteAggregationAuthorizationCallable(
      const DeleteAggregationAuthorizationRequestT& request) const {
    return SubmitCallable(&ConfigServiceClient::DeleteAggregationAuthorization, request);
  }
 
  template <typename DeleteAggregationAuthorizationRequestT = Model::DeleteAggregationAuthorizationRequest>
  void DeleteAggregationAuthorizationAsync(const DeleteAggregationAuthorizationRequestT& request,
                                           const DeleteAggregationAuthorizationResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConfigServiceClient::DeleteAggregationAuthorization, request, handler, context);
  }
 
  virtual Model::DeleteConfigRuleOutcome DeleteConfigRule(const Model::DeleteConfigRuleRequest& request) const;
 
  template <typename DeleteConfigRuleRequestT = Model::DeleteConfigRuleRequest>
  Model::DeleteConfigRuleOutcomeCallable DeleteConfigRuleCallable(const DeleteConfigRuleRequestT& request) const {
    return SubmitCallable(&ConfigServiceClient::DeleteConfigRule, request);
  }
 
  template <typename DeleteConfigRuleRequestT = Model::DeleteConfigRuleRequest>
  void DeleteConfigRuleAsync(const DeleteConfigRuleRequestT& request, const DeleteConfigRuleResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConfigServiceClient::DeleteConfigRule, request, handler, context);
  }
 
  virtual Model::DeleteConfigurationAggregatorOutcome DeleteConfigurationAggregator(
      const Model::DeleteConfigurationAggregatorRequest& request) const;
 
  template <typename DeleteConfigurationAggregatorRequestT = Model::DeleteConfigurationAggregatorRequest>
  Model::DeleteConfigurationAggregatorOutcomeCallable DeleteConfigurationAggregatorCallable(
      const DeleteConfigurationAggregatorRequestT& request) const {
    return SubmitCallable(&ConfigServiceClient::DeleteConfigurationAggregator, request);
  }
 
  template <typename DeleteConfigurationAggregatorRequestT = Model::DeleteConfigurationAggregatorRequest>
  void DeleteConfigurationAggregatorAsync(const DeleteConfigurationAggregatorRequestT& request,
                                          const DeleteConfigurationAggregatorResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConfigServiceClient::DeleteConfigurationAggregator, request, handler, context);
  }
 
  virtual Model::DeleteConfigurationRecorderOutcome DeleteConfigurationRecorder(
      const Model::DeleteConfigurationRecorderRequest& request) const;
 
  template <typename DeleteConfigurationRecorderRequestT = Model::DeleteConfigurationRecorderRequest>
  Model::DeleteConfigurationRecorderOutcomeCallable DeleteConfigurationRecorderCallable(
      const DeleteConfigurationRecorderRequestT& request) const {
    return SubmitCallable(&ConfigServiceClient::DeleteConfigurationRecorder, request);
  }
 
  template <typename DeleteConfigurationRecorderRequestT = Model::DeleteConfigurationRecorderRequest>
  void DeleteConfigurationRecorderAsync(const DeleteConfigurationRecorderRequestT& request,
                                        const DeleteConfigurationRecorderResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConfigServiceClient::DeleteConfigurationRecorder, request, handler, context);
  }
 
  virtual Model::DeleteConformancePackOutcome DeleteConformancePack(const Model::DeleteConformancePackRequest& request) const;
 
  template <typename DeleteConformancePackRequestT = Model::DeleteConformancePackRequest>
  Model::DeleteConformancePackOutcomeCallable DeleteConformancePackCallable(const DeleteConformancePackRequestT& request) const {
    return SubmitCallable(&ConfigServiceClient::DeleteConformancePack, request);
  }
 
  template <typename DeleteConformancePackRequestT = Model::DeleteConformancePackRequest>
  void DeleteConformancePackAsync(const DeleteConformancePackRequestT& request, const DeleteConformancePackResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConfigServiceClient::DeleteConformancePack, request, handler, context);
  }
 
  virtual Model::DeleteConnectorOutcome DeleteConnector(const Model::DeleteConnectorRequest& request) const;
 
  template <typename DeleteConnectorRequestT = Model::DeleteConnectorRequest>
  Model::DeleteConnectorOutcomeCallable DeleteConnectorCallable(const DeleteConnectorRequestT& request) const {
    return SubmitCallable(&ConfigServiceClient::DeleteConnector, request);
  }
 
  template <typename DeleteConnectorRequestT = Model::DeleteConnectorRequest>
  void DeleteConnectorAsync(const DeleteConnectorRequestT& request, const DeleteConnectorResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConfigServiceClient::DeleteConnector, request, handler, context);
  }
 
  virtual Model::DeleteDeliveryChannelOutcome DeleteDeliveryChannel(const Model::DeleteDeliveryChannelRequest& request) const;
 
  template <typename DeleteDeliveryChannelRequestT = Model::DeleteDeliveryChannelRequest>
  Model::DeleteDeliveryChannelOutcomeCallable DeleteDeliveryChannelCallable(const DeleteDeliveryChannelRequestT& request) const {
    return SubmitCallable(&ConfigServiceClient::DeleteDeliveryChannel, request);
  }
 
  template <typename DeleteDeliveryChannelRequestT = Model::DeleteDeliveryChannelRequest>
  void DeleteDeliveryChannelAsync(const DeleteDeliveryChannelRequestT& request, const DeleteDeliveryChannelResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConfigServiceClient::DeleteDeliveryChannel, request, handler, context);
  }
 
  virtual Model::DeleteEvaluationResultsOutcome DeleteEvaluationResults(const Model::DeleteEvaluationResultsRequest& request) const;
 
  template <typename DeleteEvaluationResultsRequestT = Model::DeleteEvaluationResultsRequest>
  Model::DeleteEvaluationResultsOutcomeCallable DeleteEvaluationResultsCallable(const DeleteEvaluationResultsRequestT& request) const {
    return SubmitCallable(&ConfigServiceClient::DeleteEvaluationResults, request);
  }
 
  template <typename DeleteEvaluationResultsRequestT = Model::DeleteEvaluationResultsRequest>
  void DeleteEvaluationResultsAsync(const DeleteEvaluationResultsRequestT& request,
                                    const DeleteEvaluationResultsResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConfigServiceClient::DeleteEvaluationResults, request, handler, context);
  }
 
  virtual Model::DeleteOrganizationConfigRuleOutcome DeleteOrganizationConfigRule(
      const Model::DeleteOrganizationConfigRuleRequest& request) const;
 
  template <typename DeleteOrganizationConfigRuleRequestT = Model::DeleteOrganizationConfigRuleRequest>
  Model::DeleteOrganizationConfigRuleOutcomeCallable DeleteOrganizationConfigRuleCallable(
      const DeleteOrganizationConfigRuleRequestT& request) const {
    return SubmitCallable(&ConfigServiceClient::DeleteOrganizationConfigRule, request);
  }
 
  template <typename DeleteOrganizationConfigRuleRequestT = Model::DeleteOrganizationConfigRuleRequest>
  void DeleteOrganizationConfigRuleAsync(const DeleteOrganizationConfigRuleRequestT& request,
                                         const DeleteOrganizationConfigRuleResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConfigServiceClient::DeleteOrganizationConfigRule, request, handler, context);
  }
 
  virtual Model::DeleteOrganizationConformancePackOutcome DeleteOrganizationConformancePack(
      const Model::DeleteOrganizationConformancePackRequest& request) const;
 
  template <typename DeleteOrganizationConformancePackRequestT = Model::DeleteOrganizationConformancePackRequest>
  Model::DeleteOrganizationConformancePackOutcomeCallable DeleteOrganizationConformancePackCallable(
      const DeleteOrganizationConformancePackRequestT& request) const {
    return SubmitCallable(&ConfigServiceClient::DeleteOrganizationConformancePack, request);
  }
 
  template <typename DeleteOrganizationConformancePackRequestT = Model::DeleteOrganizationConformancePackRequest>
  void DeleteOrganizationConformancePackAsync(const DeleteOrganizationConformancePackRequestT& request,
                                              const DeleteOrganizationConformancePackResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConfigServiceClient::DeleteOrganizationConformancePack, request, handler, context);
  }
 
  virtual Model::DeletePendingAggregationRequestOutcome DeletePendingAggregationRequest(
      const Model::DeletePendingAggregationRequestRequest& request) const;
 
  template <typename DeletePendingAggregationRequestRequestT = Model::DeletePendingAggregationRequestRequest>
  Model::DeletePendingAggregationRequestOutcomeCallable DeletePendingAggregationRequestCallable(
      const DeletePendingAggregationRequestRequestT& request) const {
    return SubmitCallable(&ConfigServiceClient::DeletePendingAggregationRequest, request);
  }
 
  template <typename DeletePendingAggregationRequestRequestT = Model::DeletePendingAggregationRequestRequest>
  void DeletePendingAggregationRequestAsync(const DeletePendingAggregationRequestRequestT& request,
                                            const DeletePendingAggregationRequestResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConfigServiceClient::DeletePendingAggregationRequest, request, handler, context);
  }
 
  virtual Model::DeleteRemediationConfigurationOutcome DeleteRemediationConfiguration(
      const Model::DeleteRemediationConfigurationRequest& request) const;
 
  template <typename DeleteRemediationConfigurationRequestT = Model::DeleteRemediationConfigurationRequest>
  Model::DeleteRemediationConfigurationOutcomeCallable DeleteRemediationConfigurationCallable(
      const DeleteRemediationConfigurationRequestT& request) const {
    return SubmitCallable(&ConfigServiceClient::DeleteRemediationConfiguration, request);
  }
 
  template <typename DeleteRemediationConfigurationRequestT = Model::DeleteRemediationConfigurationRequest>
  void DeleteRemediationConfigurationAsync(const DeleteRemediationConfigurationRequestT& request,
                                           const DeleteRemediationConfigurationResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConfigServiceClient::DeleteRemediationConfiguration, request, handler, context);
  }
 
  virtual Model::DeleteRemediationExceptionsOutcome DeleteRemediationExceptions(
      const Model::DeleteRemediationExceptionsRequest& request) const;
 
  template <typename DeleteRemediationExceptionsRequestT = Model::DeleteRemediationExceptionsRequest>
  Model::DeleteRemediationExceptionsOutcomeCallable DeleteRemediationExceptionsCallable(
      const DeleteRemediationExceptionsRequestT& request) const {
    return SubmitCallable(&ConfigServiceClient::DeleteRemediationExceptions, request);
  }
 
  template <typename DeleteRemediationExceptionsRequestT = Model::DeleteRemediationExceptionsRequest>
  void DeleteRemediationExceptionsAsync(const DeleteRemediationExceptionsRequestT& request,
                                        const DeleteRemediationExceptionsResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConfigServiceClient::DeleteRemediationExceptions, request, handler, context);
  }
 
  virtual Model::DeleteResourceConfigOutcome DeleteResourceConfig(const Model::DeleteResourceConfigRequest& request) const;
 
  template <typename DeleteResourceConfigRequestT = Model::DeleteResourceConfigRequest>
  Model::DeleteResourceConfigOutcomeCallable DeleteResourceConfigCallable(const DeleteResourceConfigRequestT& request) const {
    return SubmitCallable(&ConfigServiceClient::DeleteResourceConfig, request);
  }
 
  template <typename DeleteResourceConfigRequestT = Model::DeleteResourceConfigRequest>
  void DeleteResourceConfigAsync(const DeleteResourceConfigRequestT& request, const DeleteResourceConfigResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConfigServiceClient::DeleteResourceConfig, request, handler, context);
  }
 
  virtual Model::DeleteRetentionConfigurationOutcome DeleteRetentionConfiguration(
      const Model::DeleteRetentionConfigurationRequest& request) const;
 
  template <typename DeleteRetentionConfigurationRequestT = Model::DeleteRetentionConfigurationRequest>
  Model::DeleteRetentionConfigurationOutcomeCallable DeleteRetentionConfigurationCallable(
      const DeleteRetentionConfigurationRequestT& request) const {
    return SubmitCallable(&ConfigServiceClient::DeleteRetentionConfiguration, request);
  }
 
  template <typename DeleteRetentionConfigurationRequestT = Model::DeleteRetentionConfigurationRequest>
  void DeleteRetentionConfigurationAsync(const DeleteRetentionConfigurationRequestT& request,
                                         const DeleteRetentionConfigurationResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConfigServiceClient::DeleteRetentionConfiguration, request, handler, context);
  }
 
  virtual Model::DeleteServiceLinkedConfigurationRecorderOutcome DeleteServiceLinkedConfigurationRecorder(
      const Model::DeleteServiceLinkedConfigurationRecorderRequest& request = {}) const;
 
  template <typename DeleteServiceLinkedConfigurationRecorderRequestT = Model::DeleteServiceLinkedConfigurationRecorderRequest>
  Model::DeleteServiceLinkedConfigurationRecorderOutcomeCallable DeleteServiceLinkedConfigurationRecorderCallable(
      const DeleteServiceLinkedConfigurationRecorderRequestT& request = {}) const {
    return SubmitCallable(&ConfigServiceClient::DeleteServiceLinkedConfigurationRecorder, request);
  }
 
  template <typename DeleteServiceLinkedConfigurationRecorderRequestT = Model::DeleteServiceLinkedConfigurationRecorderRequest>
  void DeleteServiceLinkedConfigurationRecorderAsync(const DeleteServiceLinkedConfigurationRecorderResponseReceivedHandler& handler,
                                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                                     const DeleteServiceLinkedConfigurationRecorderRequestT& request = {}) const {
    return SubmitAsync(&ConfigServiceClient::DeleteServiceLinkedConfigurationRecorder, request, handler, context);
  }
 
  virtual Model::DeleteStoredQueryOutcome DeleteStoredQuery(const Model::DeleteStoredQueryRequest& request) const;
 
  template <typename DeleteStoredQueryRequestT = Model::DeleteStoredQueryRequest>
  Model::DeleteStoredQueryOutcomeCallable DeleteStoredQueryCallable(const DeleteStoredQueryRequestT& request) const {
    return SubmitCallable(&ConfigServiceClient::DeleteStoredQuery, request);
  }
 
  template <typename DeleteStoredQueryRequestT = Model::DeleteStoredQueryRequest>
  void DeleteStoredQueryAsync(const DeleteStoredQueryRequestT& request, const DeleteStoredQueryResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConfigServiceClient::DeleteStoredQuery, request, handler, context);
  }
 
  virtual Model::DeliverConfigSnapshotOutcome DeliverConfigSnapshot(const Model::DeliverConfigSnapshotRequest& request) const;
 
  template <typename DeliverConfigSnapshotRequestT = Model::DeliverConfigSnapshotRequest>
  Model::DeliverConfigSnapshotOutcomeCallable DeliverConfigSnapshotCallable(const DeliverConfigSnapshotRequestT& request) const {
    return SubmitCallable(&ConfigServiceClient::DeliverConfigSnapshot, request);
  }
 
  template <typename DeliverConfigSnapshotRequestT = Model::DeliverConfigSnapshotRequest>
  void DeliverConfigSnapshotAsync(const DeliverConfigSnapshotRequestT& request, const DeliverConfigSnapshotResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConfigServiceClient::DeliverConfigSnapshot, request, handler, context);
  }
 
  virtual Model::DescribeAggregateComplianceByConfigRulesOutcome DescribeAggregateComplianceByConfigRules(
      const Model::DescribeAggregateComplianceByConfigRulesRequest& request) const;
 
  template <typename DescribeAggregateComplianceByConfigRulesRequestT = Model::DescribeAggregateComplianceByConfigRulesRequest>
  Model::DescribeAggregateComplianceByConfigRulesOutcomeCallable DescribeAggregateComplianceByConfigRulesCallable(
      const DescribeAggregateComplianceByConfigRulesRequestT& request) const {
    return SubmitCallable(&ConfigServiceClient::DescribeAggregateComplianceByConfigRules, request);
  }
 
  template <typename DescribeAggregateComplianceByConfigRulesRequestT = Model::DescribeAggregateComplianceByConfigRulesRequest>
  void DescribeAggregateComplianceByConfigRulesAsync(
      const DescribeAggregateComplianceByConfigRulesRequestT& request,
      const DescribeAggregateComplianceByConfigRulesResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConfigServiceClient::DescribeAggregateComplianceByConfigRules, request, handler, context);
  }
 
  virtual Model::DescribeAggregateComplianceByConformancePacksOutcome DescribeAggregateComplianceByConformancePacks(
      const Model::DescribeAggregateComplianceByConformancePacksRequest& request) const;
 
  template <typename DescribeAggregateComplianceByConformancePacksRequestT = Model::DescribeAggregateComplianceByConformancePacksRequest>
  Model::DescribeAggregateComplianceByConformancePacksOutcomeCallable DescribeAggregateComplianceByConformancePacksCallable(
      const DescribeAggregateComplianceByConformancePacksRequestT& request) const {
    return SubmitCallable(&ConfigServiceClient::DescribeAggregateComplianceByConformancePacks, request);
  }
 
  template <typename DescribeAggregateComplianceByConformancePacksRequestT = Model::DescribeAggregateComplianceByConformancePacksRequest>
  void DescribeAggregateComplianceByConformancePacksAsync(
      const DescribeAggregateComplianceByConformancePacksRequestT& request,
      const DescribeAggregateComplianceByConformancePacksResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConfigServiceClient::DescribeAggregateComplianceByConformancePacks, request, handler, context);
  }
 
  virtual Model::DescribeAggregationAuthorizationsOutcome DescribeAggregationAuthorizations(
      const Model::DescribeAggregationAuthorizationsRequest& request = {}) const;
 
  template <typename DescribeAggregationAuthorizationsRequestT = Model::DescribeAggregationAuthorizationsRequest>
  Model::DescribeAggregationAuthorizationsOutcomeCallable DescribeAggregationAuthorizationsCallable(
      const DescribeAggregationAuthorizationsRequestT& request = {}) const {
    return SubmitCallable(&ConfigServiceClient::DescribeAggregationAuthorizations, request);
  }
 
  template <typename DescribeAggregationAuthorizationsRequestT = Model::DescribeAggregationAuthorizationsRequest>
  void DescribeAggregationAuthorizationsAsync(const DescribeAggregationAuthorizationsResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                              const DescribeAggregationAuthorizationsRequestT& request = {}) const {
    return SubmitAsync(&ConfigServiceClient::DescribeAggregationAuthorizations, request, handler, context);
  }
 
  virtual Model::DescribeComplianceByConfigRuleOutcome DescribeComplianceByConfigRule(
      const Model::DescribeComplianceByConfigRuleRequest& request = {}) const;
 
  template <typename DescribeComplianceByConfigRuleRequestT = Model::DescribeComplianceByConfigRuleRequest>
  Model::DescribeComplianceByConfigRuleOutcomeCallable DescribeComplianceByConfigRuleCallable(
      const DescribeComplianceByConfigRuleRequestT& request = {}) const {
    return SubmitCallable(&ConfigServiceClient::DescribeComplianceByConfigRule, request);
  }
 
  template <typename DescribeComplianceByConfigRuleRequestT = Model::DescribeComplianceByConfigRuleRequest>
  void DescribeComplianceByConfigRuleAsync(const DescribeComplianceByConfigRuleResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                           const DescribeComplianceByConfigRuleRequestT& request = {}) const {
    return SubmitAsync(&ConfigServiceClient::DescribeComplianceByConfigRule, request, handler, context);
  }
 
  virtual Model::DescribeComplianceByResourceOutcome DescribeComplianceByResource(
      const Model::DescribeComplianceByResourceRequest& request = {}) const;
 
  template <typename DescribeComplianceByResourceRequestT = Model::DescribeComplianceByResourceRequest>
  Model::DescribeComplianceByResourceOutcomeCallable DescribeComplianceByResourceCallable(
      const DescribeComplianceByResourceRequestT& request = {}) const {
    return SubmitCallable(&ConfigServiceClient::DescribeComplianceByResource, request);
  }
 
  template <typename DescribeComplianceByResourceRequestT = Model::DescribeComplianceByResourceRequest>
  void DescribeComplianceByResourceAsync(const DescribeComplianceByResourceResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                         const DescribeComplianceByResourceRequestT& request = {}) const {
    return SubmitAsync(&ConfigServiceClient::DescribeComplianceByResource, request, handler, context);
  }
 
  virtual Model::DescribeConfigRuleEvaluationStatusOutcome DescribeConfigRuleEvaluationStatus(
      const Model::DescribeConfigRuleEvaluationStatusRequest& request = {}) const;
 
  template <typename DescribeConfigRuleEvaluationStatusRequestT = Model::DescribeConfigRuleEvaluationStatusRequest>
  Model::DescribeConfigRuleEvaluationStatusOutcomeCallable DescribeConfigRuleEvaluationStatusCallable(
      const DescribeConfigRuleEvaluationStatusRequestT& request = {}) const {
    return SubmitCallable(&ConfigServiceClient::DescribeConfigRuleEvaluationStatus, request);
  }
 
  template <typename DescribeConfigRuleEvaluationStatusRequestT = Model::DescribeConfigRuleEvaluationStatusRequest>
  void DescribeConfigRuleEvaluationStatusAsync(const DescribeConfigRuleEvaluationStatusResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                               const DescribeConfigRuleEvaluationStatusRequestT& request = {}) const {
    return SubmitAsync(&ConfigServiceClient::DescribeConfigRuleEvaluationStatus, request, handler, context);
  }
 
  virtual Model::DescribeConfigRulesOutcome DescribeConfigRules(const Model::DescribeConfigRulesRequest& request = {}) const;
 
  template <typename DescribeConfigRulesRequestT = Model::DescribeConfigRulesRequest>
  Model::DescribeConfigRulesOutcomeCallable DescribeConfigRulesCallable(const DescribeConfigRulesRequestT& request = {}) const {
    return SubmitCallable(&ConfigServiceClient::DescribeConfigRules, request);
  }
 
  template <typename DescribeConfigRulesRequestT = Model::DescribeConfigRulesRequest>
  void DescribeConfigRulesAsync(const DescribeConfigRulesResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                const DescribeConfigRulesRequestT& request = {}) const {
    return SubmitAsync(&ConfigServiceClient::DescribeConfigRules, request, handler, context);
  }
 
  virtual Model::DescribeConfigurationAggregatorSourcesStatusOutcome DescribeConfigurationAggregatorSourcesStatus(
      const Model::DescribeConfigurationAggregatorSourcesStatusRequest& request) const;
 
  template <typename DescribeConfigurationAggregatorSourcesStatusRequestT = Model::DescribeConfigurationAggregatorSourcesStatusRequest>
  Model::DescribeConfigurationAggregatorSourcesStatusOutcomeCallable DescribeConfigurationAggregatorSourcesStatusCallable(
      const DescribeConfigurationAggregatorSourcesStatusRequestT& request) const {
    return SubmitCallable(&ConfigServiceClient::DescribeConfigurationAggregatorSourcesStatus, request);
  }
 
  template <typename DescribeConfigurationAggregatorSourcesStatusRequestT = Model::DescribeConfigurationAggregatorSourcesStatusRequest>
  void DescribeConfigurationAggregatorSourcesStatusAsync(
      const DescribeConfigurationAggregatorSourcesStatusRequestT& request,
      const DescribeConfigurationAggregatorSourcesStatusResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConfigServiceClient::DescribeConfigurationAggregatorSourcesStatus, request, handler, context);
  }
 
  virtual Model::DescribeConfigurationAggregatorsOutcome DescribeConfigurationAggregators(
      const Model::DescribeConfigurationAggregatorsRequest& request = {}) const;
 
  template <typename DescribeConfigurationAggregatorsRequestT = Model::DescribeConfigurationAggregatorsRequest>
  Model::DescribeConfigurationAggregatorsOutcomeCallable DescribeConfigurationAggregatorsCallable(
      const DescribeConfigurationAggregatorsRequestT& request = {}) const {
    return SubmitCallable(&ConfigServiceClient::DescribeConfigurationAggregators, request);
  }
 
  template <typename DescribeConfigurationAggregatorsRequestT = Model::DescribeConfigurationAggregatorsRequest>
  void DescribeConfigurationAggregatorsAsync(const DescribeConfigurationAggregatorsResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                             const DescribeConfigurationAggregatorsRequestT& request = {}) const {
    return SubmitAsync(&ConfigServiceClient::DescribeConfigurationAggregators, request, handler, context);
  }
 
  virtual Model::DescribeConfigurationRecorderStatusOutcome DescribeConfigurationRecorderStatus(
      const Model::DescribeConfigurationRecorderStatusRequest& request = {}) const;
 
  template <typename DescribeConfigurationRecorderStatusRequestT = Model::DescribeConfigurationRecorderStatusRequest>
  Model::DescribeConfigurationRecorderStatusOutcomeCallable DescribeConfigurationRecorderStatusCallable(
      const DescribeConfigurationRecorderStatusRequestT& request = {}) const {
    return SubmitCallable(&ConfigServiceClient::DescribeConfigurationRecorderStatus, request);
  }
 
  template <typename DescribeConfigurationRecorderStatusRequestT = Model::DescribeConfigurationRecorderStatusRequest>
  void DescribeConfigurationRecorderStatusAsync(const DescribeConfigurationRecorderStatusResponseReceivedHandler& handler,
                                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                                const DescribeConfigurationRecorderStatusRequestT& request = {}) const {
    return SubmitAsync(&ConfigServiceClient::DescribeConfigurationRecorderStatus, request, handler, context);
  }
 
  virtual Model::DescribeConfigurationRecordersOutcome DescribeConfigurationRecorders(
      const Model::DescribeConfigurationRecordersRequest& request = {}) const;
 
  template <typename DescribeConfigurationRecordersRequestT = Model::DescribeConfigurationRecordersRequest>
  Model::DescribeConfigurationRecordersOutcomeCallable DescribeConfigurationRecordersCallable(
      const DescribeConfigurationRecordersRequestT& request = {}) const {
    return SubmitCallable(&ConfigServiceClient::DescribeConfigurationRecorders, request);
  }
 
  template <typename DescribeConfigurationRecordersRequestT = Model::DescribeConfigurationRecordersRequest>
  void DescribeConfigurationRecordersAsync(const DescribeConfigurationRecordersResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                           const DescribeConfigurationRecordersRequestT& request = {}) const {
    return SubmitAsync(&ConfigServiceClient::DescribeConfigurationRecorders, request, handler, context);
  }
 
  virtual Model::DescribeConformancePackComplianceOutcome DescribeConformancePackCompliance(
      const Model::DescribeConformancePackComplianceRequest& request) const;
 
  template <typename DescribeConformancePackComplianceRequestT = Model::DescribeConformancePackComplianceRequest>
  Model::DescribeConformancePackComplianceOutcomeCallable DescribeConformancePackComplianceCallable(
      const DescribeConformancePackComplianceRequestT& request) const {
    return SubmitCallable(&ConfigServiceClient::DescribeConformancePackCompliance, request);
  }
 
  template <typename DescribeConformancePackComplianceRequestT = Model::DescribeConformancePackComplianceRequest>
  void DescribeConformancePackComplianceAsync(const DescribeConformancePackComplianceRequestT& request,
                                              const DescribeConformancePackComplianceResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConfigServiceClient::DescribeConformancePackCompliance, request, handler, context);
  }
 
  virtual Model::DescribeConformancePackStatusOutcome DescribeConformancePackStatus(
      const Model::DescribeConformancePackStatusRequest& request = {}) const;
 
  template <typename DescribeConformancePackStatusRequestT = Model::DescribeConformancePackStatusRequest>
  Model::DescribeConformancePackStatusOutcomeCallable DescribeConformancePackStatusCallable(
      const DescribeConformancePackStatusRequestT& request = {}) const {
    return SubmitCallable(&ConfigServiceClient::DescribeConformancePackStatus, request);
  }
 
  template <typename DescribeConformancePackStatusRequestT = Model::DescribeConformancePackStatusRequest>
  void DescribeConformancePackStatusAsync(const DescribeConformancePackStatusResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                          const DescribeConformancePackStatusRequestT& request = {}) const {
    return SubmitAsync(&ConfigServiceClient::DescribeConformancePackStatus, request, handler, context);
  }
 
  virtual Model::DescribeConformancePacksOutcome DescribeConformancePacks(const Model::DescribeConformancePacksRequest& request = {}) const;
 
  template <typename DescribeConformancePacksRequestT = Model::DescribeConformancePacksRequest>
  Model::DescribeConformancePacksOutcomeCallable DescribeConformancePacksCallable(
      const DescribeConformancePacksRequestT& request = {}) const {
    return SubmitCallable(&ConfigServiceClient::DescribeConformancePacks, request);
  }
 
  template <typename DescribeConformancePacksRequestT = Model::DescribeConformancePacksRequest>
  void DescribeConformancePacksAsync(const DescribeConformancePacksResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                     const DescribeConformancePacksRequestT& request = {}) const {
    return SubmitAsync(&ConfigServiceClient::DescribeConformancePacks, request, handler, context);
  }
 
  virtual Model::DescribeDeliveryChannelStatusOutcome DescribeDeliveryChannelStatus(
      const Model::DescribeDeliveryChannelStatusRequest& request = {}) const;
 
  template <typename DescribeDeliveryChannelStatusRequestT = Model::DescribeDeliveryChannelStatusRequest>
  Model::DescribeDeliveryChannelStatusOutcomeCallable DescribeDeliveryChannelStatusCallable(
      const DescribeDeliveryChannelStatusRequestT& request = {}) const {
    return SubmitCallable(&ConfigServiceClient::DescribeDeliveryChannelStatus, request);
  }
 
  template <typename DescribeDeliveryChannelStatusRequestT = Model::DescribeDeliveryChannelStatusRequest>
  void DescribeDeliveryChannelStatusAsync(const DescribeDeliveryChannelStatusResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                          const DescribeDeliveryChannelStatusRequestT& request = {}) const {
    return SubmitAsync(&ConfigServiceClient::DescribeDeliveryChannelStatus, request, handler, context);
  }
 
  virtual Model::DescribeDeliveryChannelsOutcome DescribeDeliveryChannels(const Model::DescribeDeliveryChannelsRequest& request = {}) const;
 
  template <typename DescribeDeliveryChannelsRequestT = Model::DescribeDeliveryChannelsRequest>
  Model::DescribeDeliveryChannelsOutcomeCallable DescribeDeliveryChannelsCallable(
      const DescribeDeliveryChannelsRequestT& request = {}) const {
    return SubmitCallable(&ConfigServiceClient::DescribeDeliveryChannels, request);
  }
 
  template <typename DescribeDeliveryChannelsRequestT = Model::DescribeDeliveryChannelsRequest>
  void DescribeDeliveryChannelsAsync(const DescribeDeliveryChannelsResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                     const DescribeDeliveryChannelsRequestT& request = {}) const {
    return SubmitAsync(&ConfigServiceClient::DescribeDeliveryChannels, request, handler, context);
  }
 
  virtual Model::DescribeOrganizationConfigRuleStatusesOutcome DescribeOrganizationConfigRuleStatuses(
      const Model::DescribeOrganizationConfigRuleStatusesRequest& request = {}) const;
 
  template <typename DescribeOrganizationConfigRuleStatusesRequestT = Model::DescribeOrganizationConfigRuleStatusesRequest>
  Model::DescribeOrganizationConfigRuleStatusesOutcomeCallable DescribeOrganizationConfigRuleStatusesCallable(
      const DescribeOrganizationConfigRuleStatusesRequestT& request = {}) const {
    return SubmitCallable(&ConfigServiceClient::DescribeOrganizationConfigRuleStatuses, request);
  }
 
  template <typename DescribeOrganizationConfigRuleStatusesRequestT = Model::DescribeOrganizationConfigRuleStatusesRequest>
  void DescribeOrganizationConfigRuleStatusesAsync(const DescribeOrganizationConfigRuleStatusesResponseReceivedHandler& handler,
                                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                                   const DescribeOrganizationConfigRuleStatusesRequestT& request = {}) const {
    return SubmitAsync(&ConfigServiceClient::DescribeOrganizationConfigRuleStatuses, request, handler, context);
  }
 
  virtual Model::DescribeOrganizationConfigRulesOutcome DescribeOrganizationConfigRules(
      const Model::DescribeOrganizationConfigRulesRequest& request = {}) const;
 
  template <typename DescribeOrganizationConfigRulesRequestT = Model::DescribeOrganizationConfigRulesRequest>
  Model::DescribeOrganizationConfigRulesOutcomeCallable DescribeOrganizationConfigRulesCallable(
      const DescribeOrganizationConfigRulesRequestT& request = {}) const {
    return SubmitCallable(&ConfigServiceClient::DescribeOrganizationConfigRules, request);
  }
 
  template <typename DescribeOrganizationConfigRulesRequestT = Model::DescribeOrganizationConfigRulesRequest>
  void DescribeOrganizationConfigRulesAsync(const DescribeOrganizationConfigRulesResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                            const DescribeOrganizationConfigRulesRequestT& request = {}) const {
    return SubmitAsync(&ConfigServiceClient::DescribeOrganizationConfigRules, request, handler, context);
  }
 
  virtual Model::DescribeOrganizationConformancePackStatusesOutcome DescribeOrganizationConformancePackStatuses(
      const Model::DescribeOrganizationConformancePackStatusesRequest& request = {}) const;
 
  template <typename DescribeOrganizationConformancePackStatusesRequestT = Model::DescribeOrganizationConformancePackStatusesRequest>
  Model::DescribeOrganizationConformancePackStatusesOutcomeCallable DescribeOrganizationConformancePackStatusesCallable(
      const DescribeOrganizationConformancePackStatusesRequestT& request = {}) const {
    return SubmitCallable(&ConfigServiceClient::DescribeOrganizationConformancePackStatuses, request);
  }
 
  template <typename DescribeOrganizationConformancePackStatusesRequestT = Model::DescribeOrganizationConformancePackStatusesRequest>
  void DescribeOrganizationConformancePackStatusesAsync(const DescribeOrganizationConformancePackStatusesResponseReceivedHandler& handler,
                                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                                        const DescribeOrganizationConformancePackStatusesRequestT& request = {}) const {
    return SubmitAsync(&ConfigServiceClient::DescribeOrganizationConformancePackStatuses, request, handler, context);
  }
 
  virtual Model::DescribeOrganizationConformancePacksOutcome DescribeOrganizationConformancePacks(
      const Model::DescribeOrganizationConformancePacksRequest& request = {}) const;
 
  template <typename DescribeOrganizationConformancePacksRequestT = Model::DescribeOrganizationConformancePacksRequest>
  Model::DescribeOrganizationConformancePacksOutcomeCallable DescribeOrganizationConformancePacksCallable(
      const DescribeOrganizationConformancePacksRequestT& request = {}) const {
    return SubmitCallable(&ConfigServiceClient::DescribeOrganizationConformancePacks, request);
  }
 
  template <typename DescribeOrganizationConformancePacksRequestT = Model::DescribeOrganizationConformancePacksRequest>
  void DescribeOrganizationConformancePacksAsync(const DescribeOrganizationConformancePacksResponseReceivedHandler& handler,
                                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                                 const DescribeOrganizationConformancePacksRequestT& request = {}) const {
    return SubmitAsync(&ConfigServiceClient::DescribeOrganizationConformancePacks, request, handler, context);
  }
 
  virtual Model::DescribePendingAggregationRequestsOutcome DescribePendingAggregationRequests(
      const Model::DescribePendingAggregationRequestsRequest& request = {}) const;
 
  template <typename DescribePendingAggregationRequestsRequestT = Model::DescribePendingAggregationRequestsRequest>
  Model::DescribePendingAggregationRequestsOutcomeCallable DescribePendingAggregationRequestsCallable(
      const DescribePendingAggregationRequestsRequestT& request = {}) const {
    return SubmitCallable(&ConfigServiceClient::DescribePendingAggregationRequests, request);
  }
 
  template <typename DescribePendingAggregationRequestsRequestT = Model::DescribePendingAggregationRequestsRequest>
  void DescribePendingAggregationRequestsAsync(const DescribePendingAggregationRequestsResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                               const DescribePendingAggregationRequestsRequestT& request = {}) const {
    return SubmitAsync(&ConfigServiceClient::DescribePendingAggregationRequests, request, handler, context);
  }
 
  virtual Model::DescribeRemediationConfigurationsOutcome DescribeRemediationConfigurations(
      const Model::DescribeRemediationConfigurationsRequest& request) const;
 
  template <typename DescribeRemediationConfigurationsRequestT = Model::DescribeRemediationConfigurationsRequest>
  Model::DescribeRemediationConfigurationsOutcomeCallable DescribeRemediationConfigurationsCallable(
      const DescribeRemediationConfigurationsRequestT& request) const {
    return SubmitCallable(&ConfigServiceClient::DescribeRemediationConfigurations, request);
  }
 
  template <typename DescribeRemediationConfigurationsRequestT = Model::DescribeRemediationConfigurationsRequest>
  void DescribeRemediationConfigurationsAsync(const DescribeRemediationConfigurationsRequestT& request,
                                              const DescribeRemediationConfigurationsResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConfigServiceClient::DescribeRemediationConfigurations, request, handler, context);
  }
 
  virtual Model::DescribeRemediationExceptionsOutcome DescribeRemediationExceptions(
      const Model::DescribeRemediationExceptionsRequest& request) const;
 
  template <typename DescribeRemediationExceptionsRequestT = Model::DescribeRemediationExceptionsRequest>
  Model::DescribeRemediationExceptionsOutcomeCallable DescribeRemediationExceptionsCallable(
      const DescribeRemediationExceptionsRequestT& request) const {
    return SubmitCallable(&ConfigServiceClient::DescribeRemediationExceptions, request);
  }
 
  template <typename DescribeRemediationExceptionsRequestT = Model::DescribeRemediationExceptionsRequest>
  void DescribeRemediationExceptionsAsync(const DescribeRemediationExceptionsRequestT& request,
                                          const DescribeRemediationExceptionsResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConfigServiceClient::DescribeRemediationExceptions, request, handler, context);
  }
 
  virtual Model::DescribeRemediationExecutionStatusOutcome DescribeRemediationExecutionStatus(
      const Model::DescribeRemediationExecutionStatusRequest& request) const;
 
  template <typename DescribeRemediationExecutionStatusRequestT = Model::DescribeRemediationExecutionStatusRequest>
  Model::DescribeRemediationExecutionStatusOutcomeCallable DescribeRemediationExecutionStatusCallable(
      const DescribeRemediationExecutionStatusRequestT& request) const {
    return SubmitCallable(&ConfigServiceClient::DescribeRemediationExecutionStatus, request);
  }
 
  template <typename DescribeRemediationExecutionStatusRequestT = Model::DescribeRemediationExecutionStatusRequest>
  void DescribeRemediationExecutionStatusAsync(const DescribeRemediationExecutionStatusRequestT& request,
                                               const DescribeRemediationExecutionStatusResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConfigServiceClient::DescribeRemediationExecutionStatus, request, handler, context);
  }
 
  virtual Model::DescribeRetentionConfigurationsOutcome DescribeRetentionConfigurations(
      const Model::DescribeRetentionConfigurationsRequest& request = {}) const;
 
  template <typename DescribeRetentionConfigurationsRequestT = Model::DescribeRetentionConfigurationsRequest>
  Model::DescribeRetentionConfigurationsOutcomeCallable DescribeRetentionConfigurationsCallable(
      const DescribeRetentionConfigurationsRequestT& request = {}) const {
    return SubmitCallable(&ConfigServiceClient::DescribeRetentionConfigurations, request);
  }
 
  template <typename DescribeRetentionConfigurationsRequestT = Model::DescribeRetentionConfigurationsRequest>
  void DescribeRetentionConfigurationsAsync(const DescribeRetentionConfigurationsResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                            const DescribeRetentionConfigurationsRequestT& request = {}) const {
    return SubmitAsync(&ConfigServiceClient::DescribeRetentionConfigurations, request, handler, context);
  }
 
  virtual Model::DisassociateResourceTypesOutcome DisassociateResourceTypes(const Model::DisassociateResourceTypesRequest& request) const;
 
  template <typename DisassociateResourceTypesRequestT = Model::DisassociateResourceTypesRequest>
  Model::DisassociateResourceTypesOutcomeCallable DisassociateResourceTypesCallable(
      const DisassociateResourceTypesRequestT& request) const {
    return SubmitCallable(&ConfigServiceClient::DisassociateResourceTypes, request);
  }
 
  template <typename DisassociateResourceTypesRequestT = Model::DisassociateResourceTypesRequest>
  void DisassociateResourceTypesAsync(const DisassociateResourceTypesRequestT& request,
                                      const DisassociateResourceTypesResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConfigServiceClient::DisassociateResourceTypes, request, handler, context);
  }
 
  virtual Model::GetAggregateComplianceDetailsByConfigRuleOutcome GetAggregateComplianceDetailsByConfigRule(
      const Model::GetAggregateComplianceDetailsByConfigRuleRequest& request) const;
 
  template <typename GetAggregateComplianceDetailsByConfigRuleRequestT = Model::GetAggregateComplianceDetailsByConfigRuleRequest>
  Model::GetAggregateComplianceDetailsByConfigRuleOutcomeCallable GetAggregateComplianceDetailsByConfigRuleCallable(
      const GetAggregateComplianceDetailsByConfigRuleRequestT& request) const {
    return SubmitCallable(&ConfigServiceClient::GetAggregateComplianceDetailsByConfigRule, request);
  }
 
  template <typename GetAggregateComplianceDetailsByConfigRuleRequestT = Model::GetAggregateComplianceDetailsByConfigRuleRequest>
  void GetAggregateComplianceDetailsByConfigRuleAsync(
      const GetAggregateComplianceDetailsByConfigRuleRequestT& request,
      const GetAggregateComplianceDetailsByConfigRuleResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConfigServiceClient::GetAggregateComplianceDetailsByConfigRule, request, handler, context);
  }
 
  virtual Model::GetAggregateConfigRuleComplianceSummaryOutcome GetAggregateConfigRuleComplianceSummary(
      const Model::GetAggregateConfigRuleComplianceSummaryRequest& request) const;
 
  template <typename GetAggregateConfigRuleComplianceSummaryRequestT = Model::GetAggregateConfigRuleComplianceSummaryRequest>
  Model::GetAggregateConfigRuleComplianceSummaryOutcomeCallable GetAggregateConfigRuleComplianceSummaryCallable(
      const GetAggregateConfigRuleComplianceSummaryRequestT& request) const {
    return SubmitCallable(&ConfigServiceClient::GetAggregateConfigRuleComplianceSummary, request);
  }
 
  template <typename GetAggregateConfigRuleComplianceSummaryRequestT = Model::GetAggregateConfigRuleComplianceSummaryRequest>
  void GetAggregateConfigRuleComplianceSummaryAsync(const GetAggregateConfigRuleComplianceSummaryRequestT& request,
                                                    const GetAggregateConfigRuleComplianceSummaryResponseReceivedHandler& handler,
                                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConfigServiceClient::GetAggregateConfigRuleComplianceSummary, request, handler, context);
  }
 
  virtual Model::GetAggregateConformancePackComplianceSummaryOutcome GetAggregateConformancePackComplianceSummary(
      const Model::GetAggregateConformancePackComplianceSummaryRequest& request) const;
 
  template <typename GetAggregateConformancePackComplianceSummaryRequestT = Model::GetAggregateConformancePackComplianceSummaryRequest>
  Model::GetAggregateConformancePackComplianceSummaryOutcomeCallable GetAggregateConformancePackComplianceSummaryCallable(
      const GetAggregateConformancePackComplianceSummaryRequestT& request) const {
    return SubmitCallable(&ConfigServiceClient::GetAggregateConformancePackComplianceSummary, request);
  }
 
  template <typename GetAggregateConformancePackComplianceSummaryRequestT = Model::GetAggregateConformancePackComplianceSummaryRequest>
  void GetAggregateConformancePackComplianceSummaryAsync(
      const GetAggregateConformancePackComplianceSummaryRequestT& request,
      const GetAggregateConformancePackComplianceSummaryResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConfigServiceClient::GetAggregateConformancePackComplianceSummary, request, handler, context);
  }
 
  virtual Model::GetAggregateDiscoveredResourceCountsOutcome GetAggregateDiscoveredResourceCounts(
      const Model::GetAggregateDiscoveredResourceCountsRequest& request) const;
 
  template <typename GetAggregateDiscoveredResourceCountsRequestT = Model::GetAggregateDiscoveredResourceCountsRequest>
  Model::GetAggregateDiscoveredResourceCountsOutcomeCallable GetAggregateDiscoveredResourceCountsCallable(
      const GetAggregateDiscoveredResourceCountsRequestT& request) const {
    return SubmitCallable(&ConfigServiceClient::GetAggregateDiscoveredResourceCounts, request);
  }
 
  template <typename GetAggregateDiscoveredResourceCountsRequestT = Model::GetAggregateDiscoveredResourceCountsRequest>
  void GetAggregateDiscoveredResourceCountsAsync(const GetAggregateDiscoveredResourceCountsRequestT& request,
                                                 const GetAggregateDiscoveredResourceCountsResponseReceivedHandler& handler,
                                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConfigServiceClient::GetAggregateDiscoveredResourceCounts, request, handler, context);
  }
 
  virtual Model::GetAggregateResourceConfigOutcome GetAggregateResourceConfig(
      const Model::GetAggregateResourceConfigRequest& request) const;
 
  template <typename GetAggregateResourceConfigRequestT = Model::GetAggregateResourceConfigRequest>
  Model::GetAggregateResourceConfigOutcomeCallable GetAggregateResourceConfigCallable(
      const GetAggregateResourceConfigRequestT& request) const {
    return SubmitCallable(&ConfigServiceClient::GetAggregateResourceConfig, request);
  }
 
  template <typename GetAggregateResourceConfigRequestT = Model::GetAggregateResourceConfigRequest>
  void GetAggregateResourceConfigAsync(const GetAggregateResourceConfigRequestT& request,
                                       const GetAggregateResourceConfigResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConfigServiceClient::GetAggregateResourceConfig, request, handler, context);
  }
 
  virtual Model::GetComplianceDetailsByConfigRuleOutcome GetComplianceDetailsByConfigRule(
      const Model::GetComplianceDetailsByConfigRuleRequest& request) const;
 
  template <typename GetComplianceDetailsByConfigRuleRequestT = Model::GetComplianceDetailsByConfigRuleRequest>
  Model::GetComplianceDetailsByConfigRuleOutcomeCallable GetComplianceDetailsByConfigRuleCallable(
      const GetComplianceDetailsByConfigRuleRequestT& request) const {
    return SubmitCallable(&ConfigServiceClient::GetComplianceDetailsByConfigRule, request);
  }
 
  template <typename GetComplianceDetailsByConfigRuleRequestT = Model::GetComplianceDetailsByConfigRuleRequest>
  void GetComplianceDetailsByConfigRuleAsync(const GetComplianceDetailsByConfigRuleRequestT& request,
                                             const GetComplianceDetailsByConfigRuleResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConfigServiceClient::GetComplianceDetailsByConfigRule, request, handler, context);
  }
 
  virtual Model::GetComplianceDetailsByResourceOutcome GetComplianceDetailsByResource(
      const Model::GetComplianceDetailsByResourceRequest& request = {}) const;
 
  template <typename GetComplianceDetailsByResourceRequestT = Model::GetComplianceDetailsByResourceRequest>
  Model::GetComplianceDetailsByResourceOutcomeCallable GetComplianceDetailsByResourceCallable(
      const GetComplianceDetailsByResourceRequestT& request = {}) const {
    return SubmitCallable(&ConfigServiceClient::GetComplianceDetailsByResource, request);
  }
 
  template <typename GetComplianceDetailsByResourceRequestT = Model::GetComplianceDetailsByResourceRequest>
  void GetComplianceDetailsByResourceAsync(const GetComplianceDetailsByResourceResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                           const GetComplianceDetailsByResourceRequestT& request = {}) const {
    return SubmitAsync(&ConfigServiceClient::GetComplianceDetailsByResource, request, handler, context);
  }
 
  virtual Model::GetComplianceSummaryByConfigRuleOutcome GetComplianceSummaryByConfigRule(
      const Model::GetComplianceSummaryByConfigRuleRequest& request = {}) const;
 
  template <typename GetComplianceSummaryByConfigRuleRequestT = Model::GetComplianceSummaryByConfigRuleRequest>
  Model::GetComplianceSummaryByConfigRuleOutcomeCallable GetComplianceSummaryByConfigRuleCallable(
      const GetComplianceSummaryByConfigRuleRequestT& request = {}) const {
    return SubmitCallable(&ConfigServiceClient::GetComplianceSummaryByConfigRule, request);
  }
 
  template <typename GetComplianceSummaryByConfigRuleRequestT = Model::GetComplianceSummaryByConfigRuleRequest>
  void GetComplianceSummaryByConfigRuleAsync(const GetComplianceSummaryByConfigRuleResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                             const GetComplianceSummaryByConfigRuleRequestT& request = {}) const {
    return SubmitAsync(&ConfigServiceClient::GetComplianceSummaryByConfigRule, request, handler, context);
  }
 
  virtual Model::GetComplianceSummaryByResourceTypeOutcome GetComplianceSummaryByResourceType(
      const Model::GetComplianceSummaryByResourceTypeRequest& request = {}) const;
 
  template <typename GetComplianceSummaryByResourceTypeRequestT = Model::GetComplianceSummaryByResourceTypeRequest>
  Model::GetComplianceSummaryByResourceTypeOutcomeCallable GetComplianceSummaryByResourceTypeCallable(
      const GetComplianceSummaryByResourceTypeRequestT& request = {}) const {
    return SubmitCallable(&ConfigServiceClient::GetComplianceSummaryByResourceType, request);
  }
 
  template <typename GetComplianceSummaryByResourceTypeRequestT = Model::GetComplianceSummaryByResourceTypeRequest>
  void GetComplianceSummaryByResourceTypeAsync(const GetComplianceSummaryByResourceTypeResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                               const GetComplianceSummaryByResourceTypeRequestT& request = {}) const {
    return SubmitAsync(&ConfigServiceClient::GetComplianceSummaryByResourceType, request, handler, context);
  }
 
  virtual Model::GetConformancePackComplianceDetailsOutcome GetConformancePackComplianceDetails(
      const Model::GetConformancePackComplianceDetailsRequest& request) const;
 
  template <typename GetConformancePackComplianceDetailsRequestT = Model::GetConformancePackComplianceDetailsRequest>
  Model::GetConformancePackComplianceDetailsOutcomeCallable GetConformancePackComplianceDetailsCallable(
      const GetConformancePackComplianceDetailsRequestT& request) const {
    return SubmitCallable(&ConfigServiceClient::GetConformancePackComplianceDetails, request);
  }
 
  template <typename GetConformancePackComplianceDetailsRequestT = Model::GetConformancePackComplianceDetailsRequest>
  void GetConformancePackComplianceDetailsAsync(const GetConformancePackComplianceDetailsRequestT& request,
                                                const GetConformancePackComplianceDetailsResponseReceivedHandler& handler,
                                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConfigServiceClient::GetConformancePackComplianceDetails, request, handler, context);
  }
 
  virtual Model::GetConformancePackComplianceSummaryOutcome GetConformancePackComplianceSummary(
      const Model::GetConformancePackComplianceSummaryRequest& request) const;
 
  template <typename GetConformancePackComplianceSummaryRequestT = Model::GetConformancePackComplianceSummaryRequest>
  Model::GetConformancePackComplianceSummaryOutcomeCallable GetConformancePackComplianceSummaryCallable(
      const GetConformancePackComplianceSummaryRequestT& request) const {
    return SubmitCallable(&ConfigServiceClient::GetConformancePackComplianceSummary, request);
  }
 
  template <typename GetConformancePackComplianceSummaryRequestT = Model::GetConformancePackComplianceSummaryRequest>
  void GetConformancePackComplianceSummaryAsync(const GetConformancePackComplianceSummaryRequestT& request,
                                                const GetConformancePackComplianceSummaryResponseReceivedHandler& handler,
                                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConfigServiceClient::GetConformancePackComplianceSummary, request, handler, context);
  }
 
  virtual Model::GetConnectorOutcome GetConnector(const Model::GetConnectorRequest& request) const;
 
  template <typename GetConnectorRequestT = Model::GetConnectorRequest>
  Model::GetConnectorOutcomeCallable GetConnectorCallable(const GetConnectorRequestT& request) const {
    return SubmitCallable(&ConfigServiceClient::GetConnector, request);
  }
 
  template <typename GetConnectorRequestT = Model::GetConnectorRequest>
  void GetConnectorAsync(const GetConnectorRequestT& request, const GetConnectorResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConfigServiceClient::GetConnector, request, handler, context);
  }
 
  virtual Model::GetCustomRulePolicyOutcome GetCustomRulePolicy(const Model::GetCustomRulePolicyRequest& request = {}) const;
 
  template <typename GetCustomRulePolicyRequestT = Model::GetCustomRulePolicyRequest>
  Model::GetCustomRulePolicyOutcomeCallable GetCustomRulePolicyCallable(const GetCustomRulePolicyRequestT& request = {}) const {
    return SubmitCallable(&ConfigServiceClient::GetCustomRulePolicy, request);
  }
 
  template <typename GetCustomRulePolicyRequestT = Model::GetCustomRulePolicyRequest>
  void GetCustomRulePolicyAsync(const GetCustomRulePolicyResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                const GetCustomRulePolicyRequestT& request = {}) const {
    return SubmitAsync(&ConfigServiceClient::GetCustomRulePolicy, request, handler, context);
  }
 
  virtual Model::GetDiscoveredResourceCountsOutcome GetDiscoveredResourceCounts(
      const Model::GetDiscoveredResourceCountsRequest& request = {}) const;
 
  template <typename GetDiscoveredResourceCountsRequestT = Model::GetDiscoveredResourceCountsRequest>
  Model::GetDiscoveredResourceCountsOutcomeCallable GetDiscoveredResourceCountsCallable(
      const GetDiscoveredResourceCountsRequestT& request = {}) const {
    return SubmitCallable(&ConfigServiceClient::GetDiscoveredResourceCounts, request);
  }
 
  template <typename GetDiscoveredResourceCountsRequestT = Model::GetDiscoveredResourceCountsRequest>
  void GetDiscoveredResourceCountsAsync(const GetDiscoveredResourceCountsResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                        const GetDiscoveredResourceCountsRequestT& request = {}) const {
    return SubmitAsync(&ConfigServiceClient::GetDiscoveredResourceCounts, request, handler, context);
  }
 
  virtual Model::GetOrganizationConfigRuleDetailedStatusOutcome GetOrganizationConfigRuleDetailedStatus(
      const Model::GetOrganizationConfigRuleDetailedStatusRequest& request) const;
 
  template <typename GetOrganizationConfigRuleDetailedStatusRequestT = Model::GetOrganizationConfigRuleDetailedStatusRequest>
  Model::GetOrganizationConfigRuleDetailedStatusOutcomeCallable GetOrganizationConfigRuleDetailedStatusCallable(
      const GetOrganizationConfigRuleDetailedStatusRequestT& request) const {
    return SubmitCallable(&ConfigServiceClient::GetOrganizationConfigRuleDetailedStatus, request);
  }
 
  template <typename GetOrganizationConfigRuleDetailedStatusRequestT = Model::GetOrganizationConfigRuleDetailedStatusRequest>
  void GetOrganizationConfigRuleDetailedStatusAsync(const GetOrganizationConfigRuleDetailedStatusRequestT& request,
                                                    const GetOrganizationConfigRuleDetailedStatusResponseReceivedHandler& handler,
                                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConfigServiceClient::GetOrganizationConfigRuleDetailedStatus, request, handler, context);
  }
 
  virtual Model::GetOrganizationConformancePackDetailedStatusOutcome GetOrganizationConformancePackDetailedStatus(
      const Model::GetOrganizationConformancePackDetailedStatusRequest& request) const;
 
  template <typename GetOrganizationConformancePackDetailedStatusRequestT = Model::GetOrganizationConformancePackDetailedStatusRequest>
  Model::GetOrganizationConformancePackDetailedStatusOutcomeCallable GetOrganizationConformancePackDetailedStatusCallable(
      const GetOrganizationConformancePackDetailedStatusRequestT& request) const {
    return SubmitCallable(&ConfigServiceClient::GetOrganizationConformancePackDetailedStatus, request);
  }
 
  template <typename GetOrganizationConformancePackDetailedStatusRequestT = Model::GetOrganizationConformancePackDetailedStatusRequest>
  void GetOrganizationConformancePackDetailedStatusAsync(
      const GetOrganizationConformancePackDetailedStatusRequestT& request,
      const GetOrganizationConformancePackDetailedStatusResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConfigServiceClient::GetOrganizationConformancePackDetailedStatus, request, handler, context);
  }
 
  virtual Model::GetOrganizationCustomRulePolicyOutcome GetOrganizationCustomRulePolicy(
      const Model::GetOrganizationCustomRulePolicyRequest& request) const;
 
  template <typename GetOrganizationCustomRulePolicyRequestT = Model::GetOrganizationCustomRulePolicyRequest>
  Model::GetOrganizationCustomRulePolicyOutcomeCallable GetOrganizationCustomRulePolicyCallable(
      const GetOrganizationCustomRulePolicyRequestT& request) const {
    return SubmitCallable(&ConfigServiceClient::GetOrganizationCustomRulePolicy, request);
  }
 
  template <typename GetOrganizationCustomRulePolicyRequestT = Model::GetOrganizationCustomRulePolicyRequest>
  void GetOrganizationCustomRulePolicyAsync(const GetOrganizationCustomRulePolicyRequestT& request,
                                            const GetOrganizationCustomRulePolicyResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConfigServiceClient::GetOrganizationCustomRulePolicy, request, handler, context);
  }
 
  virtual Model::GetResourceConfigHistoryOutcome GetResourceConfigHistory(const Model::GetResourceConfigHistoryRequest& request) const;
 
  template <typename GetResourceConfigHistoryRequestT = Model::GetResourceConfigHistoryRequest>
  Model::GetResourceConfigHistoryOutcomeCallable GetResourceConfigHistoryCallable(const GetResourceConfigHistoryRequestT& request) const {
    return SubmitCallable(&ConfigServiceClient::GetResourceConfigHistory, request);
  }
 
  template <typename GetResourceConfigHistoryRequestT = Model::GetResourceConfigHistoryRequest>
  void GetResourceConfigHistoryAsync(const GetResourceConfigHistoryRequestT& request,
                                     const GetResourceConfigHistoryResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConfigServiceClient::GetResourceConfigHistory, request, handler, context);
  }
 
  virtual Model::GetResourceEvaluationSummaryOutcome GetResourceEvaluationSummary(
      const Model::GetResourceEvaluationSummaryRequest& request) const;
 
  template <typename GetResourceEvaluationSummaryRequestT = Model::GetResourceEvaluationSummaryRequest>
  Model::GetResourceEvaluationSummaryOutcomeCallable GetResourceEvaluationSummaryCallable(
      const GetResourceEvaluationSummaryRequestT& request) const {
    return SubmitCallable(&ConfigServiceClient::GetResourceEvaluationSummary, request);
  }
 
  template <typename GetResourceEvaluationSummaryRequestT = Model::GetResourceEvaluationSummaryRequest>
  void GetResourceEvaluationSummaryAsync(const GetResourceEvaluationSummaryRequestT& request,
                                         const GetResourceEvaluationSummaryResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConfigServiceClient::GetResourceEvaluationSummary, request, handler, context);
  }
 
  virtual Model::GetStoredQueryOutcome GetStoredQuery(const Model::GetStoredQueryRequest& request) const;
 
  template <typename GetStoredQueryRequestT = Model::GetStoredQueryRequest>
  Model::GetStoredQueryOutcomeCallable GetStoredQueryCallable(const GetStoredQueryRequestT& request) const {
    return SubmitCallable(&ConfigServiceClient::GetStoredQuery, request);
  }
 
  template <typename GetStoredQueryRequestT = Model::GetStoredQueryRequest>
  void GetStoredQueryAsync(const GetStoredQueryRequestT& request, const GetStoredQueryResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConfigServiceClient::GetStoredQuery, request, handler, context);
  }
 
  virtual Model::ListAggregateDiscoveredResourcesOutcome ListAggregateDiscoveredResources(
      const Model::ListAggregateDiscoveredResourcesRequest& request) const;
 
  template <typename ListAggregateDiscoveredResourcesRequestT = Model::ListAggregateDiscoveredResourcesRequest>
  Model::ListAggregateDiscoveredResourcesOutcomeCallable ListAggregateDiscoveredResourcesCallable(
      const ListAggregateDiscoveredResourcesRequestT& request) const {
    return SubmitCallable(&ConfigServiceClient::ListAggregateDiscoveredResources, request);
  }
 
  template <typename ListAggregateDiscoveredResourcesRequestT = Model::ListAggregateDiscoveredResourcesRequest>
  void ListAggregateDiscoveredResourcesAsync(const ListAggregateDiscoveredResourcesRequestT& request,
                                             const ListAggregateDiscoveredResourcesResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConfigServiceClient::ListAggregateDiscoveredResources, request, handler, context);
  }
 
  virtual Model::ListConfigurationRecordersOutcome ListConfigurationRecorders(
      const Model::ListConfigurationRecordersRequest& request = {}) const;
 
  template <typename ListConfigurationRecordersRequestT = Model::ListConfigurationRecordersRequest>
  Model::ListConfigurationRecordersOutcomeCallable ListConfigurationRecordersCallable(
      const ListConfigurationRecordersRequestT& request = {}) const {
    return SubmitCallable(&ConfigServiceClient::ListConfigurationRecorders, request);
  }
 
  template <typename ListConfigurationRecordersRequestT = Model::ListConfigurationRecordersRequest>
  void ListConfigurationRecordersAsync(const ListConfigurationRecordersResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                       const ListConfigurationRecordersRequestT& request = {}) const {
    return SubmitAsync(&ConfigServiceClient::ListConfigurationRecorders, request, handler, context);
  }
 
  virtual Model::ListConformancePackComplianceScoresOutcome ListConformancePackComplianceScores(
      const Model::ListConformancePackComplianceScoresRequest& request = {}) const;
 
  template <typename ListConformancePackComplianceScoresRequestT = Model::ListConformancePackComplianceScoresRequest>
  Model::ListConformancePackComplianceScoresOutcomeCallable ListConformancePackComplianceScoresCallable(
      const ListConformancePackComplianceScoresRequestT& request = {}) const {
    return SubmitCallable(&ConfigServiceClient::ListConformancePackComplianceScores, request);
  }
 
  template <typename ListConformancePackComplianceScoresRequestT = Model::ListConformancePackComplianceScoresRequest>
  void ListConformancePackComplianceScoresAsync(const ListConformancePackComplianceScoresResponseReceivedHandler& handler,
                                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                                const ListConformancePackComplianceScoresRequestT& request = {}) const {
    return SubmitAsync(&ConfigServiceClient::ListConformancePackComplianceScores, request, handler, context);
  }
 
  virtual Model::ListConnectorsOutcome ListConnectors(const Model::ListConnectorsRequest& request = {}) const;
 
  template <typename ListConnectorsRequestT = Model::ListConnectorsRequest>
  Model::ListConnectorsOutcomeCallable ListConnectorsCallable(const ListConnectorsRequestT& request = {}) const {
    return SubmitCallable(&ConfigServiceClient::ListConnectors, request);
  }
 
  template <typename ListConnectorsRequestT = Model::ListConnectorsRequest>
  void ListConnectorsAsync(const ListConnectorsResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                           const ListConnectorsRequestT& request = {}) const {
    return SubmitAsync(&ConfigServiceClient::ListConnectors, request, handler, context);
  }
 
  virtual Model::ListDiscoveredResourcesOutcome ListDiscoveredResources(const Model::ListDiscoveredResourcesRequest& request) const;
 
  template <typename ListDiscoveredResourcesRequestT = Model::ListDiscoveredResourcesRequest>
  Model::ListDiscoveredResourcesOutcomeCallable ListDiscoveredResourcesCallable(const ListDiscoveredResourcesRequestT& request) const {
    return SubmitCallable(&ConfigServiceClient::ListDiscoveredResources, request);
  }
 
  template <typename ListDiscoveredResourcesRequestT = Model::ListDiscoveredResourcesRequest>
  void ListDiscoveredResourcesAsync(const ListDiscoveredResourcesRequestT& request,
                                    const ListDiscoveredResourcesResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConfigServiceClient::ListDiscoveredResources, request, handler, context);
  }
 
  virtual Model::ListResourceEvaluationsOutcome ListResourceEvaluations(const Model::ListResourceEvaluationsRequest& request = {}) const;
 
  template <typename ListResourceEvaluationsRequestT = Model::ListResourceEvaluationsRequest>
  Model::ListResourceEvaluationsOutcomeCallable ListResourceEvaluationsCallable(const ListResourceEvaluationsRequestT& request = {}) const {
    return SubmitCallable(&ConfigServiceClient::ListResourceEvaluations, request);
  }
 
  template <typename ListResourceEvaluationsRequestT = Model::ListResourceEvaluationsRequest>
  void ListResourceEvaluationsAsync(const ListResourceEvaluationsResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                    const ListResourceEvaluationsRequestT& request = {}) const {
    return SubmitAsync(&ConfigServiceClient::ListResourceEvaluations, request, handler, context);
  }
 
  virtual Model::ListStoredQueriesOutcome ListStoredQueries(const Model::ListStoredQueriesRequest& request = {}) const;
 
  template <typename ListStoredQueriesRequestT = Model::ListStoredQueriesRequest>
  Model::ListStoredQueriesOutcomeCallable ListStoredQueriesCallable(const ListStoredQueriesRequestT& request = {}) const {
    return SubmitCallable(&ConfigServiceClient::ListStoredQueries, request);
  }
 
  template <typename ListStoredQueriesRequestT = Model::ListStoredQueriesRequest>
  void ListStoredQueriesAsync(const ListStoredQueriesResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                              const ListStoredQueriesRequestT& request = {}) const {
    return SubmitAsync(&ConfigServiceClient::ListStoredQueries, request, handler, context);
  }
 
  virtual Model::ListTagsForResourceOutcome ListTagsForResource(const Model::ListTagsForResourceRequest& request) const;
 
  template <typename ListTagsForResourceRequestT = Model::ListTagsForResourceRequest>
  Model::ListTagsForResourceOutcomeCallable ListTagsForResourceCallable(const ListTagsForResourceRequestT& request) const {
    return SubmitCallable(&ConfigServiceClient::ListTagsForResource, request);
  }
 
  template <typename ListTagsForResourceRequestT = Model::ListTagsForResourceRequest>
  void ListTagsForResourceAsync(const ListTagsForResourceRequestT& request, const ListTagsForResourceResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConfigServiceClient::ListTagsForResource, request, handler, context);
  }
 
  virtual Model::PutAggregationAuthorizationOutcome PutAggregationAuthorization(
      const Model::PutAggregationAuthorizationRequest& request) const;
 
  template <typename PutAggregationAuthorizationRequestT = Model::PutAggregationAuthorizationRequest>
  Model::PutAggregationAuthorizationOutcomeCallable PutAggregationAuthorizationCallable(
      const PutAggregationAuthorizationRequestT& request) const {
    return SubmitCallable(&ConfigServiceClient::PutAggregationAuthorization, request);
  }
 
  template <typename PutAggregationAuthorizationRequestT = Model::PutAggregationAuthorizationRequest>
  void PutAggregationAuthorizationAsync(const PutAggregationAuthorizationRequestT& request,
                                        const PutAggregationAuthorizationResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConfigServiceClient::PutAggregationAuthorization, request, handler, context);
  }
 
  virtual Model::PutConfigRuleOutcome PutConfigRule(const Model::PutConfigRuleRequest& request) const;
 
  template <typename PutConfigRuleRequestT = Model::PutConfigRuleRequest>
  Model::PutConfigRuleOutcomeCallable PutConfigRuleCallable(const PutConfigRuleRequestT& request) const {
    return SubmitCallable(&ConfigServiceClient::PutConfigRule, request);
  }
 
  template <typename PutConfigRuleRequestT = Model::PutConfigRuleRequest>
  void PutConfigRuleAsync(const PutConfigRuleRequestT& request, const PutConfigRuleResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConfigServiceClient::PutConfigRule, request, handler, context);
  }
 
  virtual Model::PutConfigurationAggregatorOutcome PutConfigurationAggregator(
      const Model::PutConfigurationAggregatorRequest& request) const;
 
  template <typename PutConfigurationAggregatorRequestT = Model::PutConfigurationAggregatorRequest>
  Model::PutConfigurationAggregatorOutcomeCallable PutConfigurationAggregatorCallable(
      const PutConfigurationAggregatorRequestT& request) const {
    return SubmitCallable(&ConfigServiceClient::PutConfigurationAggregator, request);
  }
 
  template <typename PutConfigurationAggregatorRequestT = Model::PutConfigurationAggregatorRequest>
  void PutConfigurationAggregatorAsync(const PutConfigurationAggregatorRequestT& request,
                                       const PutConfigurationAggregatorResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConfigServiceClient::PutConfigurationAggregator, request, handler, context);
  }
 
  virtual Model::PutConfigurationRecorderOutcome PutConfigurationRecorder(const Model::PutConfigurationRecorderRequest& request) const;
 
  template <typename PutConfigurationRecorderRequestT = Model::PutConfigurationRecorderRequest>
  Model::PutConfigurationRecorderOutcomeCallable PutConfigurationRecorderCallable(const PutConfigurationRecorderRequestT& request) const {
    return SubmitCallable(&ConfigServiceClient::PutConfigurationRecorder, request);
  }
 
  template <typename PutConfigurationRecorderRequestT = Model::PutConfigurationRecorderRequest>
  void PutConfigurationRecorderAsync(const PutConfigurationRecorderRequestT& request,
                                     const PutConfigurationRecorderResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConfigServiceClient::PutConfigurationRecorder, request, handler, context);
  }
 
  virtual Model::PutConformancePackOutcome PutConformancePack(const Model::PutConformancePackRequest& request) const;
 
  template <typename PutConformancePackRequestT = Model::PutConformancePackRequest>
  Model::PutConformancePackOutcomeCallable PutConformancePackCallable(const PutConformancePackRequestT& request) const {
    return SubmitCallable(&ConfigServiceClient::PutConformancePack, request);
  }
 
  template <typename PutConformancePackRequestT = Model::PutConformancePackRequest>
  void PutConformancePackAsync(const PutConformancePackRequestT& request, const PutConformancePackResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConfigServiceClient::PutConformancePack, request, handler, context);
  }
 
  virtual Model::PutConnectorOutcome PutConnector(const Model::PutConnectorRequest& request) const;
 
  template <typename PutConnectorRequestT = Model::PutConnectorRequest>
  Model::PutConnectorOutcomeCallable PutConnectorCallable(const PutConnectorRequestT& request) const {
    return SubmitCallable(&ConfigServiceClient::PutConnector, request);
  }
 
  template <typename PutConnectorRequestT = Model::PutConnectorRequest>
  void PutConnectorAsync(const PutConnectorRequestT& request, const PutConnectorResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConfigServiceClient::PutConnector, request, handler, context);
  }
 
  virtual Model::PutDeliveryChannelOutcome PutDeliveryChannel(const Model::PutDeliveryChannelRequest& request) const;
 
  template <typename PutDeliveryChannelRequestT = Model::PutDeliveryChannelRequest>
  Model::PutDeliveryChannelOutcomeCallable PutDeliveryChannelCallable(const PutDeliveryChannelRequestT& request) const {
    return SubmitCallable(&ConfigServiceClient::PutDeliveryChannel, request);
  }
 
  template <typename PutDeliveryChannelRequestT = Model::PutDeliveryChannelRequest>
  void PutDeliveryChannelAsync(const PutDeliveryChannelRequestT& request, const PutDeliveryChannelResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConfigServiceClient::PutDeliveryChannel, request, handler, context);
  }
 
  virtual Model::PutEvaluationsOutcome PutEvaluations(const Model::PutEvaluationsRequest& request) const;
 
  template <typename PutEvaluationsRequestT = Model::PutEvaluationsRequest>
  Model::PutEvaluationsOutcomeCallable PutEvaluationsCallable(const PutEvaluationsRequestT& request) const {
    return SubmitCallable(&ConfigServiceClient::PutEvaluations, request);
  }
 
  template <typename PutEvaluationsRequestT = Model::PutEvaluationsRequest>
  void PutEvaluationsAsync(const PutEvaluationsRequestT& request, const PutEvaluationsResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConfigServiceClient::PutEvaluations, request, handler, context);
  }
 
  virtual Model::PutExternalEvaluationOutcome PutExternalEvaluation(const Model::PutExternalEvaluationRequest& request) const;
 
  template <typename PutExternalEvaluationRequestT = Model::PutExternalEvaluationRequest>
  Model::PutExternalEvaluationOutcomeCallable PutExternalEvaluationCallable(const PutExternalEvaluationRequestT& request) const {
    return SubmitCallable(&ConfigServiceClient::PutExternalEvaluation, request);
  }
 
  template <typename PutExternalEvaluationRequestT = Model::PutExternalEvaluationRequest>
  void PutExternalEvaluationAsync(const PutExternalEvaluationRequestT& request, const PutExternalEvaluationResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConfigServiceClient::PutExternalEvaluation, request, handler, context);
  }
 
  virtual Model::PutOrganizationConfigRuleOutcome PutOrganizationConfigRule(const Model::PutOrganizationConfigRuleRequest& request) const;
 
  template <typename PutOrganizationConfigRuleRequestT = Model::PutOrganizationConfigRuleRequest>
  Model::PutOrganizationConfigRuleOutcomeCallable PutOrganizationConfigRuleCallable(
      const PutOrganizationConfigRuleRequestT& request) const {
    return SubmitCallable(&ConfigServiceClient::PutOrganizationConfigRule, request);
  }
 
  template <typename PutOrganizationConfigRuleRequestT = Model::PutOrganizationConfigRuleRequest>
  void PutOrganizationConfigRuleAsync(const PutOrganizationConfigRuleRequestT& request,
                                      const PutOrganizationConfigRuleResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConfigServiceClient::PutOrganizationConfigRule, request, handler, context);
  }
 
  virtual Model::PutOrganizationConformancePackOutcome PutOrganizationConformancePack(
      const Model::PutOrganizationConformancePackRequest& request) const;
 
  template <typename PutOrganizationConformancePackRequestT = Model::PutOrganizationConformancePackRequest>
  Model::PutOrganizationConformancePackOutcomeCallable PutOrganizationConformancePackCallable(
      const PutOrganizationConformancePackRequestT& request) const {
    return SubmitCallable(&ConfigServiceClient::PutOrganizationConformancePack, request);
  }
 
  template <typename PutOrganizationConformancePackRequestT = Model::PutOrganizationConformancePackRequest>
  void PutOrganizationConformancePackAsync(const PutOrganizationConformancePackRequestT& request,
                                           const PutOrganizationConformancePackResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConfigServiceClient::PutOrganizationConformancePack, request, handler, context);
  }
 
  virtual Model::PutRemediationConfigurationsOutcome PutRemediationConfigurations(
      const Model::PutRemediationConfigurationsRequest& request) const;
 
  template <typename PutRemediationConfigurationsRequestT = Model::PutRemediationConfigurationsRequest>
  Model::PutRemediationConfigurationsOutcomeCallable PutRemediationConfigurationsCallable(
      const PutRemediationConfigurationsRequestT& request) const {
    return SubmitCallable(&ConfigServiceClient::PutRemediationConfigurations, request);
  }
 
  template <typename PutRemediationConfigurationsRequestT = Model::PutRemediationConfigurationsRequest>
  void PutRemediationConfigurationsAsync(const PutRemediationConfigurationsRequestT& request,
                                         const PutRemediationConfigurationsResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConfigServiceClient::PutRemediationConfigurations, request, handler, context);
  }
 
  virtual Model::PutRemediationExceptionsOutcome PutRemediationExceptions(const Model::PutRemediationExceptionsRequest& request) const;
 
  template <typename PutRemediationExceptionsRequestT = Model::PutRemediationExceptionsRequest>
  Model::PutRemediationExceptionsOutcomeCallable PutRemediationExceptionsCallable(const PutRemediationExceptionsRequestT& request) const {
    return SubmitCallable(&ConfigServiceClient::PutRemediationExceptions, request);
  }
 
  template <typename PutRemediationExceptionsRequestT = Model::PutRemediationExceptionsRequest>
  void PutRemediationExceptionsAsync(const PutRemediationExceptionsRequestT& request,
                                     const PutRemediationExceptionsResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConfigServiceClient::PutRemediationExceptions, request, handler, context);
  }
 
  virtual Model::PutResourceConfigOutcome PutResourceConfig(const Model::PutResourceConfigRequest& request) const;
 
  template <typename PutResourceConfigRequestT = Model::PutResourceConfigRequest>
  Model::PutResourceConfigOutcomeCallable PutResourceConfigCallable(const PutResourceConfigRequestT& request) const {
    return SubmitCallable(&ConfigServiceClient::PutResourceConfig, request);
  }
 
  template <typename PutResourceConfigRequestT = Model::PutResourceConfigRequest>
  void PutResourceConfigAsync(const PutResourceConfigRequestT& request, const PutResourceConfigResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConfigServiceClient::PutResourceConfig, request, handler, context);
  }
 
  virtual Model::PutRetentionConfigurationOutcome PutRetentionConfiguration(const Model::PutRetentionConfigurationRequest& request) const;
 
  template <typename PutRetentionConfigurationRequestT = Model::PutRetentionConfigurationRequest>
  Model::PutRetentionConfigurationOutcomeCallable PutRetentionConfigurationCallable(
      const PutRetentionConfigurationRequestT& request) const {
    return SubmitCallable(&ConfigServiceClient::PutRetentionConfiguration, request);
  }
 
  template <typename PutRetentionConfigurationRequestT = Model::PutRetentionConfigurationRequest>
  void PutRetentionConfigurationAsync(const PutRetentionConfigurationRequestT& request,
                                      const PutRetentionConfigurationResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConfigServiceClient::PutRetentionConfiguration, request, handler, context);
  }
 
  virtual Model::PutServiceLinkedConfigurationRecorderOutcome PutServiceLinkedConfigurationRecorder(
      const Model::PutServiceLinkedConfigurationRecorderRequest& request) const;
 
  template <typename PutServiceLinkedConfigurationRecorderRequestT = Model::PutServiceLinkedConfigurationRecorderRequest>
  Model::PutServiceLinkedConfigurationRecorderOutcomeCallable PutServiceLinkedConfigurationRecorderCallable(
      const PutServiceLinkedConfigurationRecorderRequestT& request) const {
    return SubmitCallable(&ConfigServiceClient::PutServiceLinkedConfigurationRecorder, request);
  }
 
  template <typename PutServiceLinkedConfigurationRecorderRequestT = Model::PutServiceLinkedConfigurationRecorderRequest>
  void PutServiceLinkedConfigurationRecorderAsync(const PutServiceLinkedConfigurationRecorderRequestT& request,
                                                  const PutServiceLinkedConfigurationRecorderResponseReceivedHandler& handler,
                                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConfigServiceClient::PutServiceLinkedConfigurationRecorder, request, handler, context);
  }
 
  virtual Model::PutStoredQueryOutcome PutStoredQuery(const Model::PutStoredQueryRequest& request) const;
 
  template <typename PutStoredQueryRequestT = Model::PutStoredQueryRequest>
  Model::PutStoredQueryOutcomeCallable PutStoredQueryCallable(const PutStoredQueryRequestT& request) const {
    return SubmitCallable(&ConfigServiceClient::PutStoredQuery, request);
  }
 
  template <typename PutStoredQueryRequestT = Model::PutStoredQueryRequest>
  void PutStoredQueryAsync(const PutStoredQueryRequestT& request, const PutStoredQueryResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConfigServiceClient::PutStoredQuery, request, handler, context);
  }
 
  virtual Model::PutThirdPartyServiceLinkedConfigurationRecorderOutcome PutThirdPartyServiceLinkedConfigurationRecorder(
      const Model::PutThirdPartyServiceLinkedConfigurationRecorderRequest& request) const;
 
  template <
      typename PutThirdPartyServiceLinkedConfigurationRecorderRequestT = Model::PutThirdPartyServiceLinkedConfigurationRecorderRequest>
  Model::PutThirdPartyServiceLinkedConfigurationRecorderOutcomeCallable PutThirdPartyServiceLinkedConfigurationRecorderCallable(
      const PutThirdPartyServiceLinkedConfigurationRecorderRequestT& request) const {
    return SubmitCallable(&ConfigServiceClient::PutThirdPartyServiceLinkedConfigurationRecorder, request);
  }
 
  template <
      typename PutThirdPartyServiceLinkedConfigurationRecorderRequestT = Model::PutThirdPartyServiceLinkedConfigurationRecorderRequest>
  void PutThirdPartyServiceLinkedConfigurationRecorderAsync(
      const PutThirdPartyServiceLinkedConfigurationRecorderRequestT& request,
      const PutThirdPartyServiceLinkedConfigurationRecorderResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConfigServiceClient::PutThirdPartyServiceLinkedConfigurationRecorder, request, handler, context);
  }
 
  virtual Model::SelectAggregateResourceConfigOutcome SelectAggregateResourceConfig(
      const Model::SelectAggregateResourceConfigRequest& request) const;
 
  template <typename SelectAggregateResourceConfigRequestT = Model::SelectAggregateResourceConfigRequest>
  Model::SelectAggregateResourceConfigOutcomeCallable SelectAggregateResourceConfigCallable(
      const SelectAggregateResourceConfigRequestT& request) const {
    return SubmitCallable(&ConfigServiceClient::SelectAggregateResourceConfig, request);
  }
 
  template <typename SelectAggregateResourceConfigRequestT = Model::SelectAggregateResourceConfigRequest>
  void SelectAggregateResourceConfigAsync(const SelectAggregateResourceConfigRequestT& request,
                                          const SelectAggregateResourceConfigResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConfigServiceClient::SelectAggregateResourceConfig, request, handler, context);
  }
 
  virtual Model::SelectResourceConfigOutcome SelectResourceConfig(const Model::SelectResourceConfigRequest& request) const;
 
  template <typename SelectResourceConfigRequestT = Model::SelectResourceConfigRequest>
  Model::SelectResourceConfigOutcomeCallable SelectResourceConfigCallable(const SelectResourceConfigRequestT& request) const {
    return SubmitCallable(&ConfigServiceClient::SelectResourceConfig, request);
  }
 
  template <typename SelectResourceConfigRequestT = Model::SelectResourceConfigRequest>
  void SelectResourceConfigAsync(const SelectResourceConfigRequestT& request, const SelectResourceConfigResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConfigServiceClient::SelectResourceConfig, request, handler, context);
  }
 
  virtual Model::StartConfigRulesEvaluationOutcome StartConfigRulesEvaluation(
      const Model::StartConfigRulesEvaluationRequest& request = {}) const;
 
  template <typename StartConfigRulesEvaluationRequestT = Model::StartConfigRulesEvaluationRequest>
  Model::StartConfigRulesEvaluationOutcomeCallable StartConfigRulesEvaluationCallable(
      const StartConfigRulesEvaluationRequestT& request = {}) const {
    return SubmitCallable(&ConfigServiceClient::StartConfigRulesEvaluation, request);
  }
 
  template <typename StartConfigRulesEvaluationRequestT = Model::StartConfigRulesEvaluationRequest>
  void StartConfigRulesEvaluationAsync(const StartConfigRulesEvaluationResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                       const StartConfigRulesEvaluationRequestT& request = {}) const {
    return SubmitAsync(&ConfigServiceClient::StartConfigRulesEvaluation, request, handler, context);
  }
 
  virtual Model::StartConfigurationRecorderOutcome StartConfigurationRecorder(
      const Model::StartConfigurationRecorderRequest& request) const;
 
  template <typename StartConfigurationRecorderRequestT = Model::StartConfigurationRecorderRequest>
  Model::StartConfigurationRecorderOutcomeCallable StartConfigurationRecorderCallable(
      const StartConfigurationRecorderRequestT& request) const {
    return SubmitCallable(&ConfigServiceClient::StartConfigurationRecorder, request);
  }
 
  template <typename StartConfigurationRecorderRequestT = Model::StartConfigurationRecorderRequest>
  void StartConfigurationRecorderAsync(const StartConfigurationRecorderRequestT& request,
                                       const StartConfigurationRecorderResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConfigServiceClient::StartConfigurationRecorder, request, handler, context);
  }
 
  virtual Model::StartRemediationExecutionOutcome StartRemediationExecution(const Model::StartRemediationExecutionRequest& request) const;
 
  template <typename StartRemediationExecutionRequestT = Model::StartRemediationExecutionRequest>
  Model::StartRemediationExecutionOutcomeCallable StartRemediationExecutionCallable(
      const StartRemediationExecutionRequestT& request) const {
    return SubmitCallable(&ConfigServiceClient::StartRemediationExecution, request);
  }
 
  template <typename StartRemediationExecutionRequestT = Model::StartRemediationExecutionRequest>
  void StartRemediationExecutionAsync(const StartRemediationExecutionRequestT& request,
                                      const StartRemediationExecutionResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConfigServiceClient::StartRemediationExecution, request, handler, context);
  }
 
  virtual Model::StartResourceEvaluationOutcome StartResourceEvaluation(const Model::StartResourceEvaluationRequest& request) const;
 
  template <typename StartResourceEvaluationRequestT = Model::StartResourceEvaluationRequest>
  Model::StartResourceEvaluationOutcomeCallable StartResourceEvaluationCallable(const StartResourceEvaluationRequestT& request) const {
    return SubmitCallable(&ConfigServiceClient::StartResourceEvaluation, request);
  }
 
  template <typename StartResourceEvaluationRequestT = Model::StartResourceEvaluationRequest>
  void StartResourceEvaluationAsync(const StartResourceEvaluationRequestT& request,
                                    const StartResourceEvaluationResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConfigServiceClient::StartResourceEvaluation, request, handler, context);
  }
 
  virtual Model::StopConfigurationRecorderOutcome StopConfigurationRecorder(const Model::StopConfigurationRecorderRequest& request) const;
 
  template <typename StopConfigurationRecorderRequestT = Model::StopConfigurationRecorderRequest>
  Model::StopConfigurationRecorderOutcomeCallable StopConfigurationRecorderCallable(
      const StopConfigurationRecorderRequestT& request) const {
    return SubmitCallable(&ConfigServiceClient::StopConfigurationRecorder, request);
  }
 
  template <typename StopConfigurationRecorderRequestT = Model::StopConfigurationRecorderRequest>
  void StopConfigurationRecorderAsync(const StopConfigurationRecorderRequestT& request,
                                      const StopConfigurationRecorderResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConfigServiceClient::StopConfigurationRecorder, request, handler, context);
  }
 
  virtual Model::TagResourceOutcome TagResource(const Model::TagResourceRequest& request) const;
 
  template <typename TagResourceRequestT = Model::TagResourceRequest>
  Model::TagResourceOutcomeCallable TagResourceCallable(const TagResourceRequestT& request) const {
    return SubmitCallable(&ConfigServiceClient::TagResource, request);
  }
 
  template <typename TagResourceRequestT = Model::TagResourceRequest>
  void TagResourceAsync(const TagResourceRequestT& request, const TagResourceResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConfigServiceClient::TagResource, request, handler, context);
  }
 
  virtual Model::UntagResourceOutcome UntagResource(const Model::UntagResourceRequest& request) const;
 
  template <typename UntagResourceRequestT = Model::UntagResourceRequest>
  Model::UntagResourceOutcomeCallable UntagResourceCallable(const UntagResourceRequestT& request) const {
    return SubmitCallable(&ConfigServiceClient::UntagResource, request);
  }
 
  template <typename UntagResourceRequestT = Model::UntagResourceRequest>
  void UntagResourceAsync(const UntagResourceRequestT& request, const UntagResourceResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConfigServiceClient::UntagResource, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<ConfigServiceEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<ConfigServiceClient>;
  void init(const ConfigServiceClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, ConfigServiceError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request, Aws::Http::HttpMethod httpMethod) const;
 
  ConfigServiceClientConfiguration m_clientConfiguration;
  std::shared_ptr<ConfigServiceEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace ConfigService
}  // namespace Aws