AppConfigClient.h

 
#pragma once
#include <aws/appconfig/AppConfigPaginationBase.h>
#include <aws/appconfig/AppConfigServiceClientModel.h>
#include <aws/appconfig/AppConfigWaiter.h>
#include <aws/appconfig/AppConfig_EXPORTS.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/utils/json/JsonSerializer.h>
 
namespace Aws {
namespace AppConfig {
class AWS_APPCONFIG_API AppConfigClient : public Aws::Client::AWSJsonClient,
                                          public Aws::Client::ClientWithAsyncTemplateMethods<AppConfigClient>,
                                          public AppConfigPaginationBase<AppConfigClient>,
                                          public AppConfigWaiter<AppConfigClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef AppConfigClientConfiguration ClientConfigurationType;
  typedef AppConfigEndpointProvider EndpointProviderType;
 
  AppConfigClient(const Aws::AppConfig::AppConfigClientConfiguration& clientConfiguration = Aws::AppConfig::AppConfigClientConfiguration(),
                  std::shared_ptr<AppConfigEndpointProviderBase> endpointProvider = nullptr);
 
  AppConfigClient(const Aws::Auth::AWSCredentials& credentials, std::shared_ptr<AppConfigEndpointProviderBase> endpointProvider = nullptr,
                  const Aws::AppConfig::AppConfigClientConfiguration& clientConfiguration = Aws::AppConfig::AppConfigClientConfiguration());
 
  AppConfigClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                  std::shared_ptr<AppConfigEndpointProviderBase> endpointProvider = nullptr,
                  const Aws::AppConfig::AppConfigClientConfiguration& clientConfiguration = Aws::AppConfig::AppConfigClientConfiguration());
 
  /* Legacy constructors due deprecation */
  AppConfigClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  AppConfigClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  AppConfigClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                  const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~AppConfigClient();
 
  virtual Model::CreateApplicationOutcome CreateApplication(const Model::CreateApplicationRequest& request) const;
 
  template <typename CreateApplicationRequestT = Model::CreateApplicationRequest>
  Model::CreateApplicationOutcomeCallable CreateApplicationCallable(const CreateApplicationRequestT& request) const {
    return SubmitCallable(&AppConfigClient::CreateApplication, request);
  }
 
