ConfigServiceClient.h

 
#pragma once
#include <aws/config/ConfigService_EXPORTS.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/config/ConfigServiceServiceClientModel.h>
 
namespace Aws
{
namespace ConfigService
{
  class AWS_CONFIGSERVICE_API ConfigServiceClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<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::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 DeleteServiceLinkedConfigurationRecorderRequestT& request, const DeleteServiceLinkedConfigurationRecorderResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) 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::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::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::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::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);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<ConfigServiceEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<ConfigServiceClient>;
      void init(const ConfigServiceClientConfiguration& clientConfiguration);
 
      ConfigServiceClientConfiguration m_clientConfiguration;
      std::shared_ptr<ConfigServiceEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace ConfigService
} // namespace Aws