AppConfigClient.h

 
#pragma once
#include <aws/appconfig/AppConfig_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/appconfig/AppConfigServiceClientModel.h>
 
namespace Aws
{
namespace AppConfig
{
  class AWS_APPCONFIG_API AppConfigClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<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::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::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::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::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::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::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::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);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<AppConfigEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<AppConfigClient>;
      void init(const AppConfigClientConfiguration& clientConfiguration);
 
      AppConfigClientConfiguration m_clientConfiguration;
      std::shared_ptr<AppConfigEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace AppConfig
} // namespace Aws