ElasticLoadBalancingClient.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/elasticloadbalancing/ElasticLoadBalancingPaginationBase.h>
#include <aws/elasticloadbalancing/ElasticLoadBalancingServiceClientModel.h>
#include <aws/elasticloadbalancing/ElasticLoadBalancingWaiter.h>
#include <aws/elasticloadbalancing/ElasticLoadBalancing_EXPORTS.h>
 
namespace Aws {
namespace ElasticLoadBalancing {
class AWS_ELASTICLOADBALANCING_API ElasticLoadBalancingClient
    : public Aws::Client::AWSXMLClient,
      public Aws::Client::ClientWithAsyncTemplateMethods<ElasticLoadBalancingClient>,
      public ElasticLoadBalancingPaginationBase<ElasticLoadBalancingClient>,
      public ElasticLoadBalancingWaiter<ElasticLoadBalancingClient> {
 public:
  typedef Aws::Client::AWSXMLClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef ElasticLoadBalancingClientConfiguration ClientConfigurationType;
  typedef ElasticLoadBalancingEndpointProvider EndpointProviderType;
 
  ElasticLoadBalancingClient(const Aws::ElasticLoadBalancing::ElasticLoadBalancingClientConfiguration& clientConfiguration =
                                 Aws::ElasticLoadBalancing::ElasticLoadBalancingClientConfiguration(),
                             std::shared_ptr<ElasticLoadBalancingEndpointProviderBase> endpointProvider = nullptr);
 
  ElasticLoadBalancingClient(const Aws::Auth::AWSCredentials& credentials,
                             std::shared_ptr<ElasticLoadBalancingEndpointProviderBase> endpointProvider = nullptr,
                             const Aws::ElasticLoadBalancing::ElasticLoadBalancingClientConfiguration& clientConfiguration =
                                 Aws::ElasticLoadBalancing::ElasticLoadBalancingClientConfiguration());
 
  ElasticLoadBalancingClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                             std::shared_ptr<ElasticLoadBalancingEndpointProviderBase> endpointProvider = nullptr,
                             const Aws::ElasticLoadBalancing::ElasticLoadBalancingClientConfiguration& clientConfiguration =
                                 Aws::ElasticLoadBalancing::ElasticLoadBalancingClientConfiguration());
 
  /* Legacy constructors due deprecation */
  ElasticLoadBalancingClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  ElasticLoadBalancingClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  ElasticLoadBalancingClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                             const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~ElasticLoadBalancingClient();
 
  Aws::String ConvertRequestToPresignedUrl(const Aws::AmazonSerializableWebServiceRequest& requestToConvert, const char* region) const;
 
  virtual Model::AddTagsOutcome AddTags(const Model::AddTagsRequest& request) const;
 
  template <typename AddTagsRequestT = Model::AddTagsRequest>
  Model::AddTagsOutcomeCallable AddTagsCallable(const AddTagsRequestT& request) const {
    return SubmitCallable(&ElasticLoadBalancingClient::AddTags, request);
  }
 
  template <typename AddTagsRequestT = Model::AddTagsRequest>
  void AddTagsAsync(const AddTagsRequestT& request, const AddTagsResponseReceivedHandler& handler,
                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ElasticLoadBalancingClient::AddTags, request, handler, context);
  }
 
  virtual Model::ApplySecurityGroupsToLoadBalancerOutcome ApplySecurityGroupsToLoadBalancer(
      const Model::ApplySecurityGroupsToLoadBalancerRequest& request) const;
 
  template <typename ApplySecurityGroupsToLoadBalancerRequestT = Model::ApplySecurityGroupsToLoadBalancerRequest>
  Model::ApplySecurityGroupsToLoadBalancerOutcomeCallable ApplySecurityGroupsToLoadBalancerCallable(
      const ApplySecurityGroupsToLoadBalancerRequestT& request) const {
    return SubmitCallable(&ElasticLoadBalancingClient::ApplySecurityGroupsToLoadBalancer, request);
  }
 
