ElasticBeanstalkClient.h

 
#pragma once
#include <aws/core/AmazonSerializableWebServiceRequest.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/utils/xml/XmlSerializer.h>
#include <aws/elasticbeanstalk/ElasticBeanstalkPaginationBase.h>
#include <aws/elasticbeanstalk/ElasticBeanstalkServiceClientModel.h>
#include <aws/elasticbeanstalk/ElasticBeanstalkWaiter.h>
#include <aws/elasticbeanstalk/ElasticBeanstalk_EXPORTS.h>
 
namespace Aws {
namespace ElasticBeanstalk {
class AWS_ELASTICBEANSTALK_API ElasticBeanstalkClient : public Aws::Client::AWSXMLClient,
                                                        public Aws::Client::ClientWithAsyncTemplateMethods<ElasticBeanstalkClient>,
                                                        public ElasticBeanstalkPaginationBase<ElasticBeanstalkClient>,
                                                        public ElasticBeanstalkWaiter<ElasticBeanstalkClient> {
 public:
  typedef Aws::Client::AWSXMLClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef ElasticBeanstalkClientConfiguration ClientConfigurationType;
  typedef ElasticBeanstalkEndpointProvider EndpointProviderType;
 
  ElasticBeanstalkClient(const Aws::ElasticBeanstalk::ElasticBeanstalkClientConfiguration& clientConfiguration =
                             Aws::ElasticBeanstalk::ElasticBeanstalkClientConfiguration(),
                         std::shared_ptr<ElasticBeanstalkEndpointProviderBase> endpointProvider = nullptr);
 
  ElasticBeanstalkClient(const Aws::Auth::AWSCredentials& credentials,
                         std::shared_ptr<ElasticBeanstalkEndpointProviderBase> endpointProvider = nullptr,
                         const Aws::ElasticBeanstalk::ElasticBeanstalkClientConfiguration& clientConfiguration =
                             Aws::ElasticBeanstalk::ElasticBeanstalkClientConfiguration());
 
  ElasticBeanstalkClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                         std::shared_ptr<ElasticBeanstalkEndpointProviderBase> endpointProvider = nullptr,
                         const Aws::ElasticBeanstalk::ElasticBeanstalkClientConfiguration& clientConfiguration =
                             Aws::ElasticBeanstalk::ElasticBeanstalkClientConfiguration());
 
  /* Legacy constructors due deprecation */
  ElasticBeanstalkClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  ElasticBeanstalkClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  ElasticBeanstalkClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                         const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~ElasticBeanstalkClient();
 
  Aws::String ConvertRequestToPresignedUrl(const Aws::AmazonSerializableWebServiceRequest& requestToConvert, const char* region) const;
 
  virtual Model::AbortEnvironmentUpdateOutcome AbortEnvironmentUpdate(const Model::AbortEnvironmentUpdateRequest& request = {}) const;
 
  template <typename AbortEnvironmentUpdateRequestT = Model::AbortEnvironmentUpdateRequest>
  Model::AbortEnvironmentUpdateOutcomeCallable AbortEnvironmentUpdateCallable(const AbortEnvironmentUpdateRequestT& request = {}) const {
    return SubmitCallable(&ElasticBeanstalkClient::AbortEnvironmentUpdate, request);
  }
 
  template <typename AbortEnvironmentUpdateRequestT = Model::AbortEnvironmentUpdateRequest>
  void AbortEnvironmentUpdateAsync(const AbortEnvironmentUpdateResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                   const AbortEnvironmentUpdateRequestT& request = {}) const {
    return SubmitAsync(&ElasticBeanstalkClient::AbortEnvironmentUpdate, request, handler, context);
  }
 
  virtual Model::ApplyEnvironmentManagedActionOutcome ApplyEnvironmentManagedAction(
      const Model::ApplyEnvironmentManagedActionRequest& request) const;
 
  template <typename ApplyEnvironmentManagedActionRequestT = Model::ApplyEnvironmentManagedActionRequest>
  Model::ApplyEnvironmentManagedActionOutcomeCallable ApplyEnvironmentManagedActionCallable(
      const ApplyEnvironmentManagedActionRequestT& request) const {
    return SubmitCallable(&ElasticBeanstalkClient::ApplyEnvironmentManagedAction, request);
  }
 
  template <typename ApplyEnvironmentManagedActionRequestT = Model::ApplyEnvironmentManagedActionRequest>
  void ApplyEnvironmentManagedActionAsync(const ApplyEnvironmentManagedActionRequestT& request,
                                          const ApplyEnvironmentManagedActionResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ElasticBeanstalkClient::ApplyEnvironmentManagedAction, request, handler, context);
  }
 
  virtual Model::AssociateEnvironmentOperationsRoleOutcome AssociateEnvironmentOperationsRole(
      const Model::AssociateEnvironmentOperationsRoleRequest& request) const;
 
  template <typename AssociateEnvironmentOperationsRoleRequestT = Model::AssociateEnvironmentOperationsRoleRequest>
  Model::AssociateEnvironmentOperationsRoleOutcomeCallable AssociateEnvironmentOperationsRoleCallable(
      const AssociateEnvironmentOperationsRoleRequestT& request) const {
    return SubmitCallable(&ElasticBeanstalkClient::AssociateEnvironmentOperationsRole, request);
  }
 