  template <typename CreateApplicationRequestT = Model::CreateApplicationRequest>
  void CreateApplicationAsync(const CreateApplicationRequestT& request, const CreateApplicationResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppConfigClient::CreateApplication, request, handler, context);
  }
 
  virtual Model::CreateConfigurationProfileOutcome CreateConfigurationProfile(
      const Model::CreateConfigurationProfileRequest& request) const;
 
  template <typename CreateConfigurationProfileRequestT = Model::CreateConfigurationProfileRequest>
  Model::CreateConfigurationProfileOutcomeCallable CreateConfigurationProfileCallable(
      const CreateConfigurationProfileRequestT& request) const {
    return SubmitCallable(&AppConfigClient::CreateConfigurationProfile, request);
  }
 
  template <typename CreateConfigurationProfileRequestT = Model::CreateConfigurationProfileRequest>
  void CreateConfigurationProfileAsync(const CreateConfigurationProfileRequestT& request,
                                       const CreateConfigurationProfileResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppConfigClient::CreateConfigurationProfile, request, handler, context);
  }
 
  virtual Model::CreateDeploymentStrategyOutcome CreateDeploymentStrategy(const Model::CreateDeploymentStrategyRequest& request) const;
 
  template <typename CreateDeploymentStrategyRequestT = Model::CreateDeploymentStrategyRequest>
  Model::CreateDeploymentStrategyOutcomeCallable CreateDeploymentStrategyCallable(const CreateDeploymentStrategyRequestT& request) const {
    return SubmitCallable(&AppConfigClient::CreateDeploymentStrategy, request);
  }
 
  template <typename CreateDeploymentStrategyRequestT = Model::CreateDeploymentStrategyRequest>
  void CreateDeploymentStrategyAsync(const CreateDeploymentStrategyRequestT& request,
                                     const CreateDeploymentStrategyResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppConfigClient::CreateDeploymentStrategy, request, handler, context);
  }
 
  virtual Model::CreateEnvironmentOutcome CreateEnvironment(const Model::CreateEnvironmentRequest& request) const;
 
  template <typename CreateEnvironmentRequestT = Model::CreateEnvironmentRequest>
  Model::CreateEnvironmentOutcomeCallable CreateEnvironmentCallable(const CreateEnvironmentRequestT& request) const {
    return SubmitCallable(&AppConfigClient::CreateEnvironment, request);
  }
 
  template <typename CreateEnvironmentRequestT = Model::CreateEnvironmentRequest>
  void CreateEnvironmentAsync(const CreateEnvironmentRequestT& request, const CreateEnvironmentResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppConfigClient::CreateEnvironment, request, handler, context);
  }
 
  virtual Model::CreateExperimentDefinitionOutcome CreateExperimentDefinition(
      const Model::CreateExperimentDefinitionRequest& request) const;
 
  template <typename CreateExperimentDefinitionRequestT = Model::CreateExperimentDefinitionRequest>
  Model::CreateExperimentDefinitionOutcomeCallable CreateExperimentDefinitionCallable(
      const CreateExperimentDefinitionRequestT& request) const {
    return SubmitCallable(&AppConfigClient::CreateExperimentDefinition, request);
  }
 
  template <typename CreateExperimentDefinitionRequestT = Model::CreateExperimentDefinitionRequest>
  void CreateExperimentDefinitionAsync(const CreateExperimentDefinitionRequestT& request,
                                       const CreateExperimentDefinitionResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppConfigClient::CreateExperimentDefinition, request, handler, context);
  }
 
  virtual Model::CreateExtensionOutcome CreateExtension(const Model::CreateExtensionRequest& request) const;
 
  template <typename CreateExtensionRequestT = Model::CreateExtensionRequest>
  Model::CreateExtensionOutcomeCallable CreateExtensionCallable(const CreateExtensionRequestT& request) const {
    return SubmitCallable(&AppConfigClient::CreateExtension, request);
  }
 
  template <typename CreateExtensionRequestT = Model::CreateExtensionRequest>
  void CreateExtensionAsync(const CreateExtensionRequestT& request, const CreateExtensionResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppConfigClient::CreateExtension, request, handler, context);
  }
 
  virtual Model::CreateExtensionAssociationOutcome CreateExtensionAssociation(
      const Model::CreateExtensionAssociationRequest& request) const;
 
  template <typename CreateExtensionAssociationRequestT = Model::CreateExtensionAssociationRequest>
  Model::CreateExtensionAssociationOutcomeCallable CreateExtensionAssociationCallable(
      const CreateExtensionAssociationRequestT& request) const {
    return SubmitCallable(&AppConfigClient::CreateExtensionAssociation, request);
  }
 
  template <typename CreateExtensionAssociationRequestT = Model::CreateExtensionAssociationRequest>
  void CreateExtensionAssociationAsync(const CreateExtensionAssociationRequestT& request,
                                       const CreateExtensionAssociationResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppConfigClient::CreateExtensionAssociation, request, handler, context);
  }
 
  virtual Model::CreateHostedConfigurationVersionOutcome CreateHostedConfigurationVersion(
      const Model::CreateHostedConfigurationVersionRequest& request) const;
 
  template <typename CreateHostedConfigurationVersionRequestT = Model::CreateHostedConfigurationVersionRequest>
  Model::CreateHostedConfigurationVersionOutcomeCallable CreateHostedConfigurationVersionCallable(
      const CreateHostedConfigurationVersionRequestT& request) const {
    return SubmitCallable(&AppConfigClient::CreateHostedConfigurationVersion, request);
  }
 
  template <typename CreateHostedConfigurationVersionRequestT = Model::CreateHostedConfigurationVersionRequest>
  void CreateHostedConfigurationVersionAsync(const CreateHostedConfigurationVersionRequestT& request,
                                             const CreateHostedConfigurationVersionResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppConfigClient::CreateHostedConfigurationVersion, request, handler, context);
  }
 
  virtual Model::DeleteApplicationOutcome DeleteApplication(const Model::DeleteApplicationRequest& request) const;
 
  template <typename DeleteApplicationRequestT = Model::DeleteApplicationRequest>
  Model::DeleteApplicationOutcomeCallable DeleteApplicationCallable(const DeleteApplicationRequestT& request) const {
    return SubmitCallable(&AppConfigClient::DeleteApplication, request);
  }
 
  template <typename DeleteApplicationRequestT = Model::DeleteApplicationRequest>
  void DeleteApplicationAsync(const DeleteApplicationRequestT& request, const DeleteApplicationResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppConfigClient::DeleteApplication, request, handler, context);
  }
 
  virtual Model::DeleteConfigurationProfileOutcome DeleteConfigurationProfile(
      const Model::DeleteConfigurationProfileRequest& request) const;
 
  template <typename DeleteConfigurationProfileRequestT = Model::DeleteConfigurationProfileRequest>
  Model::DeleteConfigurationProfileOutcomeCallable DeleteConfigurationProfileCallable(
      const DeleteConfigurationProfileRequestT& request) const {
    return SubmitCallable(&AppConfigClient::DeleteConfigurationProfile, request);
  }
 
  template <typename DeleteConfigurationProfileRequestT = Model::DeleteConfigurationProfileRequest>
  void DeleteConfigurationProfileAsync(const DeleteConfigurationProfileRequestT& request,
                                       const DeleteConfigurationProfileResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppConfigClient::DeleteConfigurationProfile, request, handler, context);
  }
 
  virtual Model::DeleteDeploymentStrategyOutcome DeleteDeploymentStrategy(const Model::DeleteDeploymentStrategyRequest& request) const;
 
  template <typename DeleteDeploymentStrategyRequestT = Model::DeleteDeploymentStrategyRequest>
  Model::DeleteDeploymentStrategyOutcomeCallable DeleteDeploymentStrategyCallable(const DeleteDeploymentStrategyRequestT& request) const {
    return SubmitCallable(&AppConfigClient::DeleteDeploymentStrategy, request);
  }
 
  template <typename DeleteDeploymentStrategyRequestT = Model::DeleteDeploymentStrategyRequest>
  void DeleteDeploymentStrategyAsync(const DeleteDeploymentStrategyRequestT& request,
                                     const DeleteDeploymentStrategyResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppConfigClient::DeleteDeploymentStrategy, request, handler, context);
  }
 
  virtual Model::DeleteEnvironmentOutcome DeleteEnvironment(const Model::DeleteEnvironmentRequest& request) const;
 
  template <typename DeleteEnvironmentRequestT = Model::DeleteEnvironmentRequest>
  Model::DeleteEnvironmentOutcomeCallable DeleteEnvironmentCallable(const DeleteEnvironmentRequestT& request) const {
    return SubmitCallable(&AppConfigClient::DeleteEnvironment, request);
  }
 
  template <typename DeleteEnvironmentRequestT = Model::DeleteEnvironmentRequest>
  void DeleteEnvironmentAsync(const DeleteEnvironmentRequestT& request, const DeleteEnvironmentResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppConfigClient::DeleteEnvironment, request, handler, context);
  }
 
  virtual Model::DeleteExperimentDefinitionOutcome DeleteExperimentDefinition(
      const Model::DeleteExperimentDefinitionRequest& request) const;
 
  template <typename DeleteExperimentDefinitionRequestT = Model::DeleteExperimentDefinitionRequest>
  Model::DeleteExperimentDefinitionOutcomeCallable DeleteExperimentDefinitionCallable(
      const DeleteExperimentDefinitionRequestT& request) const {
    return SubmitCallable(&AppConfigClient::DeleteExperimentDefinition, request);
  }
 
  template <typename DeleteExperimentDefinitionRequestT = Model::DeleteExperimentDefinitionRequest>
  void DeleteExperimentDefinitionAsync(const DeleteExperimentDefinitionRequestT& request,
                                       const DeleteExperimentDefinitionResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppConfigClient::DeleteExperimentDefinition, request, handler, context);
  }
 
  virtual Model::DeleteExtensionOutcome DeleteExtension(const Model::DeleteExtensionRequest& request) const;
 
  template <typename DeleteExtensionRequestT = Model::DeleteExtensionRequest>
  Model::DeleteExtensionOutcomeCallable DeleteExtensionCallable(const DeleteExtensionRequestT& request) const {
    return SubmitCallable(&AppConfigClient::DeleteExtension, request);
  }
 
  template <typename DeleteExtensionRequestT = Model::DeleteExtensionRequest>
  void DeleteExtensionAsync(const DeleteExtensionRequestT& request, const DeleteExtensionResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppConfigClient::DeleteExtension, request, handler, context);
  }
 
  virtual Model::DeleteExtensionAssociationOutcome DeleteExtensionAssociation(
      const Model::DeleteExtensionAssociationRequest& request) const;
 
  template <typename DeleteExtensionAssociationRequestT = Model::DeleteExtensionAssociationRequest>
  Model::DeleteExtensionAssociationOutcomeCallable DeleteExtensionAssociationCallable(
      const DeleteExtensionAssociationRequestT& request) const {
    return SubmitCallable(&AppConfigClient::DeleteExtensionAssociation, request);
  }
 
  template <typename DeleteExtensionAssociationRequestT = Model::DeleteExtensionAssociationRequest>
  void DeleteExtensionAssociationAsync(const DeleteExtensionAssociationRequestT& request,
                                       const DeleteExtensionAssociationResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppConfigClient::DeleteExtensionAssociation, request, handler, context);
  }
 
  virtual Model::DeleteHostedConfigurationVersionOutcome DeleteHostedConfigurationVersion(
      const Model::DeleteHostedConfigurationVersionRequest& request) const;
 
  template <typename DeleteHostedConfigurationVersionRequestT = Model::DeleteHostedConfigurationVersionRequest>
  Model::DeleteHostedConfigurationVersionOutcomeCallable DeleteHostedConfigurationVersionCallable(
      const DeleteHostedConfigurationVersionRequestT& request) const {
    return SubmitCallable(&AppConfigClient::DeleteHostedConfigurationVersion, request);
  }
 
  template <typename DeleteHostedConfigurationVersionRequestT = Model::DeleteHostedConfigurationVersionRequest>
  void DeleteHostedConfigurationVersionAsync(const DeleteHostedConfigurationVersionRequestT& request,
                                             const DeleteHostedConfigurationVersionResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppConfigClient::DeleteHostedConfigurationVersion, request, handler, context);
  }
 
  virtual Model::GetAccountSettingsOutcome GetAccountSettings(const Model::GetAccountSettingsRequest& request = {}) const;
 
  template <typename GetAccountSettingsRequestT = Model::GetAccountSettingsRequest>
  Model::GetAccountSettingsOutcomeCallable GetAccountSettingsCallable(const GetAccountSettingsRequestT& request = {}) const {
    return SubmitCallable(&AppConfigClient::GetAccountSettings, request);
  }
 
  template <typename GetAccountSettingsRequestT = Model::GetAccountSettingsRequest>
  void GetAccountSettingsAsync(const GetAccountSettingsResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                               const GetAccountSettingsRequestT& request = {}) const {
    return SubmitAsync(&AppConfigClient::GetAccountSettings, request, handler, context);
  }
 
  virtual Model::GetApplicationOutcome GetApplication(const Model::GetApplicationRequest& request) const;
 
  template <typename GetApplicationRequestT = Model::GetApplicationRequest>
  Model::GetApplicationOutcomeCallable GetApplicationCallable(const GetApplicationRequestT& request) const {
    return SubmitCallable(&AppConfigClient::GetApplication, request);
  }
 
  template <typename GetApplicationRequestT = Model::GetApplicationRequest>
  void GetApplicationAsync(const GetApplicationRequestT& request, const GetApplicationResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppConfigClient::GetApplication, request, handler, context);
  }
 
  virtual Model::GetConfigurationProfileOutcome GetConfigurationProfile(const Model::GetConfigurationProfileRequest& request) const;
 
  template <typename GetConfigurationProfileRequestT = Model::GetConfigurationProfileRequest>
  Model::GetConfigurationProfileOutcomeCallable GetConfigurationProfileCallable(const GetConfigurationProfileRequestT& request) const {
    return SubmitCallable(&AppConfigClient::GetConfigurationProfile, request);
  }
 
  template <typename GetConfigurationProfileRequestT = Model::GetConfigurationProfileRequest>
  void GetConfigurationProfileAsync(const GetConfigurationProfileRequestT& request,
                                    const GetConfigurationProfileResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppConfigClient::GetConfigurationProfile, request, handler, context);
  }
 
  virtual Model::GetDeploymentOutcome GetDeployment(const Model::GetDeploymentRequest& request) const;
 
  template <typename GetDeploymentRequestT = Model::GetDeploymentRequest>
  Model::GetDeploymentOutcomeCallable GetDeploymentCallable(const GetDeploymentRequestT& request) const {
    return SubmitCallable(&AppConfigClient::GetDeployment, request);
  }
 
  template <typename GetDeploymentRequestT = Model::GetDeploymentRequest>
  void GetDeploymentAsync(const GetDeploymentRequestT& request, const GetDeploymentResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppConfigClient::GetDeployment, request, handler, context);
  }
 
  virtual Model::GetDeploymentStrategyOutcome GetDeploymentStrategy(const Model::GetDeploymentStrategyRequest& request) const;
 
  template <typename GetDeploymentStrategyRequestT = Model::GetDeploymentStrategyRequest>
  Model::GetDeploymentStrategyOutcomeCallable GetDeploymentStrategyCallable(const GetDeploymentStrategyRequestT& request) const {
    return SubmitCallable(&AppConfigClient::GetDeploymentStrategy, request);
  }
 
  template <typename GetDeploymentStrategyRequestT = Model::GetDeploymentStrategyRequest>
  void GetDeploymentStrategyAsync(const GetDeploymentStrategyRequestT& request, const GetDeploymentStrategyResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppConfigClient::GetDeploymentStrategy, request, handler, context);
  }
 
  virtual Model::GetEnvironmentOutcome GetEnvironment(const Model::GetEnvironmentRequest& request) const;
 
  template <typename GetEnvironmentRequestT = Model::GetEnvironmentRequest>
  Model::GetEnvironmentOutcomeCallable GetEnvironmentCallable(const GetEnvironmentRequestT& request) const {
    return SubmitCallable(&AppConfigClient::GetEnvironment, request);
  }
 
  template <typename GetEnvironmentRequestT = Model::GetEnvironmentRequest>
  void GetEnvironmentAsync(const GetEnvironmentRequestT& request, const GetEnvironmentResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppConfigClient::GetEnvironment, request, handler, context);
  }
 
  virtual Model::GetExperimentDefinitionOutcome GetExperimentDefinition(const Model::GetExperimentDefinitionRequest& request) const;
 
  template <typename GetExperimentDefinitionRequestT = Model::GetExperimentDefinitionRequest>
  Model::GetExperimentDefinitionOutcomeCallable GetExperimentDefinitionCallable(const GetExperimentDefinitionRequestT& request) const {
    return SubmitCallable(&AppConfigClient::GetExperimentDefinition, request);
  }
 
  template <typename GetExperimentDefinitionRequestT = Model::GetExperimentDefinitionRequest>
  void GetExperimentDefinitionAsync(const GetExperimentDefinitionRequestT& request,
                                    const GetExperimentDefinitionResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppConfigClient::GetExperimentDefinition, request, handler, context);
  }
 
  virtual Model::GetExperimentRunOutcome GetExperimentRun(const Model::GetExperimentRunRequest& request) const;
 
  template <typename GetExperimentRunRequestT = Model::GetExperimentRunRequest>
  Model::GetExperimentRunOutcomeCallable GetExperimentRunCallable(const GetExperimentRunRequestT& request) const {
    return SubmitCallable(&AppConfigClient::GetExperimentRun, request);
  }
 
  template <typename GetExperimentRunRequestT = Model::GetExperimentRunRequest>
  void GetExperimentRunAsync(const GetExperimentRunRequestT& request, const GetExperimentRunResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppConfigClient::GetExperimentRun, request, handler, context);
  }
 
  virtual Model::GetExtensionOutcome GetExtension(const Model::GetExtensionRequest& request) const;
 
  template <typename GetExtensionRequestT = Model::GetExtensionRequest>
  Model::GetExtensionOutcomeCallable GetExtensionCallable(const GetExtensionRequestT& request) const {
    return SubmitCallable(&AppConfigClient::GetExtension, request);
  }
 
  template <typename GetExtensionRequestT = Model::GetExtensionRequest>
  void GetExtensionAsync(const GetExtensionRequestT& request, const GetExtensionResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppConfigClient::GetExtension, request, handler, context);
  }
 
  virtual Model::GetExtensionAssociationOutcome GetExtensionAssociation(const Model::GetExtensionAssociationRequest& request) const;
 
  template <typename GetExtensionAssociationRequestT = Model::GetExtensionAssociationRequest>
  Model::GetExtensionAssociationOutcomeCallable GetExtensionAssociationCallable(const GetExtensionAssociationRequestT& request) const {
    return SubmitCallable(&AppConfigClient::GetExtensionAssociation, request);
  }
 
  template <typename GetExtensionAssociationRequestT = Model::GetExtensionAssociationRequest>
  void GetExtensionAssociationAsync(const GetExtensionAssociationRequestT& request,
                                    const GetExtensionAssociationResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppConfigClient::GetExtensionAssociation, request, handler, context);
  }
 
  virtual Model::GetHostedConfigurationVersionOutcome GetHostedConfigurationVersion(
      const Model::GetHostedConfigurationVersionRequest& request) const;
 
  template <typename GetHostedConfigurationVersionRequestT = Model::GetHostedConfigurationVersionRequest>
  Model::GetHostedConfigurationVersionOutcomeCallable GetHostedConfigurationVersionCallable(
      const GetHostedConfigurationVersionRequestT& request) const {
    return SubmitCallable(&AppConfigClient::GetHostedConfigurationVersion, request);
  }
 
  template <typename GetHostedConfigurationVersionRequestT = Model::GetHostedConfigurationVersionRequest>
  void GetHostedConfigurationVersionAsync(const GetHostedConfigurationVersionRequestT& request,
                                          const GetHostedConfigurationVersionResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppConfigClient::GetHostedConfigurationVersion, request, handler, context);
  }
 
  virtual Model::ListApplicationsOutcome ListApplications(const Model::ListApplicationsRequest& request = {}) const;
 
  template <typename ListApplicationsRequestT = Model::ListApplicationsRequest>
  Model::ListApplicationsOutcomeCallable ListApplicationsCallable(const ListApplicationsRequestT& request = {}) const {
    return SubmitCallable(&AppConfigClient::ListApplications, request);
  }
 
  template <typename ListApplicationsRequestT = Model::ListApplicationsRequest>
  void ListApplicationsAsync(const ListApplicationsResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                             const ListApplicationsRequestT& request = {}) const {
    return SubmitAsync(&AppConfigClient::ListApplications, request, handler, context);
  }
 
  virtual Model::ListConfigurationProfilesOutcome ListConfigurationProfiles(const Model::ListConfigurationProfilesRequest& request) const;
 
  template <typename ListConfigurationProfilesRequestT = Model::ListConfigurationProfilesRequest>
  Model::ListConfigurationProfilesOutcomeCallable ListConfigurationProfilesCallable(
      const ListConfigurationProfilesRequestT& request) const {
    return SubmitCallable(&AppConfigClient::ListConfigurationProfiles, request);
  }
 
  template <typename ListConfigurationProfilesRequestT = Model::ListConfigurationProfilesRequest>
  void ListConfigurationProfilesAsync(const ListConfigurationProfilesRequestT& request,
                                      const ListConfigurationProfilesResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppConfigClient::ListConfigurationProfiles, request, handler, context);
  }
 
  virtual Model::ListDeploymentStrategiesOutcome ListDeploymentStrategies(const Model::ListDeploymentStrategiesRequest& request = {}) const;
 
  template <typename ListDeploymentStrategiesRequestT = Model::ListDeploymentStrategiesRequest>
  Model::ListDeploymentStrategiesOutcomeCallable ListDeploymentStrategiesCallable(
      const ListDeploymentStrategiesRequestT& request = {}) const {
    return SubmitCallable(&AppConfigClient::ListDeploymentStrategies, request);
  }
 
  template <typename ListDeploymentStrategiesRequestT = Model::ListDeploymentStrategiesRequest>
  void ListDeploymentStrategiesAsync(const ListDeploymentStrategiesResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                     const ListDeploymentStrategiesRequestT& request = {}) const {
    return SubmitAsync(&AppConfigClient::ListDeploymentStrategies, request, handler, context);
  }
 
  virtual Model::ListDeploymentsOutcome ListDeployments(const Model::ListDeploymentsRequest& request) const;
 
  template <typename ListDeploymentsRequestT = Model::ListDeploymentsRequest>
  Model::ListDeploymentsOutcomeCallable ListDeploymentsCallable(const ListDeploymentsRequestT& request) const {
    return SubmitCallable(&AppConfigClient::ListDeployments, request);
  }
 
  template <typename ListDeploymentsRequestT = Model::ListDeploymentsRequest>
  void ListDeploymentsAsync(const ListDeploymentsRequestT& request, const ListDeploymentsResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppConfigClient::ListDeployments, request, handler, context);
  }
 
  virtual Model::ListEnvironmentsOutcome ListEnvironments(const Model::ListEnvironmentsRequest& request) const;
 
  template <typename ListEnvironmentsRequestT = Model::ListEnvironmentsRequest>
  Model::ListEnvironmentsOutcomeCallable ListEnvironmentsCallable(const ListEnvironmentsRequestT& request) const {
    return SubmitCallable(&AppConfigClient::ListEnvironments, request);
  }
 
  template <typename ListEnvironmentsRequestT = Model::ListEnvironmentsRequest>
  void ListEnvironmentsAsync(const ListEnvironmentsRequestT& request, const ListEnvironmentsResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppConfigClient::ListEnvironments, request, handler, context);
  }
 
  virtual Model::ListExperimentDefinitionsOutcome ListExperimentDefinitions(
      const Model::ListExperimentDefinitionsRequest& request = {}) const;
 
  template <typename ListExperimentDefinitionsRequestT = Model::ListExperimentDefinitionsRequest>
  Model::ListExperimentDefinitionsOutcomeCallable ListExperimentDefinitionsCallable(
      const ListExperimentDefinitionsRequestT& request = {}) const {
    return SubmitCallable(&AppConfigClient::ListExperimentDefinitions, request);
  }
 
  template <typename ListExperimentDefinitionsRequestT = Model::ListExperimentDefinitionsRequest>
  void ListExperimentDefinitionsAsync(const ListExperimentDefinitionsResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                      const ListExperimentDefinitionsRequestT& request = {}) const {
    return SubmitAsync(&AppConfigClient::ListExperimentDefinitions, request, handler, context);
  }
 
  virtual Model::ListExperimentRunEventsOutcome ListExperimentRunEvents(const Model::ListExperimentRunEventsRequest& request) const;
 
  template <typename ListExperimentRunEventsRequestT = Model::ListExperimentRunEventsRequest>
  Model::ListExperimentRunEventsOutcomeCallable ListExperimentRunEventsCallable(const ListExperimentRunEventsRequestT& request) const {
    return SubmitCallable(&AppConfigClient::ListExperimentRunEvents, request);
  }
 
  template <typename ListExperimentRunEventsRequestT = Model::ListExperimentRunEventsRequest>
  void ListExperimentRunEventsAsync(const ListExperimentRunEventsRequestT& request,
                                    const ListExperimentRunEventsResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppConfigClient::ListExperimentRunEvents, request, handler, context);
  }
 
  virtual Model::ListExperimentRunsOutcome ListExperimentRuns(const Model::ListExperimentRunsRequest& request) const;
 
  template <typename ListExperimentRunsRequestT = Model::ListExperimentRunsRequest>
  Model::ListExperimentRunsOutcomeCallable ListExperimentRunsCallable(const ListExperimentRunsRequestT& request) const {
    return SubmitCallable(&AppConfigClient::ListExperimentRuns, request);
  }
 
  template <typename ListExperimentRunsRequestT = Model::ListExperimentRunsRequest>
  void ListExperimentRunsAsync(const ListExperimentRunsRequestT& request, const ListExperimentRunsResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppConfigClient::ListExperimentRuns, request, handler, context);
  }
 
  virtual Model::ListExtensionAssociationsOutcome ListExtensionAssociations(
      const Model::ListExtensionAssociationsRequest& request = {}) const;
 
  template <typename ListExtensionAssociationsRequestT = Model::ListExtensionAssociationsRequest>
  Model::ListExtensionAssociationsOutcomeCallable ListExtensionAssociationsCallable(
      const ListExtensionAssociationsRequestT& request = {}) const {
    return SubmitCallable(&AppConfigClient::ListExtensionAssociations, request);
  }
 
  template <typename ListExtensionAssociationsRequestT = Model::ListExtensionAssociationsRequest>
  void ListExtensionAssociationsAsync(const ListExtensionAssociationsResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                      const ListExtensionAssociationsRequestT& request = {}) const {
    return SubmitAsync(&AppConfigClient::ListExtensionAssociations, request, handler, context);
  }
 
  virtual Model::ListExtensionsOutcome ListExtensions(const Model::ListExtensionsRequest& request = {}) const;
 
  template <typename ListExtensionsRequestT = Model::ListExtensionsRequest>
  Model::ListExtensionsOutcomeCallable ListExtensionsCallable(const ListExtensionsRequestT& request = {}) const {
    return SubmitCallable(&AppConfigClient::ListExtensions, request);
  }
 
  template <typename ListExtensionsRequestT = Model::ListExtensionsRequest>
  void ListExtensionsAsync(const ListExtensionsResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                           const ListExtensionsRequestT& request = {}) const {
    return SubmitAsync(&AppConfigClient::ListExtensions, request, handler, context);
  }
 
  virtual Model::ListHostedConfigurationVersionsOutcome ListHostedConfigurationVersions(
      const Model::ListHostedConfigurationVersionsRequest& request) const;
 
  template <typename ListHostedConfigurationVersionsRequestT = Model::ListHostedConfigurationVersionsRequest>
  Model::ListHostedConfigurationVersionsOutcomeCallable ListHostedConfigurationVersionsCallable(
      const ListHostedConfigurationVersionsRequestT& request) const {
    return SubmitCallable(&AppConfigClient::ListHostedConfigurationVersions, request);
  }
 
  template <typename ListHostedConfigurationVersionsRequestT = Model::ListHostedConfigurationVersionsRequest>
  void ListHostedConfigurationVersionsAsync(const ListHostedConfigurationVersionsRequestT& request,
                                            const ListHostedConfigurationVersionsResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppConfigClient::ListHostedConfigurationVersions, 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(&AppConfigClient::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(&AppConfigClient::ListTagsForResource, request, handler, context);
  }
 
  virtual Model::StartDeploymentOutcome StartDeployment(const Model::StartDeploymentRequest& request) const;
 
  template <typename StartDeploymentRequestT = Model::StartDeploymentRequest>
  Model::StartDeploymentOutcomeCallable StartDeploymentCallable(const StartDeploymentRequestT& request) const {
    return SubmitCallable(&AppConfigClient::StartDeployment, request);
  }
 
  template <typename StartDeploymentRequestT = Model::StartDeploymentRequest>
  void StartDeploymentAsync(const StartDeploymentRequestT& request, const StartDeploymentResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppConfigClient::StartDeployment, request, handler, context);
  }
 
  virtual Model::StartExperimentRunOutcome StartExperimentRun(const Model::StartExperimentRunRequest& request) const;
 
  template <typename StartExperimentRunRequestT = Model::StartExperimentRunRequest>
  Model::StartExperimentRunOutcomeCallable StartExperimentRunCallable(const StartExperimentRunRequestT& request) const {
    return SubmitCallable(&AppConfigClient::StartExperimentRun, request);
  }
 
  template <typename StartExperimentRunRequestT = Model::StartExperimentRunRequest>
  void StartExperimentRunAsync(const StartExperimentRunRequestT& request, const StartExperimentRunResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppConfigClient::StartExperimentRun, request, handler, context);
  }
 
  virtual Model::StopDeploymentOutcome StopDeployment(const Model::StopDeploymentRequest& request) const;
 
  template <typename StopDeploymentRequestT = Model::StopDeploymentRequest>
  Model::StopDeploymentOutcomeCallable StopDeploymentCallable(const StopDeploymentRequestT& request) const {
    return SubmitCallable(&AppConfigClient::StopDeployment, request);
  }
 
  template <typename StopDeploymentRequestT = Model::StopDeploymentRequest>
  void StopDeploymentAsync(const StopDeploymentRequestT& request, const StopDeploymentResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppConfigClient::StopDeployment, request, handler, context);
  }
 
  virtual Model::StopExperimentRunOutcome StopExperimentRun(const Model::StopExperimentRunRequest& request) const;
 
  template <typename StopExperimentRunRequestT = Model::StopExperimentRunRequest>
  Model::StopExperimentRunOutcomeCallable StopExperimentRunCallable(const StopExperimentRunRequestT& request) const {
    return SubmitCallable(&AppConfigClient::StopExperimentRun, request);
  }
 
  template <typename StopExperimentRunRequestT = Model::StopExperimentRunRequest>
  void StopExperimentRunAsync(const StopExperimentRunRequestT& request, const StopExperimentRunResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppConfigClient::StopExperimentRun, 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(&AppConfigClient::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(&AppConfigClient::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(&AppConfigClient::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(&AppConfigClient::UntagResource, request, handler, context);
  }
 
  virtual Model::UpdateAccountSettingsOutcome UpdateAccountSettings(const Model::UpdateAccountSettingsRequest& request = {}) const;
 
  template <typename UpdateAccountSettingsRequestT = Model::UpdateAccountSettingsRequest>
  Model::UpdateAccountSettingsOutcomeCallable UpdateAccountSettingsCallable(const UpdateAccountSettingsRequestT& request = {}) const {
    return SubmitCallable(&AppConfigClient::UpdateAccountSettings, request);
  }
 
  template <typename UpdateAccountSettingsRequestT = Model::UpdateAccountSettingsRequest>
  void UpdateAccountSettingsAsync(const UpdateAccountSettingsResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                  const UpdateAccountSettingsRequestT& request = {}) const {
    return SubmitAsync(&AppConfigClient::UpdateAccountSettings, request, handler, context);
  }
 
  virtual Model::UpdateApplicationOutcome UpdateApplication(const Model::UpdateApplicationRequest& request) const;
 
  template <typename UpdateApplicationRequestT = Model::UpdateApplicationRequest>
  Model::UpdateApplicationOutcomeCallable UpdateApplicationCallable(const UpdateApplicationRequestT& request) const {
    return SubmitCallable(&AppConfigClient::UpdateApplication, request);
  }
 
  template <typename UpdateApplicationRequestT = Model::UpdateApplicationRequest>
  void UpdateApplicationAsync(const UpdateApplicationRequestT& request, const UpdateApplicationResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppConfigClient::UpdateApplication, request, handler, context);
  }
 
  virtual Model::UpdateConfigurationProfileOutcome UpdateConfigurationProfile(
      const Model::UpdateConfigurationProfileRequest& request) const;
 
  template <typename UpdateConfigurationProfileRequestT = Model::UpdateConfigurationProfileRequest>
  Model::UpdateConfigurationProfileOutcomeCallable UpdateConfigurationProfileCallable(
      const UpdateConfigurationProfileRequestT& request) const {
    return SubmitCallable(&AppConfigClient::UpdateConfigurationProfile, request);
  }
 
  template <typename UpdateConfigurationProfileRequestT = Model::UpdateConfigurationProfileRequest>
  void UpdateConfigurationProfileAsync(const UpdateConfigurationProfileRequestT& request,
                                       const UpdateConfigurationProfileResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppConfigClient::UpdateConfigurationProfile, request, handler, context);
  }
 
  virtual Model::UpdateDeploymentStrategyOutcome UpdateDeploymentStrategy(const Model::UpdateDeploymentStrategyRequest& request) const;
 
  template <typename UpdateDeploymentStrategyRequestT = Model::UpdateDeploymentStrategyRequest>
  Model::UpdateDeploymentStrategyOutcomeCallable UpdateDeploymentStrategyCallable(const UpdateDeploymentStrategyRequestT& request) const {
    return SubmitCallable(&AppConfigClient::UpdateDeploymentStrategy, request);
  }
 
  template <typename UpdateDeploymentStrategyRequestT = Model::UpdateDeploymentStrategyRequest>
  void UpdateDeploymentStrategyAsync(const UpdateDeploymentStrategyRequestT& request,
                                     const UpdateDeploymentStrategyResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppConfigClient::UpdateDeploymentStrategy, request, handler, context);
  }
 
  virtual Model::UpdateEnvironmentOutcome UpdateEnvironment(const Model::UpdateEnvironmentRequest& request) const;
 
  template <typename UpdateEnvironmentRequestT = Model::UpdateEnvironmentRequest>
  Model::UpdateEnvironmentOutcomeCallable UpdateEnvironmentCallable(const UpdateEnvironmentRequestT& request) const {
    return SubmitCallable(&AppConfigClient::UpdateEnvironment, request);
  }
 
  template <typename UpdateEnvironmentRequestT = Model::UpdateEnvironmentRequest>
  void UpdateEnvironmentAsync(const UpdateEnvironmentRequestT& request, const UpdateEnvironmentResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppConfigClient::UpdateEnvironment, request, handler, context);
  }
 
  virtual Model::UpdateExperimentDefinitionOutcome UpdateExperimentDefinition(
      const Model::UpdateExperimentDefinitionRequest& request) const;
 
  template <typename UpdateExperimentDefinitionRequestT = Model::UpdateExperimentDefinitionRequest>
  Model::UpdateExperimentDefinitionOutcomeCallable UpdateExperimentDefinitionCallable(
      const UpdateExperimentDefinitionRequestT& request) const {
    return SubmitCallable(&AppConfigClient::UpdateExperimentDefinition, request);
  }
 
  template <typename UpdateExperimentDefinitionRequestT = Model::UpdateExperimentDefinitionRequest>
  void UpdateExperimentDefinitionAsync(const UpdateExperimentDefinitionRequestT& request,
                                       const UpdateExperimentDefinitionResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppConfigClient::UpdateExperimentDefinition, request, handler, context);
  }
 
  virtual Model::UpdateExperimentRunOutcome UpdateExperimentRun(const Model::UpdateExperimentRunRequest& request) const;
 
  template <typename UpdateExperimentRunRequestT = Model::UpdateExperimentRunRequest>
  Model::UpdateExperimentRunOutcomeCallable UpdateExperimentRunCallable(const UpdateExperimentRunRequestT& request) const {
    return SubmitCallable(&AppConfigClient::UpdateExperimentRun, request);
  }
 
  template <typename UpdateExperimentRunRequestT = Model::UpdateExperimentRunRequest>
  void UpdateExperimentRunAsync(const UpdateExperimentRunRequestT& request, const UpdateExperimentRunResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppConfigClient::UpdateExperimentRun, request, handler, context);
  }
 
  virtual Model::UpdateExtensionOutcome UpdateExtension(const Model::UpdateExtensionRequest& request) const;
 
  template <typename UpdateExtensionRequestT = Model::UpdateExtensionRequest>
  Model::UpdateExtensionOutcomeCallable UpdateExtensionCallable(const UpdateExtensionRequestT& request) const {
    return SubmitCallable(&AppConfigClient::UpdateExtension, request);
  }
 
  template <typename UpdateExtensionRequestT = Model::UpdateExtensionRequest>
  void UpdateExtensionAsync(const UpdateExtensionRequestT& request, const UpdateExtensionResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppConfigClient::UpdateExtension, request, handler, context);
  }
 
  virtual Model::UpdateExtensionAssociationOutcome UpdateExtensionAssociation(
      const Model::UpdateExtensionAssociationRequest& request) const;
 
  template <typename UpdateExtensionAssociationRequestT = Model::UpdateExtensionAssociationRequest>
  Model::UpdateExtensionAssociationOutcomeCallable UpdateExtensionAssociationCallable(
      const UpdateExtensionAssociationRequestT& request) const {
    return SubmitCallable(&AppConfigClient::UpdateExtensionAssociation, request);
  }
 
  template <typename UpdateExtensionAssociationRequestT = Model::UpdateExtensionAssociationRequest>
  void UpdateExtensionAssociationAsync(const UpdateExtensionAssociationRequestT& request,
                                       const UpdateExtensionAssociationResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppConfigClient::UpdateExtensionAssociation, request, handler, context);
  }
 
  virtual Model::ValidateConfigurationOutcome ValidateConfiguration(const Model::ValidateConfigurationRequest& request) const;
 
  template <typename ValidateConfigurationRequestT = Model::ValidateConfigurationRequest>
  Model::ValidateConfigurationOutcomeCallable ValidateConfigurationCallable(const ValidateConfigurationRequestT& request) const {
    return SubmitCallable(&AppConfigClient::ValidateConfiguration, request);
  }
 
  template <typename ValidateConfigurationRequestT = Model::ValidateConfigurationRequest>
  void ValidateConfigurationAsync(const ValidateConfigurationRequestT& request, const ValidateConfigurationResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppConfigClient::ValidateConfiguration, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<AppConfigEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<AppConfigClient>;
  void init(const AppConfigClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, AppConfigError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request,
                                                const std::function<void(Aws::Endpoint::ResolveEndpointOutcome&)>& resolveUri,
                                                Aws::Http::HttpMethod httpMethod) const;
 
  AppConfigClientConfiguration m_clientConfiguration;
  std::shared_ptr<AppConfigEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace AppConfig
}  // namespace Aws