  template <typename ApplySecurityGroupsToLoadBalancerRequestT = Model::ApplySecurityGroupsToLoadBalancerRequest>
  void ApplySecurityGroupsToLoadBalancerAsync(const ApplySecurityGroupsToLoadBalancerRequestT& request,
                                              const ApplySecurityGroupsToLoadBalancerResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ElasticLoadBalancingClient::ApplySecurityGroupsToLoadBalancer, request, handler, context);
  }
 
  virtual Model::AttachLoadBalancerToSubnetsOutcome AttachLoadBalancerToSubnets(
      const Model::AttachLoadBalancerToSubnetsRequest& request) const;
 
  template <typename AttachLoadBalancerToSubnetsRequestT = Model::AttachLoadBalancerToSubnetsRequest>
  Model::AttachLoadBalancerToSubnetsOutcomeCallable AttachLoadBalancerToSubnetsCallable(
      const AttachLoadBalancerToSubnetsRequestT& request) const {
    return SubmitCallable(&ElasticLoadBalancingClient::AttachLoadBalancerToSubnets, request);
  }
 
  template <typename AttachLoadBalancerToSubnetsRequestT = Model::AttachLoadBalancerToSubnetsRequest>
  void AttachLoadBalancerToSubnetsAsync(const AttachLoadBalancerToSubnetsRequestT& request,
                                        const AttachLoadBalancerToSubnetsResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ElasticLoadBalancingClient::AttachLoadBalancerToSubnets, request, handler, context);
  }
 
  virtual Model::ConfigureHealthCheckOutcome ConfigureHealthCheck(const Model::ConfigureHealthCheckRequest& request) const;
 
  template <typename ConfigureHealthCheckRequestT = Model::ConfigureHealthCheckRequest>
  Model::ConfigureHealthCheckOutcomeCallable ConfigureHealthCheckCallable(const ConfigureHealthCheckRequestT& request) const {
    return SubmitCallable(&ElasticLoadBalancingClient::ConfigureHealthCheck, request);
  }
 
  template <typename ConfigureHealthCheckRequestT = Model::ConfigureHealthCheckRequest>
  void ConfigureHealthCheckAsync(const ConfigureHealthCheckRequestT& request, const ConfigureHealthCheckResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ElasticLoadBalancingClient::ConfigureHealthCheck, request, handler, context);
  }
 
  virtual Model::CreateAppCookieStickinessPolicyOutcome CreateAppCookieStickinessPolicy(
      const Model::CreateAppCookieStickinessPolicyRequest& request) const;
 
  template <typename CreateAppCookieStickinessPolicyRequestT = Model::CreateAppCookieStickinessPolicyRequest>
  Model::CreateAppCookieStickinessPolicyOutcomeCallable CreateAppCookieStickinessPolicyCallable(
      const CreateAppCookieStickinessPolicyRequestT& request) const {
    return SubmitCallable(&ElasticLoadBalancingClient::CreateAppCookieStickinessPolicy, request);
  }
 
  template <typename CreateAppCookieStickinessPolicyRequestT = Model::CreateAppCookieStickinessPolicyRequest>
  void CreateAppCookieStickinessPolicyAsync(const CreateAppCookieStickinessPolicyRequestT& request,
                                            const CreateAppCookieStickinessPolicyResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ElasticLoadBalancingClient::CreateAppCookieStickinessPolicy, request, handler, context);
  }
 
  virtual Model::CreateLBCookieStickinessPolicyOutcome CreateLBCookieStickinessPolicy(
      const Model::CreateLBCookieStickinessPolicyRequest& request) const;
 
  template <typename CreateLBCookieStickinessPolicyRequestT = Model::CreateLBCookieStickinessPolicyRequest>
  Model::CreateLBCookieStickinessPolicyOutcomeCallable CreateLBCookieStickinessPolicyCallable(
      const CreateLBCookieStickinessPolicyRequestT& request) const {
    return SubmitCallable(&ElasticLoadBalancingClient::CreateLBCookieStickinessPolicy, request);
  }
 
  template <typename CreateLBCookieStickinessPolicyRequestT = Model::CreateLBCookieStickinessPolicyRequest>
  void CreateLBCookieStickinessPolicyAsync(const CreateLBCookieStickinessPolicyRequestT& request,
                                           const CreateLBCookieStickinessPolicyResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ElasticLoadBalancingClient::CreateLBCookieStickinessPolicy, request, handler, context);
  }
 
  virtual Model::CreateLoadBalancerOutcome CreateLoadBalancer(const Model::CreateLoadBalancerRequest& request) const;
 
  template <typename CreateLoadBalancerRequestT = Model::CreateLoadBalancerRequest>
  Model::CreateLoadBalancerOutcomeCallable CreateLoadBalancerCallable(const CreateLoadBalancerRequestT& request) const {
    return SubmitCallable(&ElasticLoadBalancingClient::CreateLoadBalancer, request);
  }
 
  template <typename CreateLoadBalancerRequestT = Model::CreateLoadBalancerRequest>
  void CreateLoadBalancerAsync(const CreateLoadBalancerRequestT& request, const CreateLoadBalancerResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ElasticLoadBalancingClient::CreateLoadBalancer, request, handler, context);
  }
 
  virtual Model::CreateLoadBalancerListenersOutcome CreateLoadBalancerListeners(
      const Model::CreateLoadBalancerListenersRequest& request) const;
 
  template <typename CreateLoadBalancerListenersRequestT = Model::CreateLoadBalancerListenersRequest>
  Model::CreateLoadBalancerListenersOutcomeCallable CreateLoadBalancerListenersCallable(
      const CreateLoadBalancerListenersRequestT& request) const {
    return SubmitCallable(&ElasticLoadBalancingClient::CreateLoadBalancerListeners, request);
  }
 
  template <typename CreateLoadBalancerListenersRequestT = Model::CreateLoadBalancerListenersRequest>
  void CreateLoadBalancerListenersAsync(const CreateLoadBalancerListenersRequestT& request,
                                        const CreateLoadBalancerListenersResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ElasticLoadBalancingClient::CreateLoadBalancerListeners, request, handler, context);
  }
 
  virtual Model::CreateLoadBalancerPolicyOutcome CreateLoadBalancerPolicy(const Model::CreateLoadBalancerPolicyRequest& request) const;
 
  template <typename CreateLoadBalancerPolicyRequestT = Model::CreateLoadBalancerPolicyRequest>
  Model::CreateLoadBalancerPolicyOutcomeCallable CreateLoadBalancerPolicyCallable(const CreateLoadBalancerPolicyRequestT& request) const {
    return SubmitCallable(&ElasticLoadBalancingClient::CreateLoadBalancerPolicy, request);
  }
 
  template <typename CreateLoadBalancerPolicyRequestT = Model::CreateLoadBalancerPolicyRequest>
  void CreateLoadBalancerPolicyAsync(const CreateLoadBalancerPolicyRequestT& request,
                                     const CreateLoadBalancerPolicyResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ElasticLoadBalancingClient::CreateLoadBalancerPolicy, request, handler, context);
  }
 
  virtual Model::DeleteLoadBalancerOutcome DeleteLoadBalancer(const Model::DeleteLoadBalancerRequest& request) const;
 
  template <typename DeleteLoadBalancerRequestT = Model::DeleteLoadBalancerRequest>
  Model::DeleteLoadBalancerOutcomeCallable DeleteLoadBalancerCallable(const DeleteLoadBalancerRequestT& request) const {
    return SubmitCallable(&ElasticLoadBalancingClient::DeleteLoadBalancer, request);
  }
 
  template <typename DeleteLoadBalancerRequestT = Model::DeleteLoadBalancerRequest>
  void DeleteLoadBalancerAsync(const DeleteLoadBalancerRequestT& request, const DeleteLoadBalancerResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ElasticLoadBalancingClient::DeleteLoadBalancer, request, handler, context);
  }
 
  virtual Model::DeleteLoadBalancerListenersOutcome DeleteLoadBalancerListeners(
      const Model::DeleteLoadBalancerListenersRequest& request) const;
 
  template <typename DeleteLoadBalancerListenersRequestT = Model::DeleteLoadBalancerListenersRequest>
  Model::DeleteLoadBalancerListenersOutcomeCallable DeleteLoadBalancerListenersCallable(
      const DeleteLoadBalancerListenersRequestT& request) const {
    return SubmitCallable(&ElasticLoadBalancingClient::DeleteLoadBalancerListeners, request);
  }
 
  template <typename DeleteLoadBalancerListenersRequestT = Model::DeleteLoadBalancerListenersRequest>
  void DeleteLoadBalancerListenersAsync(const DeleteLoadBalancerListenersRequestT& request,
                                        const DeleteLoadBalancerListenersResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ElasticLoadBalancingClient::DeleteLoadBalancerListeners, request, handler, context);
  }
 
  virtual Model::DeleteLoadBalancerPolicyOutcome DeleteLoadBalancerPolicy(const Model::DeleteLoadBalancerPolicyRequest& request) const;
 
  template <typename DeleteLoadBalancerPolicyRequestT = Model::DeleteLoadBalancerPolicyRequest>
  Model::DeleteLoadBalancerPolicyOutcomeCallable DeleteLoadBalancerPolicyCallable(const DeleteLoadBalancerPolicyRequestT& request) const {
    return SubmitCallable(&ElasticLoadBalancingClient::DeleteLoadBalancerPolicy, request);
  }
 
  template <typename DeleteLoadBalancerPolicyRequestT = Model::DeleteLoadBalancerPolicyRequest>
  void DeleteLoadBalancerPolicyAsync(const DeleteLoadBalancerPolicyRequestT& request,
                                     const DeleteLoadBalancerPolicyResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ElasticLoadBalancingClient::DeleteLoadBalancerPolicy, request, handler, context);
  }
 
  virtual Model::DeregisterInstancesFromLoadBalancerOutcome DeregisterInstancesFromLoadBalancer(
      const Model::DeregisterInstancesFromLoadBalancerRequest& request) const;
 
  template <typename DeregisterInstancesFromLoadBalancerRequestT = Model::DeregisterInstancesFromLoadBalancerRequest>
  Model::DeregisterInstancesFromLoadBalancerOutcomeCallable DeregisterInstancesFromLoadBalancerCallable(
      const DeregisterInstancesFromLoadBalancerRequestT& request) const {
    return SubmitCallable(&ElasticLoadBalancingClient::DeregisterInstancesFromLoadBalancer, request);
  }
 
  template <typename DeregisterInstancesFromLoadBalancerRequestT = Model::DeregisterInstancesFromLoadBalancerRequest>
  void DeregisterInstancesFromLoadBalancerAsync(const DeregisterInstancesFromLoadBalancerRequestT& request,
                                                const DeregisterInstancesFromLoadBalancerResponseReceivedHandler& handler,
                                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ElasticLoadBalancingClient::DeregisterInstancesFromLoadBalancer, request, handler, context);
  }
 
  virtual Model::DescribeAccountLimitsOutcome DescribeAccountLimits(const Model::DescribeAccountLimitsRequest& request = {}) const;
 
  template <typename DescribeAccountLimitsRequestT = Model::DescribeAccountLimitsRequest>
  Model::DescribeAccountLimitsOutcomeCallable DescribeAccountLimitsCallable(const DescribeAccountLimitsRequestT& request = {}) const {
    return SubmitCallable(&ElasticLoadBalancingClient::DescribeAccountLimits, request);
  }
 
  template <typename DescribeAccountLimitsRequestT = Model::DescribeAccountLimitsRequest>
  void DescribeAccountLimitsAsync(const DescribeAccountLimitsResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                  const DescribeAccountLimitsRequestT& request = {}) const {
    return SubmitAsync(&ElasticLoadBalancingClient::DescribeAccountLimits, request, handler, context);
  }
 
  virtual Model::DescribeInstanceHealthOutcome DescribeInstanceHealth(const Model::DescribeInstanceHealthRequest& request) const;
 
  template <typename DescribeInstanceHealthRequestT = Model::DescribeInstanceHealthRequest>
  Model::DescribeInstanceHealthOutcomeCallable DescribeInstanceHealthCallable(const DescribeInstanceHealthRequestT& request) const {
    return SubmitCallable(&ElasticLoadBalancingClient::DescribeInstanceHealth, request);
  }
 
  template <typename DescribeInstanceHealthRequestT = Model::DescribeInstanceHealthRequest>
  void DescribeInstanceHealthAsync(const DescribeInstanceHealthRequestT& request,
                                   const DescribeInstanceHealthResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ElasticLoadBalancingClient::DescribeInstanceHealth, request, handler, context);
  }
 
  virtual Model::DescribeLoadBalancerAttributesOutcome DescribeLoadBalancerAttributes(
      const Model::DescribeLoadBalancerAttributesRequest& request) const;
 
  template <typename DescribeLoadBalancerAttributesRequestT = Model::DescribeLoadBalancerAttributesRequest>
  Model::DescribeLoadBalancerAttributesOutcomeCallable DescribeLoadBalancerAttributesCallable(
      const DescribeLoadBalancerAttributesRequestT& request) const {
    return SubmitCallable(&ElasticLoadBalancingClient::DescribeLoadBalancerAttributes, request);
  }
 
  template <typename DescribeLoadBalancerAttributesRequestT = Model::DescribeLoadBalancerAttributesRequest>
  void DescribeLoadBalancerAttributesAsync(const DescribeLoadBalancerAttributesRequestT& request,
                                           const DescribeLoadBalancerAttributesResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ElasticLoadBalancingClient::DescribeLoadBalancerAttributes, request, handler, context);
  }
 
  virtual Model::DescribeLoadBalancerPoliciesOutcome DescribeLoadBalancerPolicies(
      const Model::DescribeLoadBalancerPoliciesRequest& request = {}) const;
 
  template <typename DescribeLoadBalancerPoliciesRequestT = Model::DescribeLoadBalancerPoliciesRequest>
  Model::DescribeLoadBalancerPoliciesOutcomeCallable DescribeLoadBalancerPoliciesCallable(
      const DescribeLoadBalancerPoliciesRequestT& request = {}) const {
    return SubmitCallable(&ElasticLoadBalancingClient::DescribeLoadBalancerPolicies, request);
  }
 
  template <typename DescribeLoadBalancerPoliciesRequestT = Model::DescribeLoadBalancerPoliciesRequest>
  void DescribeLoadBalancerPoliciesAsync(const DescribeLoadBalancerPoliciesResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                         const DescribeLoadBalancerPoliciesRequestT& request = {}) const {
    return SubmitAsync(&ElasticLoadBalancingClient::DescribeLoadBalancerPolicies, request, handler, context);
  }
 
  virtual Model::DescribeLoadBalancerPolicyTypesOutcome DescribeLoadBalancerPolicyTypes(
      const Model::DescribeLoadBalancerPolicyTypesRequest& request = {}) const;
 
  template <typename DescribeLoadBalancerPolicyTypesRequestT = Model::DescribeLoadBalancerPolicyTypesRequest>
  Model::DescribeLoadBalancerPolicyTypesOutcomeCallable DescribeLoadBalancerPolicyTypesCallable(
      const DescribeLoadBalancerPolicyTypesRequestT& request = {}) const {
    return SubmitCallable(&ElasticLoadBalancingClient::DescribeLoadBalancerPolicyTypes, request);
  }
 
  template <typename DescribeLoadBalancerPolicyTypesRequestT = Model::DescribeLoadBalancerPolicyTypesRequest>
  void DescribeLoadBalancerPolicyTypesAsync(const DescribeLoadBalancerPolicyTypesResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                            const DescribeLoadBalancerPolicyTypesRequestT& request = {}) const {
    return SubmitAsync(&ElasticLoadBalancingClient::DescribeLoadBalancerPolicyTypes, request, handler, context);
  }
 
  virtual Model::DescribeLoadBalancersOutcome DescribeLoadBalancers(const Model::DescribeLoadBalancersRequest& request = {}) const;
 
  template <typename DescribeLoadBalancersRequestT = Model::DescribeLoadBalancersRequest>
  Model::DescribeLoadBalancersOutcomeCallable DescribeLoadBalancersCallable(const DescribeLoadBalancersRequestT& request = {}) const {
    return SubmitCallable(&ElasticLoadBalancingClient::DescribeLoadBalancers, request);
  }
 
  template <typename DescribeLoadBalancersRequestT = Model::DescribeLoadBalancersRequest>
  void DescribeLoadBalancersAsync(const DescribeLoadBalancersResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                  const DescribeLoadBalancersRequestT& request = {}) const {
    return SubmitAsync(&ElasticLoadBalancingClient::DescribeLoadBalancers, request, handler, context);
  }
 
  virtual Model::DescribeTagsOutcome DescribeTags(const Model::DescribeTagsRequest& request) const;
 
  template <typename DescribeTagsRequestT = Model::DescribeTagsRequest>
  Model::DescribeTagsOutcomeCallable DescribeTagsCallable(const DescribeTagsRequestT& request) const {
    return SubmitCallable(&ElasticLoadBalancingClient::DescribeTags, request);
  }
 
  template <typename DescribeTagsRequestT = Model::DescribeTagsRequest>
  void DescribeTagsAsync(const DescribeTagsRequestT& request, const DescribeTagsResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ElasticLoadBalancingClient::DescribeTags, request, handler, context);
  }
 
  virtual Model::DetachLoadBalancerFromSubnetsOutcome DetachLoadBalancerFromSubnets(
      const Model::DetachLoadBalancerFromSubnetsRequest& request) const;
 
  template <typename DetachLoadBalancerFromSubnetsRequestT = Model::DetachLoadBalancerFromSubnetsRequest>
  Model::DetachLoadBalancerFromSubnetsOutcomeCallable DetachLoadBalancerFromSubnetsCallable(
      const DetachLoadBalancerFromSubnetsRequestT& request) const {
    return SubmitCallable(&ElasticLoadBalancingClient::DetachLoadBalancerFromSubnets, request);
  }
 
  template <typename DetachLoadBalancerFromSubnetsRequestT = Model::DetachLoadBalancerFromSubnetsRequest>
  void DetachLoadBalancerFromSubnetsAsync(const DetachLoadBalancerFromSubnetsRequestT& request,
                                          const DetachLoadBalancerFromSubnetsResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ElasticLoadBalancingClient::DetachLoadBalancerFromSubnets, request, handler, context);
  }
 
  virtual Model::DisableAvailabilityZonesForLoadBalancerOutcome DisableAvailabilityZonesForLoadBalancer(
      const Model::DisableAvailabilityZonesForLoadBalancerRequest& request) const;
 
  template <typename DisableAvailabilityZonesForLoadBalancerRequestT = Model::DisableAvailabilityZonesForLoadBalancerRequest>
  Model::DisableAvailabilityZonesForLoadBalancerOutcomeCallable DisableAvailabilityZonesForLoadBalancerCallable(
      const DisableAvailabilityZonesForLoadBalancerRequestT& request) const {
    return SubmitCallable(&ElasticLoadBalancingClient::DisableAvailabilityZonesForLoadBalancer, request);
  }
 
  template <typename DisableAvailabilityZonesForLoadBalancerRequestT = Model::DisableAvailabilityZonesForLoadBalancerRequest>
  void DisableAvailabilityZonesForLoadBalancerAsync(const DisableAvailabilityZonesForLoadBalancerRequestT& request,
                                                    const DisableAvailabilityZonesForLoadBalancerResponseReceivedHandler& handler,
                                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ElasticLoadBalancingClient::DisableAvailabilityZonesForLoadBalancer, request, handler, context);
  }
 
  virtual Model::EnableAvailabilityZonesForLoadBalancerOutcome EnableAvailabilityZonesForLoadBalancer(
      const Model::EnableAvailabilityZonesForLoadBalancerRequest& request) const;
 
  template <typename EnableAvailabilityZonesForLoadBalancerRequestT = Model::EnableAvailabilityZonesForLoadBalancerRequest>
  Model::EnableAvailabilityZonesForLoadBalancerOutcomeCallable EnableAvailabilityZonesForLoadBalancerCallable(
      const EnableAvailabilityZonesForLoadBalancerRequestT& request) const {
    return SubmitCallable(&ElasticLoadBalancingClient::EnableAvailabilityZonesForLoadBalancer, request);
  }
 
  template <typename EnableAvailabilityZonesForLoadBalancerRequestT = Model::EnableAvailabilityZonesForLoadBalancerRequest>
  void EnableAvailabilityZonesForLoadBalancerAsync(const EnableAvailabilityZonesForLoadBalancerRequestT& request,
                                                   const EnableAvailabilityZonesForLoadBalancerResponseReceivedHandler& handler,
                                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ElasticLoadBalancingClient::EnableAvailabilityZonesForLoadBalancer, request, handler, context);
  }
 
  virtual Model::ModifyLoadBalancerAttributesOutcome ModifyLoadBalancerAttributes(
      const Model::ModifyLoadBalancerAttributesRequest& request) const;
 
  template <typename ModifyLoadBalancerAttributesRequestT = Model::ModifyLoadBalancerAttributesRequest>
  Model::ModifyLoadBalancerAttributesOutcomeCallable ModifyLoadBalancerAttributesCallable(
      const ModifyLoadBalancerAttributesRequestT& request) const {
    return SubmitCallable(&ElasticLoadBalancingClient::ModifyLoadBalancerAttributes, request);
  }
 
  template <typename ModifyLoadBalancerAttributesRequestT = Model::ModifyLoadBalancerAttributesRequest>
  void ModifyLoadBalancerAttributesAsync(const ModifyLoadBalancerAttributesRequestT& request,
                                         const ModifyLoadBalancerAttributesResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ElasticLoadBalancingClient::ModifyLoadBalancerAttributes, request, handler, context);
  }
 
  virtual Model::RegisterInstancesWithLoadBalancerOutcome RegisterInstancesWithLoadBalancer(
      const Model::RegisterInstancesWithLoadBalancerRequest& request) const;
 
  template <typename RegisterInstancesWithLoadBalancerRequestT = Model::RegisterInstancesWithLoadBalancerRequest>
  Model::RegisterInstancesWithLoadBalancerOutcomeCallable RegisterInstancesWithLoadBalancerCallable(
      const RegisterInstancesWithLoadBalancerRequestT& request) const {
    return SubmitCallable(&ElasticLoadBalancingClient::RegisterInstancesWithLoadBalancer, request);
  }
 
  template <typename RegisterInstancesWithLoadBalancerRequestT = Model::RegisterInstancesWithLoadBalancerRequest>
  void RegisterInstancesWithLoadBalancerAsync(const RegisterInstancesWithLoadBalancerRequestT& request,
                                              const RegisterInstancesWithLoadBalancerResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ElasticLoadBalancingClient::RegisterInstancesWithLoadBalancer, request, handler, context);
  }
 
  virtual Model::RemoveTagsOutcome RemoveTags(const Model::RemoveTagsRequest& request) const;
 
  template <typename RemoveTagsRequestT = Model::RemoveTagsRequest>
  Model::RemoveTagsOutcomeCallable RemoveTagsCallable(const RemoveTagsRequestT& request) const {
    return SubmitCallable(&ElasticLoadBalancingClient::RemoveTags, request);
  }
 
  template <typename RemoveTagsRequestT = Model::RemoveTagsRequest>
  void RemoveTagsAsync(const RemoveTagsRequestT& request, const RemoveTagsResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ElasticLoadBalancingClient::RemoveTags, request, handler, context);
  }
 
  virtual Model::SetLoadBalancerListenerSSLCertificateOutcome SetLoadBalancerListenerSSLCertificate(
      const Model::SetLoadBalancerListenerSSLCertificateRequest& request) const;
 
  template <typename SetLoadBalancerListenerSSLCertificateRequestT = Model::SetLoadBalancerListenerSSLCertificateRequest>
  Model::SetLoadBalancerListenerSSLCertificateOutcomeCallable SetLoadBalancerListenerSSLCertificateCallable(
      const SetLoadBalancerListenerSSLCertificateRequestT& request) const {
    return SubmitCallable(&ElasticLoadBalancingClient::SetLoadBalancerListenerSSLCertificate, request);
  }
 
  template <typename SetLoadBalancerListenerSSLCertificateRequestT = Model::SetLoadBalancerListenerSSLCertificateRequest>
  void SetLoadBalancerListenerSSLCertificateAsync(const SetLoadBalancerListenerSSLCertificateRequestT& request,
                                                  const SetLoadBalancerListenerSSLCertificateResponseReceivedHandler& handler,
                                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ElasticLoadBalancingClient::SetLoadBalancerListenerSSLCertificate, request, handler, context);
  }
 
  virtual Model::SetLoadBalancerPoliciesForBackendServerOutcome SetLoadBalancerPoliciesForBackendServer(
      const Model::SetLoadBalancerPoliciesForBackendServerRequest& request) const;
 
  template <typename SetLoadBalancerPoliciesForBackendServerRequestT = Model::SetLoadBalancerPoliciesForBackendServerRequest>
  Model::SetLoadBalancerPoliciesForBackendServerOutcomeCallable SetLoadBalancerPoliciesForBackendServerCallable(
      const SetLoadBalancerPoliciesForBackendServerRequestT& request) const {
    return SubmitCallable(&ElasticLoadBalancingClient::SetLoadBalancerPoliciesForBackendServer, request);
  }
 
  template <typename SetLoadBalancerPoliciesForBackendServerRequestT = Model::SetLoadBalancerPoliciesForBackendServerRequest>
  void SetLoadBalancerPoliciesForBackendServerAsync(const SetLoadBalancerPoliciesForBackendServerRequestT& request,
                                                    const SetLoadBalancerPoliciesForBackendServerResponseReceivedHandler& handler,
                                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ElasticLoadBalancingClient::SetLoadBalancerPoliciesForBackendServer, request, handler, context);
  }
 
  virtual Model::SetLoadBalancerPoliciesOfListenerOutcome SetLoadBalancerPoliciesOfListener(
      const Model::SetLoadBalancerPoliciesOfListenerRequest& request) const;
 
  template <typename SetLoadBalancerPoliciesOfListenerRequestT = Model::SetLoadBalancerPoliciesOfListenerRequest>
  Model::SetLoadBalancerPoliciesOfListenerOutcomeCallable SetLoadBalancerPoliciesOfListenerCallable(
      const SetLoadBalancerPoliciesOfListenerRequestT& request) const {
    return SubmitCallable(&ElasticLoadBalancingClient::SetLoadBalancerPoliciesOfListener, request);
  }
 
  template <typename SetLoadBalancerPoliciesOfListenerRequestT = Model::SetLoadBalancerPoliciesOfListenerRequest>
  void SetLoadBalancerPoliciesOfListenerAsync(const SetLoadBalancerPoliciesOfListenerRequestT& request,
                                              const SetLoadBalancerPoliciesOfListenerResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ElasticLoadBalancingClient::SetLoadBalancerPoliciesOfListener, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<ElasticLoadBalancingEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<ElasticLoadBalancingClient>;
  void init(const ElasticLoadBalancingClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, ElasticLoadBalancingError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request, Aws::Http::HttpMethod httpMethod) const;
 
  ElasticLoadBalancingClientConfiguration m_clientConfiguration;
  std::shared_ptr<ElasticLoadBalancingEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace ElasticLoadBalancing
}  // namespace Aws