  template <typename AssociateEnvironmentOperationsRoleRequestT = Model::AssociateEnvironmentOperationsRoleRequest>
  void AssociateEnvironmentOperationsRoleAsync(const AssociateEnvironmentOperationsRoleRequestT& request,
                                               const AssociateEnvironmentOperationsRoleResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ElasticBeanstalkClient::AssociateEnvironmentOperationsRole, request, handler, context);
  }
 
  virtual Model::CheckDNSAvailabilityOutcome CheckDNSAvailability(const Model::CheckDNSAvailabilityRequest& request) const;
 
  template <typename CheckDNSAvailabilityRequestT = Model::CheckDNSAvailabilityRequest>
  Model::CheckDNSAvailabilityOutcomeCallable CheckDNSAvailabilityCallable(const CheckDNSAvailabilityRequestT& request) const {
    return SubmitCallable(&ElasticBeanstalkClient::CheckDNSAvailability, request);
  }
 
  template <typename CheckDNSAvailabilityRequestT = Model::CheckDNSAvailabilityRequest>
  void CheckDNSAvailabilityAsync(const CheckDNSAvailabilityRequestT& request, const CheckDNSAvailabilityResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ElasticBeanstalkClient::CheckDNSAvailability, request, handler, context);
  }
 
  virtual Model::ComposeEnvironmentsOutcome ComposeEnvironments(const Model::ComposeEnvironmentsRequest& request = {}) const;
 
  template <typename ComposeEnvironmentsRequestT = Model::ComposeEnvironmentsRequest>
  Model::ComposeEnvironmentsOutcomeCallable ComposeEnvironmentsCallable(const ComposeEnvironmentsRequestT& request = {}) const {
    return SubmitCallable(&ElasticBeanstalkClient::ComposeEnvironments, request);
  }
 
  template <typename ComposeEnvironmentsRequestT = Model::ComposeEnvironmentsRequest>
  void ComposeEnvironmentsAsync(const ComposeEnvironmentsResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                const ComposeEnvironmentsRequestT& request = {}) const {
    return SubmitAsync(&ElasticBeanstalkClient::ComposeEnvironments, request, handler, context);
  }
 
  virtual Model::CreateApplicationOutcome CreateApplication(const Model::CreateApplicationRequest& request) const;
 
  template <typename CreateApplicationRequestT = Model::CreateApplicationRequest>
  Model::CreateApplicationOutcomeCallable CreateApplicationCallable(const CreateApplicationRequestT& request) const {
    return SubmitCallable(&ElasticBeanstalkClient::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(&ElasticBeanstalkClient::CreateApplication, request, handler, context);
  }
 
  virtual Model::CreateApplicationVersionOutcome CreateApplicationVersion(const Model::CreateApplicationVersionRequest& request) const;
 
  template <typename CreateApplicationVersionRequestT = Model::CreateApplicationVersionRequest>
  Model::CreateApplicationVersionOutcomeCallable CreateApplicationVersionCallable(const CreateApplicationVersionRequestT& request) const {
    return SubmitCallable(&ElasticBeanstalkClient::CreateApplicationVersion, request);
  }
 
  template <typename CreateApplicationVersionRequestT = Model::CreateApplicationVersionRequest>
  void CreateApplicationVersionAsync(const CreateApplicationVersionRequestT& request,
                                     const CreateApplicationVersionResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ElasticBeanstalkClient::CreateApplicationVersion, request, handler, context);
  }
 
  virtual Model::CreateConfigurationTemplateOutcome CreateConfigurationTemplate(
      const Model::CreateConfigurationTemplateRequest& request) const;
 
  template <typename CreateConfigurationTemplateRequestT = Model::CreateConfigurationTemplateRequest>
  Model::CreateConfigurationTemplateOutcomeCallable CreateConfigurationTemplateCallable(
      const CreateConfigurationTemplateRequestT& request) const {
    return SubmitCallable(&ElasticBeanstalkClient::CreateConfigurationTemplate, request);
  }
 
  template <typename CreateConfigurationTemplateRequestT = Model::CreateConfigurationTemplateRequest>
  void CreateConfigurationTemplateAsync(const CreateConfigurationTemplateRequestT& request,
                                        const CreateConfigurationTemplateResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ElasticBeanstalkClient::CreateConfigurationTemplate, 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(&ElasticBeanstalkClient::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(&ElasticBeanstalkClient::CreateEnvironment, request, handler, context);
  }
 
  virtual Model::CreatePlatformVersionOutcome CreatePlatformVersion(const Model::CreatePlatformVersionRequest& request) const;
 
  template <typename CreatePlatformVersionRequestT = Model::CreatePlatformVersionRequest>
  Model::CreatePlatformVersionOutcomeCallable CreatePlatformVersionCallable(const CreatePlatformVersionRequestT& request) const {
    return SubmitCallable(&ElasticBeanstalkClient::CreatePlatformVersion, request);
  }
 
  template <typename CreatePlatformVersionRequestT = Model::CreatePlatformVersionRequest>
  void CreatePlatformVersionAsync(const CreatePlatformVersionRequestT& request, const CreatePlatformVersionResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ElasticBeanstalkClient::CreatePlatformVersion, request, handler, context);
  }
 
  virtual Model::CreateStorageLocationOutcome CreateStorageLocation(const Model::CreateStorageLocationRequest& request = {}) const;
 
  template <typename CreateStorageLocationRequestT = Model::CreateStorageLocationRequest>
  Model::CreateStorageLocationOutcomeCallable CreateStorageLocationCallable(const CreateStorageLocationRequestT& request = {}) const {
    return SubmitCallable(&ElasticBeanstalkClient::CreateStorageLocation, request);
  }
 
  template <typename CreateStorageLocationRequestT = Model::CreateStorageLocationRequest>
  void CreateStorageLocationAsync(const CreateStorageLocationResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                  const CreateStorageLocationRequestT& request = {}) const {
    return SubmitAsync(&ElasticBeanstalkClient::CreateStorageLocation, 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(&ElasticBeanstalkClient::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(&ElasticBeanstalkClient::DeleteApplication, request, handler, context);
  }
 
  virtual Model::DeleteApplicationVersionOutcome DeleteApplicationVersion(const Model::DeleteApplicationVersionRequest& request) const;
 
  template <typename DeleteApplicationVersionRequestT = Model::DeleteApplicationVersionRequest>
  Model::DeleteApplicationVersionOutcomeCallable DeleteApplicationVersionCallable(const DeleteApplicationVersionRequestT& request) const {
    return SubmitCallable(&ElasticBeanstalkClient::DeleteApplicationVersion, request);
  }
 
  template <typename DeleteApplicationVersionRequestT = Model::DeleteApplicationVersionRequest>
  void DeleteApplicationVersionAsync(const DeleteApplicationVersionRequestT& request,
                                     const DeleteApplicationVersionResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ElasticBeanstalkClient::DeleteApplicationVersion, request, handler, context);
  }
 
  virtual Model::DeleteConfigurationTemplateOutcome DeleteConfigurationTemplate(
      const Model::DeleteConfigurationTemplateRequest& request) const;
 
  template <typename DeleteConfigurationTemplateRequestT = Model::DeleteConfigurationTemplateRequest>
  Model::DeleteConfigurationTemplateOutcomeCallable DeleteConfigurationTemplateCallable(
      const DeleteConfigurationTemplateRequestT& request) const {
    return SubmitCallable(&ElasticBeanstalkClient::DeleteConfigurationTemplate, request);
  }
 
  template <typename DeleteConfigurationTemplateRequestT = Model::DeleteConfigurationTemplateRequest>
  void DeleteConfigurationTemplateAsync(const DeleteConfigurationTemplateRequestT& request,
                                        const DeleteConfigurationTemplateResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ElasticBeanstalkClient::DeleteConfigurationTemplate, request, handler, context);
  }
 
  virtual Model::DeleteEnvironmentConfigurationOutcome DeleteEnvironmentConfiguration(
      const Model::DeleteEnvironmentConfigurationRequest& request) const;
 
  template <typename DeleteEnvironmentConfigurationRequestT = Model::DeleteEnvironmentConfigurationRequest>
  Model::DeleteEnvironmentConfigurationOutcomeCallable DeleteEnvironmentConfigurationCallable(
      const DeleteEnvironmentConfigurationRequestT& request) const {
    return SubmitCallable(&ElasticBeanstalkClient::DeleteEnvironmentConfiguration, request);
  }
 
  template <typename DeleteEnvironmentConfigurationRequestT = Model::DeleteEnvironmentConfigurationRequest>
  void DeleteEnvironmentConfigurationAsync(const DeleteEnvironmentConfigurationRequestT& request,
                                           const DeleteEnvironmentConfigurationResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ElasticBeanstalkClient::DeleteEnvironmentConfiguration, request, handler, context);
  }
 
  virtual Model::DeletePlatformVersionOutcome DeletePlatformVersion(const Model::DeletePlatformVersionRequest& request = {}) const;
 
  template <typename DeletePlatformVersionRequestT = Model::DeletePlatformVersionRequest>
  Model::DeletePlatformVersionOutcomeCallable DeletePlatformVersionCallable(const DeletePlatformVersionRequestT& request = {}) const {
    return SubmitCallable(&ElasticBeanstalkClient::DeletePlatformVersion, request);
  }
 
  template <typename DeletePlatformVersionRequestT = Model::DeletePlatformVersionRequest>
  void DeletePlatformVersionAsync(const DeletePlatformVersionResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                  const DeletePlatformVersionRequestT& request = {}) const {
    return SubmitAsync(&ElasticBeanstalkClient::DeletePlatformVersion, request, handler, context);
  }
 
  virtual Model::DescribeAccountAttributesOutcome DescribeAccountAttributes(
      const Model::DescribeAccountAttributesRequest& request = {}) const;
 
  template <typename DescribeAccountAttributesRequestT = Model::DescribeAccountAttributesRequest>
  Model::DescribeAccountAttributesOutcomeCallable DescribeAccountAttributesCallable(
      const DescribeAccountAttributesRequestT& request = {}) const {
    return SubmitCallable(&ElasticBeanstalkClient::DescribeAccountAttributes, request);
  }
 
  template <typename DescribeAccountAttributesRequestT = Model::DescribeAccountAttributesRequest>
  void DescribeAccountAttributesAsync(const DescribeAccountAttributesResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                      const DescribeAccountAttributesRequestT& request = {}) const {
    return SubmitAsync(&ElasticBeanstalkClient::DescribeAccountAttributes, request, handler, context);
  }
 
  virtual Model::DescribeApplicationVersionsOutcome DescribeApplicationVersions(
      const Model::DescribeApplicationVersionsRequest& request = {}) const;
 
  template <typename DescribeApplicationVersionsRequestT = Model::DescribeApplicationVersionsRequest>
  Model::DescribeApplicationVersionsOutcomeCallable DescribeApplicationVersionsCallable(
      const DescribeApplicationVersionsRequestT& request = {}) const {
    return SubmitCallable(&ElasticBeanstalkClient::DescribeApplicationVersions, request);
  }
 
  template <typename DescribeApplicationVersionsRequestT = Model::DescribeApplicationVersionsRequest>
  void DescribeApplicationVersionsAsync(const DescribeApplicationVersionsResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                        const DescribeApplicationVersionsRequestT& request = {}) const {
    return SubmitAsync(&ElasticBeanstalkClient::DescribeApplicationVersions, request, handler, context);
  }
 
  virtual Model::DescribeApplicationsOutcome DescribeApplications(const Model::DescribeApplicationsRequest& request = {}) const;
 
  template <typename DescribeApplicationsRequestT = Model::DescribeApplicationsRequest>
  Model::DescribeApplicationsOutcomeCallable DescribeApplicationsCallable(const DescribeApplicationsRequestT& request = {}) const {
    return SubmitCallable(&ElasticBeanstalkClient::DescribeApplications, request);
  }
 
  template <typename DescribeApplicationsRequestT = Model::DescribeApplicationsRequest>
  void DescribeApplicationsAsync(const DescribeApplicationsResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                 const DescribeApplicationsRequestT& request = {}) const {
    return SubmitAsync(&ElasticBeanstalkClient::DescribeApplications, request, handler, context);
  }
 
  virtual Model::DescribeConfigurationOptionsOutcome DescribeConfigurationOptions(
      const Model::DescribeConfigurationOptionsRequest& request = {}) const;
 
  template <typename DescribeConfigurationOptionsRequestT = Model::DescribeConfigurationOptionsRequest>
  Model::DescribeConfigurationOptionsOutcomeCallable DescribeConfigurationOptionsCallable(
      const DescribeConfigurationOptionsRequestT& request = {}) const {
    return SubmitCallable(&ElasticBeanstalkClient::DescribeConfigurationOptions, request);
  }
 
  template <typename DescribeConfigurationOptionsRequestT = Model::DescribeConfigurationOptionsRequest>
  void DescribeConfigurationOptionsAsync(const DescribeConfigurationOptionsResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                         const DescribeConfigurationOptionsRequestT& request = {}) const {
    return SubmitAsync(&ElasticBeanstalkClient::DescribeConfigurationOptions, request, handler, context);
  }
 
  virtual Model::DescribeConfigurationSettingsOutcome DescribeConfigurationSettings(
      const Model::DescribeConfigurationSettingsRequest& request) const;
 
  template <typename DescribeConfigurationSettingsRequestT = Model::DescribeConfigurationSettingsRequest>
  Model::DescribeConfigurationSettingsOutcomeCallable DescribeConfigurationSettingsCallable(
      const DescribeConfigurationSettingsRequestT& request) const {
    return SubmitCallable(&ElasticBeanstalkClient::DescribeConfigurationSettings, request);
  }
 
  template <typename DescribeConfigurationSettingsRequestT = Model::DescribeConfigurationSettingsRequest>
  void DescribeConfigurationSettingsAsync(const DescribeConfigurationSettingsRequestT& request,
                                          const DescribeConfigurationSettingsResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ElasticBeanstalkClient::DescribeConfigurationSettings, request, handler, context);
  }
 
  virtual Model::DescribeEnvironmentHealthOutcome DescribeEnvironmentHealth(
      const Model::DescribeEnvironmentHealthRequest& request = {}) const;
 
  template <typename DescribeEnvironmentHealthRequestT = Model::DescribeEnvironmentHealthRequest>
  Model::DescribeEnvironmentHealthOutcomeCallable DescribeEnvironmentHealthCallable(
      const DescribeEnvironmentHealthRequestT& request = {}) const {
    return SubmitCallable(&ElasticBeanstalkClient::DescribeEnvironmentHealth, request);
  }
 
  template <typename DescribeEnvironmentHealthRequestT = Model::DescribeEnvironmentHealthRequest>
  void DescribeEnvironmentHealthAsync(const DescribeEnvironmentHealthResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                      const DescribeEnvironmentHealthRequestT& request = {}) const {
    return SubmitAsync(&ElasticBeanstalkClient::DescribeEnvironmentHealth, request, handler, context);
  }
 
  virtual Model::DescribeEnvironmentManagedActionHistoryOutcome DescribeEnvironmentManagedActionHistory(
      const Model::DescribeEnvironmentManagedActionHistoryRequest& request = {}) const;
 
  template <typename DescribeEnvironmentManagedActionHistoryRequestT = Model::DescribeEnvironmentManagedActionHistoryRequest>
  Model::DescribeEnvironmentManagedActionHistoryOutcomeCallable DescribeEnvironmentManagedActionHistoryCallable(
      const DescribeEnvironmentManagedActionHistoryRequestT& request = {}) const {
    return SubmitCallable(&ElasticBeanstalkClient::DescribeEnvironmentManagedActionHistory, request);
  }
 
  template <typename DescribeEnvironmentManagedActionHistoryRequestT = Model::DescribeEnvironmentManagedActionHistoryRequest>
  void DescribeEnvironmentManagedActionHistoryAsync(const DescribeEnvironmentManagedActionHistoryResponseReceivedHandler& handler,
                                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                                    const DescribeEnvironmentManagedActionHistoryRequestT& request = {}) const {
    return SubmitAsync(&ElasticBeanstalkClient::DescribeEnvironmentManagedActionHistory, request, handler, context);
  }
 
  virtual Model::DescribeEnvironmentManagedActionsOutcome DescribeEnvironmentManagedActions(
      const Model::DescribeEnvironmentManagedActionsRequest& request = {}) const;
 
  template <typename DescribeEnvironmentManagedActionsRequestT = Model::DescribeEnvironmentManagedActionsRequest>
  Model::DescribeEnvironmentManagedActionsOutcomeCallable DescribeEnvironmentManagedActionsCallable(
      const DescribeEnvironmentManagedActionsRequestT& request = {}) const {
    return SubmitCallable(&ElasticBeanstalkClient::DescribeEnvironmentManagedActions, request);
  }
 
  template <typename DescribeEnvironmentManagedActionsRequestT = Model::DescribeEnvironmentManagedActionsRequest>
  void DescribeEnvironmentManagedActionsAsync(const DescribeEnvironmentManagedActionsResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                              const DescribeEnvironmentManagedActionsRequestT& request = {}) const {
    return SubmitAsync(&ElasticBeanstalkClient::DescribeEnvironmentManagedActions, request, handler, context);
  }
 
  virtual Model::DescribeEnvironmentResourcesOutcome DescribeEnvironmentResources(
      const Model::DescribeEnvironmentResourcesRequest& request = {}) const;
 
  template <typename DescribeEnvironmentResourcesRequestT = Model::DescribeEnvironmentResourcesRequest>
  Model::DescribeEnvironmentResourcesOutcomeCallable DescribeEnvironmentResourcesCallable(
      const DescribeEnvironmentResourcesRequestT& request = {}) const {
    return SubmitCallable(&ElasticBeanstalkClient::DescribeEnvironmentResources, request);
  }
 
  template <typename DescribeEnvironmentResourcesRequestT = Model::DescribeEnvironmentResourcesRequest>
  void DescribeEnvironmentResourcesAsync(const DescribeEnvironmentResourcesResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                         const DescribeEnvironmentResourcesRequestT& request = {}) const {
    return SubmitAsync(&ElasticBeanstalkClient::DescribeEnvironmentResources, request, handler, context);
  }
 
  virtual Model::DescribeEnvironmentsOutcome DescribeEnvironments(const Model::DescribeEnvironmentsRequest& request = {}) const;
 
  template <typename DescribeEnvironmentsRequestT = Model::DescribeEnvironmentsRequest>
  Model::DescribeEnvironmentsOutcomeCallable DescribeEnvironmentsCallable(const DescribeEnvironmentsRequestT& request = {}) const {
    return SubmitCallable(&ElasticBeanstalkClient::DescribeEnvironments, request);
  }
 
  template <typename DescribeEnvironmentsRequestT = Model::DescribeEnvironmentsRequest>
  void DescribeEnvironmentsAsync(const DescribeEnvironmentsResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                 const DescribeEnvironmentsRequestT& request = {}) const {
    return SubmitAsync(&ElasticBeanstalkClient::DescribeEnvironments, request, handler, context);
  }
 
  virtual Model::DescribeEventsOutcome DescribeEvents(const Model::DescribeEventsRequest& request = {}) const;
 
  template <typename DescribeEventsRequestT = Model::DescribeEventsRequest>
  Model::DescribeEventsOutcomeCallable DescribeEventsCallable(const DescribeEventsRequestT& request = {}) const {
    return SubmitCallable(&ElasticBeanstalkClient::DescribeEvents, request);
  }
 
  template <typename DescribeEventsRequestT = Model::DescribeEventsRequest>
  void DescribeEventsAsync(const DescribeEventsResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                           const DescribeEventsRequestT& request = {}) const {
    return SubmitAsync(&ElasticBeanstalkClient::DescribeEvents, request, handler, context);
  }
 
  virtual Model::DescribeInstancesHealthOutcome DescribeInstancesHealth(const Model::DescribeInstancesHealthRequest& request = {}) const;
 
  template <typename DescribeInstancesHealthRequestT = Model::DescribeInstancesHealthRequest>
  Model::DescribeInstancesHealthOutcomeCallable DescribeInstancesHealthCallable(const DescribeInstancesHealthRequestT& request = {}) const {
    return SubmitCallable(&ElasticBeanstalkClient::DescribeInstancesHealth, request);
  }
 
  template <typename DescribeInstancesHealthRequestT = Model::DescribeInstancesHealthRequest>
  void DescribeInstancesHealthAsync(const DescribeInstancesHealthResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                    const DescribeInstancesHealthRequestT& request = {}) const {
    return SubmitAsync(&ElasticBeanstalkClient::DescribeInstancesHealth, request, handler, context);
  }
 
  virtual Model::DescribePlatformVersionOutcome DescribePlatformVersion(const Model::DescribePlatformVersionRequest& request = {}) const;
 
  template <typename DescribePlatformVersionRequestT = Model::DescribePlatformVersionRequest>
  Model::DescribePlatformVersionOutcomeCallable DescribePlatformVersionCallable(const DescribePlatformVersionRequestT& request = {}) const {
    return SubmitCallable(&ElasticBeanstalkClient::DescribePlatformVersion, request);
  }
 
  template <typename DescribePlatformVersionRequestT = Model::DescribePlatformVersionRequest>
  void DescribePlatformVersionAsync(const DescribePlatformVersionResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                    const DescribePlatformVersionRequestT& request = {}) const {
    return SubmitAsync(&ElasticBeanstalkClient::DescribePlatformVersion, request, handler, context);
  }
 
  virtual Model::DisassociateEnvironmentOperationsRoleOutcome DisassociateEnvironmentOperationsRole(
      const Model::DisassociateEnvironmentOperationsRoleRequest& request) const;
 
  template <typename DisassociateEnvironmentOperationsRoleRequestT = Model::DisassociateEnvironmentOperationsRoleRequest>
  Model::DisassociateEnvironmentOperationsRoleOutcomeCallable DisassociateEnvironmentOperationsRoleCallable(
      const DisassociateEnvironmentOperationsRoleRequestT& request) const {
    return SubmitCallable(&ElasticBeanstalkClient::DisassociateEnvironmentOperationsRole, request);
  }
 
  template <typename DisassociateEnvironmentOperationsRoleRequestT = Model::DisassociateEnvironmentOperationsRoleRequest>
  void DisassociateEnvironmentOperationsRoleAsync(const DisassociateEnvironmentOperationsRoleRequestT& request,
                                                  const DisassociateEnvironmentOperationsRoleResponseReceivedHandler& handler,
                                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ElasticBeanstalkClient::DisassociateEnvironmentOperationsRole, request, handler, context);
  }
 
  virtual Model::ListAvailableSolutionStacksOutcome ListAvailableSolutionStacks(
      const Model::ListAvailableSolutionStacksRequest& request = {}) const;
 
  template <typename ListAvailableSolutionStacksRequestT = Model::ListAvailableSolutionStacksRequest>
  Model::ListAvailableSolutionStacksOutcomeCallable ListAvailableSolutionStacksCallable(
      const ListAvailableSolutionStacksRequestT& request = {}) const {
    return SubmitCallable(&ElasticBeanstalkClient::ListAvailableSolutionStacks, request);
  }
 
  template <typename ListAvailableSolutionStacksRequestT = Model::ListAvailableSolutionStacksRequest>
  void ListAvailableSolutionStacksAsync(const ListAvailableSolutionStacksResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                        const ListAvailableSolutionStacksRequestT& request = {}) const {
    return SubmitAsync(&ElasticBeanstalkClient::ListAvailableSolutionStacks, request, handler, context);
  }
 
  virtual Model::ListPlatformBranchesOutcome ListPlatformBranches(const Model::ListPlatformBranchesRequest& request = {}) const;
 
  template <typename ListPlatformBranchesRequestT = Model::ListPlatformBranchesRequest>
  Model::ListPlatformBranchesOutcomeCallable ListPlatformBranchesCallable(const ListPlatformBranchesRequestT& request = {}) const {
    return SubmitCallable(&ElasticBeanstalkClient::ListPlatformBranches, request);
  }
 
  template <typename ListPlatformBranchesRequestT = Model::ListPlatformBranchesRequest>
  void ListPlatformBranchesAsync(const ListPlatformBranchesResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                 const ListPlatformBranchesRequestT& request = {}) const {
    return SubmitAsync(&ElasticBeanstalkClient::ListPlatformBranches, request, handler, context);
  }
 
  virtual Model::ListPlatformVersionsOutcome ListPlatformVersions(const Model::ListPlatformVersionsRequest& request = {}) const;
 
  template <typename ListPlatformVersionsRequestT = Model::ListPlatformVersionsRequest>
  Model::ListPlatformVersionsOutcomeCallable ListPlatformVersionsCallable(const ListPlatformVersionsRequestT& request = {}) const {
    return SubmitCallable(&ElasticBeanstalkClient::ListPlatformVersions, request);
  }
 
  template <typename ListPlatformVersionsRequestT = Model::ListPlatformVersionsRequest>
  void ListPlatformVersionsAsync(const ListPlatformVersionsResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                 const ListPlatformVersionsRequestT& request = {}) const {
    return SubmitAsync(&ElasticBeanstalkClient::ListPlatformVersions, 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(&ElasticBeanstalkClient::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(&ElasticBeanstalkClient::ListTagsForResource, request, handler, context);
  }
 
  virtual Model::RebuildEnvironmentOutcome RebuildEnvironment(const Model::RebuildEnvironmentRequest& request = {}) const;
 
  template <typename RebuildEnvironmentRequestT = Model::RebuildEnvironmentRequest>
  Model::RebuildEnvironmentOutcomeCallable RebuildEnvironmentCallable(const RebuildEnvironmentRequestT& request = {}) const {
    return SubmitCallable(&ElasticBeanstalkClient::RebuildEnvironment, request);
  }
 
  template <typename RebuildEnvironmentRequestT = Model::RebuildEnvironmentRequest>
  void RebuildEnvironmentAsync(const RebuildEnvironmentResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                               const RebuildEnvironmentRequestT& request = {}) const {
    return SubmitAsync(&ElasticBeanstalkClient::RebuildEnvironment, request, handler, context);
  }
 
  virtual Model::RequestEnvironmentInfoOutcome RequestEnvironmentInfo(const Model::RequestEnvironmentInfoRequest& request) const;
 
  template <typename RequestEnvironmentInfoRequestT = Model::RequestEnvironmentInfoRequest>
  Model::RequestEnvironmentInfoOutcomeCallable RequestEnvironmentInfoCallable(const RequestEnvironmentInfoRequestT& request) const {
    return SubmitCallable(&ElasticBeanstalkClient::RequestEnvironmentInfo, request);
  }
 
  template <typename RequestEnvironmentInfoRequestT = Model::RequestEnvironmentInfoRequest>
  void RequestEnvironmentInfoAsync(const RequestEnvironmentInfoRequestT& request,
                                   const RequestEnvironmentInfoResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ElasticBeanstalkClient::RequestEnvironmentInfo, request, handler, context);
  }
 
  virtual Model::RestartAppServerOutcome RestartAppServer(const Model::RestartAppServerRequest& request = {}) const;
 
  template <typename RestartAppServerRequestT = Model::RestartAppServerRequest>
  Model::RestartAppServerOutcomeCallable RestartAppServerCallable(const RestartAppServerRequestT& request = {}) const {
    return SubmitCallable(&ElasticBeanstalkClient::RestartAppServer, request);
  }
 
  template <typename RestartAppServerRequestT = Model::RestartAppServerRequest>
  void RestartAppServerAsync(const RestartAppServerResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                             const RestartAppServerRequestT& request = {}) const {
    return SubmitAsync(&ElasticBeanstalkClient::RestartAppServer, request, handler, context);
  }
 
  virtual Model::RetrieveEnvironmentInfoOutcome RetrieveEnvironmentInfo(const Model::RetrieveEnvironmentInfoRequest& request) const;
 
  template <typename RetrieveEnvironmentInfoRequestT = Model::RetrieveEnvironmentInfoRequest>
  Model::RetrieveEnvironmentInfoOutcomeCallable RetrieveEnvironmentInfoCallable(const RetrieveEnvironmentInfoRequestT& request) const {
    return SubmitCallable(&ElasticBeanstalkClient::RetrieveEnvironmentInfo, request);
  }
 
  template <typename RetrieveEnvironmentInfoRequestT = Model::RetrieveEnvironmentInfoRequest>
  void RetrieveEnvironmentInfoAsync(const RetrieveEnvironmentInfoRequestT& request,
                                    const RetrieveEnvironmentInfoResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ElasticBeanstalkClient::RetrieveEnvironmentInfo, request, handler, context);
  }
 
  virtual Model::SwapEnvironmentCNAMEsOutcome SwapEnvironmentCNAMEs(const Model::SwapEnvironmentCNAMEsRequest& request = {}) const;
 
  template <typename SwapEnvironmentCNAMEsRequestT = Model::SwapEnvironmentCNAMEsRequest>
  Model::SwapEnvironmentCNAMEsOutcomeCallable SwapEnvironmentCNAMEsCallable(const SwapEnvironmentCNAMEsRequestT& request = {}) const {
    return SubmitCallable(&ElasticBeanstalkClient::SwapEnvironmentCNAMEs, request);
  }
 
  template <typename SwapEnvironmentCNAMEsRequestT = Model::SwapEnvironmentCNAMEsRequest>
  void SwapEnvironmentCNAMEsAsync(const SwapEnvironmentCNAMEsResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                  const SwapEnvironmentCNAMEsRequestT& request = {}) const {
    return SubmitAsync(&ElasticBeanstalkClient::SwapEnvironmentCNAMEs, request, handler, context);
  }
 
  virtual Model::TerminateEnvironmentOutcome TerminateEnvironment(const Model::TerminateEnvironmentRequest& request = {}) const;
 
  template <typename TerminateEnvironmentRequestT = Model::TerminateEnvironmentRequest>
  Model::TerminateEnvironmentOutcomeCallable TerminateEnvironmentCallable(const TerminateEnvironmentRequestT& request = {}) const {
    return SubmitCallable(&ElasticBeanstalkClient::TerminateEnvironment, request);
  }
 
  template <typename TerminateEnvironmentRequestT = Model::TerminateEnvironmentRequest>
  void TerminateEnvironmentAsync(const TerminateEnvironmentResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                 const TerminateEnvironmentRequestT& request = {}) const {
    return SubmitAsync(&ElasticBeanstalkClient::TerminateEnvironment, 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(&ElasticBeanstalkClient::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(&ElasticBeanstalkClient::UpdateApplication, request, handler, context);
  }
 
  virtual Model::UpdateApplicationResourceLifecycleOutcome UpdateApplicationResourceLifecycle(
      const Model::UpdateApplicationResourceLifecycleRequest& request) const;
 
  template <typename UpdateApplicationResourceLifecycleRequestT = Model::UpdateApplicationResourceLifecycleRequest>
  Model::UpdateApplicationResourceLifecycleOutcomeCallable UpdateApplicationResourceLifecycleCallable(
      const UpdateApplicationResourceLifecycleRequestT& request) const {
    return SubmitCallable(&ElasticBeanstalkClient::UpdateApplicationResourceLifecycle, request);
  }
 
  template <typename UpdateApplicationResourceLifecycleRequestT = Model::UpdateApplicationResourceLifecycleRequest>
  void UpdateApplicationResourceLifecycleAsync(const UpdateApplicationResourceLifecycleRequestT& request,
                                               const UpdateApplicationResourceLifecycleResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ElasticBeanstalkClient::UpdateApplicationResourceLifecycle, request, handler, context);
  }
 
  virtual Model::UpdateApplicationVersionOutcome UpdateApplicationVersion(const Model::UpdateApplicationVersionRequest& request) const;
 
  template <typename UpdateApplicationVersionRequestT = Model::UpdateApplicationVersionRequest>
  Model::UpdateApplicationVersionOutcomeCallable UpdateApplicationVersionCallable(const UpdateApplicationVersionRequestT& request) const {
    return SubmitCallable(&ElasticBeanstalkClient::UpdateApplicationVersion, request);
  }
 
  template <typename UpdateApplicationVersionRequestT = Model::UpdateApplicationVersionRequest>
  void UpdateApplicationVersionAsync(const UpdateApplicationVersionRequestT& request,
                                     const UpdateApplicationVersionResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ElasticBeanstalkClient::UpdateApplicationVersion, request, handler, context);
  }
 
  virtual Model::UpdateConfigurationTemplateOutcome UpdateConfigurationTemplate(
      const Model::UpdateConfigurationTemplateRequest& request) const;
 
  template <typename UpdateConfigurationTemplateRequestT = Model::UpdateConfigurationTemplateRequest>
  Model::UpdateConfigurationTemplateOutcomeCallable UpdateConfigurationTemplateCallable(
      const UpdateConfigurationTemplateRequestT& request) const {
    return SubmitCallable(&ElasticBeanstalkClient::UpdateConfigurationTemplate, request);
  }
 
  template <typename UpdateConfigurationTemplateRequestT = Model::UpdateConfigurationTemplateRequest>
  void UpdateConfigurationTemplateAsync(const UpdateConfigurationTemplateRequestT& request,
                                        const UpdateConfigurationTemplateResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ElasticBeanstalkClient::UpdateConfigurationTemplate, 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(&ElasticBeanstalkClient::UpdateEnvironment, request);
  }
 
  template <typename UpdateEnvironmentRequestT = Model::UpdateEnvironmentRequest>
  void UpdateEnvironmentAsync(const UpdateEnvironmentResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                              const UpdateEnvironmentRequestT& request = {}) const {
    return SubmitAsync(&ElasticBeanstalkClient::UpdateEnvironment, request, handler, context);
  }
 
  virtual Model::UpdateTagsForResourceOutcome UpdateTagsForResource(const Model::UpdateTagsForResourceRequest& request) const;
 
  template <typename UpdateTagsForResourceRequestT = Model::UpdateTagsForResourceRequest>
  Model::UpdateTagsForResourceOutcomeCallable UpdateTagsForResourceCallable(const UpdateTagsForResourceRequestT& request) const {
    return SubmitCallable(&ElasticBeanstalkClient::UpdateTagsForResource, request);
  }
 
  template <typename UpdateTagsForResourceRequestT = Model::UpdateTagsForResourceRequest>
  void UpdateTagsForResourceAsync(const UpdateTagsForResourceRequestT& request, const UpdateTagsForResourceResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ElasticBeanstalkClient::UpdateTagsForResource, request, handler, context);
  }
 
  virtual Model::ValidateConfigurationSettingsOutcome ValidateConfigurationSettings(
      const Model::ValidateConfigurationSettingsRequest& request) const;
 
  template <typename ValidateConfigurationSettingsRequestT = Model::ValidateConfigurationSettingsRequest>
  Model::ValidateConfigurationSettingsOutcomeCallable ValidateConfigurationSettingsCallable(
      const ValidateConfigurationSettingsRequestT& request) const {
    return SubmitCallable(&ElasticBeanstalkClient::ValidateConfigurationSettings, request);
  }
 
  template <typename ValidateConfigurationSettingsRequestT = Model::ValidateConfigurationSettingsRequest>
  void ValidateConfigurationSettingsAsync(const ValidateConfigurationSettingsRequestT& request,
                                          const ValidateConfigurationSettingsResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ElasticBeanstalkClient::ValidateConfigurationSettings, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<ElasticBeanstalkEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<ElasticBeanstalkClient>;
  void init(const ElasticBeanstalkClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, ElasticBeanstalkError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request, Aws::Http::HttpMethod httpMethod) const;
 
  ElasticBeanstalkClientConfiguration m_clientConfiguration;
  std::shared_ptr<ElasticBeanstalkEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace ElasticBeanstalk
}  // namespace Aws