ElasticBeanstalkClient.h

 
#pragma once
#include <aws/elasticbeanstalk/ElasticBeanstalk_EXPORTS.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/AmazonSerializableWebServiceRequest.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/utils/xml/XmlSerializer.h>
#include <aws/elasticbeanstalk/ElasticBeanstalkServiceClientModel.h>
 
namespace Aws
{
namespace ElasticBeanstalk
{
  class AWS_ELASTICBEANSTALK_API ElasticBeanstalkClient : public Aws::Client::AWSXMLClient, public Aws::Client::ClientWithAsyncTemplateMethods<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);
        }
 
 
        void OverrideEndpoint(const Aws::String& endpoint);
        std::shared_ptr<ElasticBeanstalkEndpointProviderBase>& accessEndpointProvider();
  private:
        friend class Aws::Client::ClientWithAsyncTemplateMethods<ElasticBeanstalkClient>;
        void init(const ElasticBeanstalkClientConfiguration& clientConfiguration);
 
        ElasticBeanstalkClientConfiguration m_clientConfiguration;
        std::shared_ptr<ElasticBeanstalkEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace ElasticBeanstalk
} // namespace Aws