ElasticLoadBalancingv2Client.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/elasticloadbalancingv2/ElasticLoadBalancingv2PaginationBase.h>
#include <aws/elasticloadbalancingv2/ElasticLoadBalancingv2ServiceClientModel.h>
#include <aws/elasticloadbalancingv2/ElasticLoadBalancingv2_EXPORTS.h>
 
namespace Aws {
namespace ElasticLoadBalancingv2 {
class AWS_ELASTICLOADBALANCINGV2_API ElasticLoadBalancingv2Client
    : public Aws::Client::AWSXMLClient,
      public Aws::Client::ClientWithAsyncTemplateMethods<ElasticLoadBalancingv2Client>,
      public ElasticLoadBalancingv2PaginationBase<ElasticLoadBalancingv2Client> {
 public:
  typedef Aws::Client::AWSXMLClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef ElasticLoadBalancingv2ClientConfiguration ClientConfigurationType;
  typedef ElasticLoadBalancingv2EndpointProvider EndpointProviderType;
 
  ElasticLoadBalancingv2Client(const Aws::ElasticLoadBalancingv2::ElasticLoadBalancingv2ClientConfiguration& clientConfiguration =
                                   Aws::ElasticLoadBalancingv2::ElasticLoadBalancingv2ClientConfiguration(),
                               std::shared_ptr<ElasticLoadBalancingv2EndpointProviderBase> endpointProvider = nullptr);
 
  ElasticLoadBalancingv2Client(const Aws::Auth::AWSCredentials& credentials,
                               std::shared_ptr<ElasticLoadBalancingv2EndpointProviderBase> endpointProvider = nullptr,
                               const Aws::ElasticLoadBalancingv2::ElasticLoadBalancingv2ClientConfiguration& clientConfiguration =
                                   Aws::ElasticLoadBalancingv2::ElasticLoadBalancingv2ClientConfiguration());
 
  ElasticLoadBalancingv2Client(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                               std::shared_ptr<ElasticLoadBalancingv2EndpointProviderBase> endpointProvider = nullptr,
                               const Aws::ElasticLoadBalancingv2::ElasticLoadBalancingv2ClientConfiguration& clientConfiguration =
                                   Aws::ElasticLoadBalancingv2::ElasticLoadBalancingv2ClientConfiguration());
 
  /* Legacy constructors due deprecation */
  ElasticLoadBalancingv2Client(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  ElasticLoadBalancingv2Client(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  ElasticLoadBalancingv2Client(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                               const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~ElasticLoadBalancingv2Client();
 
  Aws::String ConvertRequestToPresignedUrl(const Aws::AmazonSerializableWebServiceRequest& requestToConvert, const char* region) const;
 
  virtual Model::AddListenerCertificatesOutcome AddListenerCertificates(const Model::AddListenerCertificatesRequest& request) const;
 
  template <typename AddListenerCertificatesRequestT = Model::AddListenerCertificatesRequest>
  Model::AddListenerCertificatesOutcomeCallable AddListenerCertificatesCallable(const AddListenerCertificatesRequestT& request) const {
    return SubmitCallable(&ElasticLoadBalancingv2Client::AddListenerCertificates, request);
  }
 
  template <typename AddListenerCertificatesRequestT = Model::AddListenerCertificatesRequest>
  void AddListenerCertificatesAsync(const AddListenerCertificatesRequestT& request,
                                    const AddListenerCertificatesResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ElasticLoadBalancingv2Client::AddListenerCertificates, request, handler, context);
  }
 
  virtual Model::AddTagsOutcome AddTags(const Model::AddTagsRequest& request) const;
 
  template <typename AddTagsRequestT = Model::AddTagsRequest>
  Model::AddTagsOutcomeCallable AddTagsCallable(const AddTagsRequestT& request) const {
    return SubmitCallable(&ElasticLoadBalancingv2Client::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(&ElasticLoadBalancingv2Client::AddTags, request, handler, context);
  }
 
  virtual Model::AddTrustStoreRevocationsOutcome AddTrustStoreRevocations(const Model::AddTrustStoreRevocationsRequest& request) const;
 
  template <typename AddTrustStoreRevocationsRequestT = Model::AddTrustStoreRevocationsRequest>
  Model::AddTrustStoreRevocationsOutcomeCallable AddTrustStoreRevocationsCallable(const AddTrustStoreRevocationsRequestT& request) const {
    return SubmitCallable(&ElasticLoadBalancingv2Client::AddTrustStoreRevocations, request);
  }
 
  template <typename AddTrustStoreRevocationsRequestT = Model::AddTrustStoreRevocationsRequest>
  void AddTrustStoreRevocationsAsync(const AddTrustStoreRevocationsRequestT& request,
                                     const AddTrustStoreRevocationsResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ElasticLoadBalancingv2Client::AddTrustStoreRevocations, request, handler, context);
  }
 
  virtual Model::CreateListenerOutcome CreateListener(const Model::CreateListenerRequest& request) const;
 
  template <typename CreateListenerRequestT = Model::CreateListenerRequest>
  Model::CreateListenerOutcomeCallable CreateListenerCallable(const CreateListenerRequestT& request) const {
    return SubmitCallable(&ElasticLoadBalancingv2Client::CreateListener, request);
  }
 
  template <typename CreateListenerRequestT = Model::CreateListenerRequest>
  void CreateListenerAsync(const CreateListenerRequestT& request, const CreateListenerResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ElasticLoadBalancingv2Client::CreateListener, 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(&ElasticLoadBalancingv2Client::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(&ElasticLoadBalancingv2Client::CreateLoadBalancer, request, handler, context);
  }
 
  virtual Model::CreateRuleOutcome CreateRule(const Model::CreateRuleRequest& request) const;
 
  template <typename CreateRuleRequestT = Model::CreateRuleRequest>
  Model::CreateRuleOutcomeCallable CreateRuleCallable(const CreateRuleRequestT& request) const {
    return SubmitCallable(&ElasticLoadBalancingv2Client::CreateRule, request);
  }
 
  template <typename CreateRuleRequestT = Model::CreateRuleRequest>
  void CreateRuleAsync(const CreateRuleRequestT& request, const CreateRuleResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ElasticLoadBalancingv2Client::CreateRule, request, handler, context);
  }
 
  virtual Model::CreateTargetGroupOutcome CreateTargetGroup(const Model::CreateTargetGroupRequest& request) const;
 
  template <typename CreateTargetGroupRequestT = Model::CreateTargetGroupRequest>
  Model::CreateTargetGroupOutcomeCallable CreateTargetGroupCallable(const CreateTargetGroupRequestT& request) const {
    return SubmitCallable(&ElasticLoadBalancingv2Client::CreateTargetGroup, request);
  }
 
  template <typename CreateTargetGroupRequestT = Model::CreateTargetGroupRequest>
  void CreateTargetGroupAsync(const CreateTargetGroupRequestT& request, const CreateTargetGroupResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ElasticLoadBalancingv2Client::CreateTargetGroup, request, handler, context);
  }
 
  virtual Model::CreateTrustStoreOutcome CreateTrustStore(const Model::CreateTrustStoreRequest& request) const;
 
  template <typename CreateTrustStoreRequestT = Model::CreateTrustStoreRequest>
  Model::CreateTrustStoreOutcomeCallable CreateTrustStoreCallable(const CreateTrustStoreRequestT& request) const {
    return SubmitCallable(&ElasticLoadBalancingv2Client::CreateTrustStore, request);
  }
 
  template <typename CreateTrustStoreRequestT = Model::CreateTrustStoreRequest>
  void CreateTrustStoreAsync(const CreateTrustStoreRequestT& request, const CreateTrustStoreResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ElasticLoadBalancingv2Client::CreateTrustStore, request, handler, context);
  }
 
  virtual Model::DeleteListenerOutcome DeleteListener(const Model::DeleteListenerRequest& request) const;
 
  template <typename DeleteListenerRequestT = Model::DeleteListenerRequest>
  Model::DeleteListenerOutcomeCallable DeleteListenerCallable(const DeleteListenerRequestT& request) const {
    return SubmitCallable(&ElasticLoadBalancingv2Client::DeleteListener, request);
  }
 
  template <typename DeleteListenerRequestT = Model::DeleteListenerRequest>
  void DeleteListenerAsync(const DeleteListenerRequestT& request, const DeleteListenerResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ElasticLoadBalancingv2Client::DeleteListener, 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(&ElasticLoadBalancingv2Client::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(&ElasticLoadBalancingv2Client::DeleteLoadBalancer, request, handler, context);
  }
 
  virtual Model::DeleteRuleOutcome DeleteRule(const Model::DeleteRuleRequest& request) const;
 
  template <typename DeleteRuleRequestT = Model::DeleteRuleRequest>
  Model::DeleteRuleOutcomeCallable DeleteRuleCallable(const DeleteRuleRequestT& request) const {
    return SubmitCallable(&ElasticLoadBalancingv2Client::DeleteRule, request);
  }
 
  template <typename DeleteRuleRequestT = Model::DeleteRuleRequest>
  void DeleteRuleAsync(const DeleteRuleRequestT& request, const DeleteRuleResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ElasticLoadBalancingv2Client::DeleteRule, request, handler, context);
  }
 
  virtual Model::DeleteSharedTrustStoreAssociationOutcome DeleteSharedTrustStoreAssociation(
      const Model::DeleteSharedTrustStoreAssociationRequest& request) const;
 
  template <typename DeleteSharedTrustStoreAssociationRequestT = Model::DeleteSharedTrustStoreAssociationRequest>
  Model::DeleteSharedTrustStoreAssociationOutcomeCallable DeleteSharedTrustStoreAssociationCallable(
      const DeleteSharedTrustStoreAssociationRequestT& request) const {
    return SubmitCallable(&ElasticLoadBalancingv2Client::DeleteSharedTrustStoreAssociation, request);
  }
 
  template <typename DeleteSharedTrustStoreAssociationRequestT = Model::DeleteSharedTrustStoreAssociationRequest>
  void DeleteSharedTrustStoreAssociationAsync(const DeleteSharedTrustStoreAssociationRequestT& request,
                                              const DeleteSharedTrustStoreAssociationResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ElasticLoadBalancingv2Client::DeleteSharedTrustStoreAssociation, request, handler, context);
  }
 
  virtual Model::DeleteTargetGroupOutcome DeleteTargetGroup(const Model::DeleteTargetGroupRequest& request) const;
 
  template <typename DeleteTargetGroupRequestT = Model::DeleteTargetGroupRequest>
  Model::DeleteTargetGroupOutcomeCallable DeleteTargetGroupCallable(const DeleteTargetGroupRequestT& request) const {
    return SubmitCallable(&ElasticLoadBalancingv2Client::DeleteTargetGroup, request);
  }
 
  template <typename DeleteTargetGroupRequestT = Model::DeleteTargetGroupRequest>
  void DeleteTargetGroupAsync(const DeleteTargetGroupRequestT& request, const DeleteTargetGroupResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ElasticLoadBalancingv2Client::DeleteTargetGroup, request, handler, context);
  }
 
  virtual Model::DeleteTrustStoreOutcome DeleteTrustStore(const Model::DeleteTrustStoreRequest& request) const;
 
  template <typename DeleteTrustStoreRequestT = Model::DeleteTrustStoreRequest>
  Model::DeleteTrustStoreOutcomeCallable DeleteTrustStoreCallable(const DeleteTrustStoreRequestT& request) const {
    return SubmitCallable(&ElasticLoadBalancingv2Client::DeleteTrustStore, request);
  }
 
  template <typename DeleteTrustStoreRequestT = Model::DeleteTrustStoreRequest>
  void DeleteTrustStoreAsync(const DeleteTrustStoreRequestT& request, const DeleteTrustStoreResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ElasticLoadBalancingv2Client::DeleteTrustStore, request, handler, context);
  }
 
  virtual Model::DeregisterTargetsOutcome DeregisterTargets(const Model::DeregisterTargetsRequest& request) const;
 
  template <typename DeregisterTargetsRequestT = Model::DeregisterTargetsRequest>
  Model::DeregisterTargetsOutcomeCallable DeregisterTargetsCallable(const DeregisterTargetsRequestT& request) const {
    return SubmitCallable(&ElasticLoadBalancingv2Client::DeregisterTargets, request);
  }
 
  template <typename DeregisterTargetsRequestT = Model::DeregisterTargetsRequest>
  void DeregisterTargetsAsync(const DeregisterTargetsRequestT& request, const DeregisterTargetsResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ElasticLoadBalancingv2Client::DeregisterTargets, 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(&ElasticLoadBalancingv2Client::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(&ElasticLoadBalancingv2Client::DescribeAccountLimits, request, handler, context);
  }
 
  virtual Model::DescribeCapacityReservationOutcome DescribeCapacityReservation(
      const Model::DescribeCapacityReservationRequest& request) const;
 
  template <typename DescribeCapacityReservationRequestT = Model::DescribeCapacityReservationRequest>
  Model::DescribeCapacityReservationOutcomeCallable DescribeCapacityReservationCallable(
      const DescribeCapacityReservationRequestT& request) const {
    return SubmitCallable(&ElasticLoadBalancingv2Client::DescribeCapacityReservation, request);
  }
 
  template <typename DescribeCapacityReservationRequestT = Model::DescribeCapacityReservationRequest>
  void DescribeCapacityReservationAsync(const DescribeCapacityReservationRequestT& request,
                                        const DescribeCapacityReservationResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ElasticLoadBalancingv2Client::DescribeCapacityReservation, request, handler, context);
  }
 
  virtual Model::DescribeListenerAttributesOutcome DescribeListenerAttributes(
      const Model::DescribeListenerAttributesRequest& request) const;
 
  template <typename DescribeListenerAttributesRequestT = Model::DescribeListenerAttributesRequest>
  Model::DescribeListenerAttributesOutcomeCallable DescribeListenerAttributesCallable(
      const DescribeListenerAttributesRequestT& request) const {
    return SubmitCallable(&ElasticLoadBalancingv2Client::DescribeListenerAttributes, request);
  }
 
  template <typename DescribeListenerAttributesRequestT = Model::DescribeListenerAttributesRequest>
  void DescribeListenerAttributesAsync(const DescribeListenerAttributesRequestT& request,
                                       const DescribeListenerAttributesResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ElasticLoadBalancingv2Client::DescribeListenerAttributes, request, handler, context);
  }
 
  virtual Model::DescribeListenerCertificatesOutcome DescribeListenerCertificates(
      const Model::DescribeListenerCertificatesRequest& request) const;
 
  template <typename DescribeListenerCertificatesRequestT = Model::DescribeListenerCertificatesRequest>
  Model::DescribeListenerCertificatesOutcomeCallable DescribeListenerCertificatesCallable(
      const DescribeListenerCertificatesRequestT& request) const {
    return SubmitCallable(&ElasticLoadBalancingv2Client::DescribeListenerCertificates, request);
  }
 
  template <typename DescribeListenerCertificatesRequestT = Model::DescribeListenerCertificatesRequest>
  void DescribeListenerCertificatesAsync(const DescribeListenerCertificatesRequestT& request,
                                         const DescribeListenerCertificatesResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ElasticLoadBalancingv2Client::DescribeListenerCertificates, request, handler, context);
  }
 
  virtual Model::DescribeListenersOutcome DescribeListeners(const Model::DescribeListenersRequest& request = {}) const;
 
  template <typename DescribeListenersRequestT = Model::DescribeListenersRequest>
  Model::DescribeListenersOutcomeCallable DescribeListenersCallable(const DescribeListenersRequestT& request = {}) const {
    return SubmitCallable(&ElasticLoadBalancingv2Client::DescribeListeners, request);
  }
 
  template <typename DescribeListenersRequestT = Model::DescribeListenersRequest>
  void DescribeListenersAsync(const DescribeListenersResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                              const DescribeListenersRequestT& request = {}) const {
    return SubmitAsync(&ElasticLoadBalancingv2Client::DescribeListeners, 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(&ElasticLoadBalancingv2Client::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(&ElasticLoadBalancingv2Client::DescribeLoadBalancerAttributes, 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(&ElasticLoadBalancingv2Client::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(&ElasticLoadBalancingv2Client::DescribeLoadBalancers, request, handler, context);
  }
 
  virtual Model::DescribeRulesOutcome DescribeRules(const Model::DescribeRulesRequest& request = {}) const;
 
  template <typename DescribeRulesRequestT = Model::DescribeRulesRequest>
  Model::DescribeRulesOutcomeCallable DescribeRulesCallable(const DescribeRulesRequestT& request = {}) const {
    return SubmitCallable(&ElasticLoadBalancingv2Client::DescribeRules, request);
  }
 
  template <typename DescribeRulesRequestT = Model::DescribeRulesRequest>
  void DescribeRulesAsync(const DescribeRulesResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                          const DescribeRulesRequestT& request = {}) const {
    return SubmitAsync(&ElasticLoadBalancingv2Client::DescribeRules, request, handler, context);
  }
 
  virtual Model::DescribeSSLPoliciesOutcome DescribeSSLPolicies(const Model::DescribeSSLPoliciesRequest& request = {}) const;
 
  template <typename DescribeSSLPoliciesRequestT = Model::DescribeSSLPoliciesRequest>
  Model::DescribeSSLPoliciesOutcomeCallable DescribeSSLPoliciesCallable(const DescribeSSLPoliciesRequestT& request = {}) const {
    return SubmitCallable(&ElasticLoadBalancingv2Client::DescribeSSLPolicies, request);
  }
 
  template <typename DescribeSSLPoliciesRequestT = Model::DescribeSSLPoliciesRequest>
  void DescribeSSLPoliciesAsync(const DescribeSSLPoliciesResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                const DescribeSSLPoliciesRequestT& request = {}) const {
    return SubmitAsync(&ElasticLoadBalancingv2Client::DescribeSSLPolicies, 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(&ElasticLoadBalancingv2Client::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(&ElasticLoadBalancingv2Client::DescribeTags, request, handler, context);
  }
 
  virtual Model::DescribeTargetGroupAttributesOutcome DescribeTargetGroupAttributes(
      const Model::DescribeTargetGroupAttributesRequest& request) const;
 
  template <typename DescribeTargetGroupAttributesRequestT = Model::DescribeTargetGroupAttributesRequest>
  Model::DescribeTargetGroupAttributesOutcomeCallable DescribeTargetGroupAttributesCallable(
      const DescribeTargetGroupAttributesRequestT& request) const {
    return SubmitCallable(&ElasticLoadBalancingv2Client::DescribeTargetGroupAttributes, request);
  }
 
  template <typename DescribeTargetGroupAttributesRequestT = Model::DescribeTargetGroupAttributesRequest>
  void DescribeTargetGroupAttributesAsync(const DescribeTargetGroupAttributesRequestT& request,
                                          const DescribeTargetGroupAttributesResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ElasticLoadBalancingv2Client::DescribeTargetGroupAttributes, request, handler, context);
  }
 
  virtual Model::DescribeTargetGroupsOutcome DescribeTargetGroups(const Model::DescribeTargetGroupsRequest& request = {}) const;
 
  template <typename DescribeTargetGroupsRequestT = Model::DescribeTargetGroupsRequest>
  Model::DescribeTargetGroupsOutcomeCallable DescribeTargetGroupsCallable(const DescribeTargetGroupsRequestT& request = {}) const {
    return SubmitCallable(&ElasticLoadBalancingv2Client::DescribeTargetGroups, request);
  }
 
  template <typename DescribeTargetGroupsRequestT = Model::DescribeTargetGroupsRequest>
  void DescribeTargetGroupsAsync(const DescribeTargetGroupsResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                 const DescribeTargetGroupsRequestT& request = {}) const {
    return SubmitAsync(&ElasticLoadBalancingv2Client::DescribeTargetGroups, request, handler, context);
  }
 
  virtual Model::DescribeTargetHealthOutcome DescribeTargetHealth(const Model::DescribeTargetHealthRequest& request) const;
 
  template <typename DescribeTargetHealthRequestT = Model::DescribeTargetHealthRequest>
  Model::DescribeTargetHealthOutcomeCallable DescribeTargetHealthCallable(const DescribeTargetHealthRequestT& request) const {
    return SubmitCallable(&ElasticLoadBalancingv2Client::DescribeTargetHealth, request);
  }
 
  template <typename DescribeTargetHealthRequestT = Model::DescribeTargetHealthRequest>
  void DescribeTargetHealthAsync(const DescribeTargetHealthRequestT& request, const DescribeTargetHealthResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ElasticLoadBalancingv2Client::DescribeTargetHealth, request, handler, context);
  }
 
  virtual Model::DescribeTrustStoreAssociationsOutcome DescribeTrustStoreAssociations(
      const Model::DescribeTrustStoreAssociationsRequest& request) const;
 
  template <typename DescribeTrustStoreAssociationsRequestT = Model::DescribeTrustStoreAssociationsRequest>
  Model::DescribeTrustStoreAssociationsOutcomeCallable DescribeTrustStoreAssociationsCallable(
      const DescribeTrustStoreAssociationsRequestT& request) const {
    return SubmitCallable(&ElasticLoadBalancingv2Client::DescribeTrustStoreAssociations, request);
  }
 
  template <typename DescribeTrustStoreAssociationsRequestT = Model::DescribeTrustStoreAssociationsRequest>
  void DescribeTrustStoreAssociationsAsync(const DescribeTrustStoreAssociationsRequestT& request,
                                           const DescribeTrustStoreAssociationsResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ElasticLoadBalancingv2Client::DescribeTrustStoreAssociations, request, handler, context);
  }
 
  virtual Model::DescribeTrustStoreRevocationsOutcome DescribeTrustStoreRevocations(
      const Model::DescribeTrustStoreRevocationsRequest& request) const;
 
  template <typename DescribeTrustStoreRevocationsRequestT = Model::DescribeTrustStoreRevocationsRequest>
  Model::DescribeTrustStoreRevocationsOutcomeCallable DescribeTrustStoreRevocationsCallable(
      const DescribeTrustStoreRevocationsRequestT& request) const {
    return SubmitCallable(&ElasticLoadBalancingv2Client::DescribeTrustStoreRevocations, request);
  }
 
  template <typename DescribeTrustStoreRevocationsRequestT = Model::DescribeTrustStoreRevocationsRequest>
  void DescribeTrustStoreRevocationsAsync(const DescribeTrustStoreRevocationsRequestT& request,
                                          const DescribeTrustStoreRevocationsResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ElasticLoadBalancingv2Client::DescribeTrustStoreRevocations, request, handler, context);
  }
 
  virtual Model::DescribeTrustStoresOutcome DescribeTrustStores(const Model::DescribeTrustStoresRequest& request = {}) const;
 
  template <typename DescribeTrustStoresRequestT = Model::DescribeTrustStoresRequest>
  Model::DescribeTrustStoresOutcomeCallable DescribeTrustStoresCallable(const DescribeTrustStoresRequestT& request = {}) const {
    return SubmitCallable(&ElasticLoadBalancingv2Client::DescribeTrustStores, request);
  }
 
  template <typename DescribeTrustStoresRequestT = Model::DescribeTrustStoresRequest>
  void DescribeTrustStoresAsync(const DescribeTrustStoresResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                const DescribeTrustStoresRequestT& request = {}) const {
    return SubmitAsync(&ElasticLoadBalancingv2Client::DescribeTrustStores, request, handler, context);
  }
 
  virtual Model::GetResourcePolicyOutcome GetResourcePolicy(const Model::GetResourcePolicyRequest& request) const;
 
  template <typename GetResourcePolicyRequestT = Model::GetResourcePolicyRequest>
  Model::GetResourcePolicyOutcomeCallable GetResourcePolicyCallable(const GetResourcePolicyRequestT& request) const {
    return SubmitCallable(&ElasticLoadBalancingv2Client::GetResourcePolicy, request);
  }
 
  template <typename GetResourcePolicyRequestT = Model::GetResourcePolicyRequest>
  void GetResourcePolicyAsync(const GetResourcePolicyRequestT& request, const GetResourcePolicyResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ElasticLoadBalancingv2Client::GetResourcePolicy, request, handler, context);
  }
 
  virtual Model::GetTrustStoreCaCertificatesBundleOutcome GetTrustStoreCaCertificatesBundle(
      const Model::GetTrustStoreCaCertificatesBundleRequest& request) const;
 
  template <typename GetTrustStoreCaCertificatesBundleRequestT = Model::GetTrustStoreCaCertificatesBundleRequest>
  Model::GetTrustStoreCaCertificatesBundleOutcomeCallable GetTrustStoreCaCertificatesBundleCallable(
      const GetTrustStoreCaCertificatesBundleRequestT& request) const {
    return SubmitCallable(&ElasticLoadBalancingv2Client::GetTrustStoreCaCertificatesBundle, request);
  }
 
  template <typename GetTrustStoreCaCertificatesBundleRequestT = Model::GetTrustStoreCaCertificatesBundleRequest>
  void GetTrustStoreCaCertificatesBundleAsync(const GetTrustStoreCaCertificatesBundleRequestT& request,
                                              const GetTrustStoreCaCertificatesBundleResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ElasticLoadBalancingv2Client::GetTrustStoreCaCertificatesBundle, request, handler, context);
  }
 
  virtual Model::GetTrustStoreRevocationContentOutcome GetTrustStoreRevocationContent(
      const Model::GetTrustStoreRevocationContentRequest& request) const;
 
  template <typename GetTrustStoreRevocationContentRequestT = Model::GetTrustStoreRevocationContentRequest>
  Model::GetTrustStoreRevocationContentOutcomeCallable GetTrustStoreRevocationContentCallable(
      const GetTrustStoreRevocationContentRequestT& request) const {
    return SubmitCallable(&ElasticLoadBalancingv2Client::GetTrustStoreRevocationContent, request);
  }
 
  template <typename GetTrustStoreRevocationContentRequestT = Model::GetTrustStoreRevocationContentRequest>
  void GetTrustStoreRevocationContentAsync(const GetTrustStoreRevocationContentRequestT& request,
                                           const GetTrustStoreRevocationContentResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ElasticLoadBalancingv2Client::GetTrustStoreRevocationContent, request, handler, context);
  }
 
  virtual Model::ModifyCapacityReservationOutcome ModifyCapacityReservation(const Model::ModifyCapacityReservationRequest& request) const;
 
  template <typename ModifyCapacityReservationRequestT = Model::ModifyCapacityReservationRequest>
  Model::ModifyCapacityReservationOutcomeCallable ModifyCapacityReservationCallable(
      const ModifyCapacityReservationRequestT& request) const {
    return SubmitCallable(&ElasticLoadBalancingv2Client::ModifyCapacityReservation, request);
  }
 
  template <typename ModifyCapacityReservationRequestT = Model::ModifyCapacityReservationRequest>
  void ModifyCapacityReservationAsync(const ModifyCapacityReservationRequestT& request,
                                      const ModifyCapacityReservationResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ElasticLoadBalancingv2Client::ModifyCapacityReservation, request, handler, context);
  }
 
  virtual Model::ModifyIpPoolsOutcome ModifyIpPools(const Model::ModifyIpPoolsRequest& request) const;
 
  template <typename ModifyIpPoolsRequestT = Model::ModifyIpPoolsRequest>
  Model::ModifyIpPoolsOutcomeCallable ModifyIpPoolsCallable(const ModifyIpPoolsRequestT& request) const {
    return SubmitCallable(&ElasticLoadBalancingv2Client::ModifyIpPools, request);
  }
 
  template <typename ModifyIpPoolsRequestT = Model::ModifyIpPoolsRequest>
  void ModifyIpPoolsAsync(const ModifyIpPoolsRequestT& request, const ModifyIpPoolsResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ElasticLoadBalancingv2Client::ModifyIpPools, request, handler, context);
  }
 
  virtual Model::ModifyListenerOutcome ModifyListener(const Model::ModifyListenerRequest& request) const;
 
  template <typename ModifyListenerRequestT = Model::ModifyListenerRequest>
  Model::ModifyListenerOutcomeCallable ModifyListenerCallable(const ModifyListenerRequestT& request) const {
    return SubmitCallable(&ElasticLoadBalancingv2Client::ModifyListener, request);
  }
 
  template <typename ModifyListenerRequestT = Model::ModifyListenerRequest>
  void ModifyListenerAsync(const ModifyListenerRequestT& request, const ModifyListenerResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ElasticLoadBalancingv2Client::ModifyListener, request, handler, context);
  }
 
  virtual Model::ModifyListenerAttributesOutcome ModifyListenerAttributes(const Model::ModifyListenerAttributesRequest& request) const;
 
  template <typename ModifyListenerAttributesRequestT = Model::ModifyListenerAttributesRequest>
  Model::ModifyListenerAttributesOutcomeCallable ModifyListenerAttributesCallable(const ModifyListenerAttributesRequestT& request) const {
    return SubmitCallable(&ElasticLoadBalancingv2Client::ModifyListenerAttributes, request);
  }
 
  template <typename ModifyListenerAttributesRequestT = Model::ModifyListenerAttributesRequest>
  void ModifyListenerAttributesAsync(const ModifyListenerAttributesRequestT& request,
                                     const ModifyListenerAttributesResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ElasticLoadBalancingv2Client::ModifyListenerAttributes, 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(&ElasticLoadBalancingv2Client::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(&ElasticLoadBalancingv2Client::ModifyLoadBalancerAttributes, request, handler, context);
  }
 
  virtual Model::ModifyRuleOutcome ModifyRule(const Model::ModifyRuleRequest& request) const;
 
  template <typename ModifyRuleRequestT = Model::ModifyRuleRequest>
  Model::ModifyRuleOutcomeCallable ModifyRuleCallable(const ModifyRuleRequestT& request) const {
    return SubmitCallable(&ElasticLoadBalancingv2Client::ModifyRule, request);
  }
 
  template <typename ModifyRuleRequestT = Model::ModifyRuleRequest>
  void ModifyRuleAsync(const ModifyRuleRequestT& request, const ModifyRuleResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ElasticLoadBalancingv2Client::ModifyRule, request, handler, context);
  }
 
  virtual Model::ModifyTargetGroupOutcome ModifyTargetGroup(const Model::ModifyTargetGroupRequest& request) const;
 
  template <typename ModifyTargetGroupRequestT = Model::ModifyTargetGroupRequest>
  Model::ModifyTargetGroupOutcomeCallable ModifyTargetGroupCallable(const ModifyTargetGroupRequestT& request) const {
    return SubmitCallable(&ElasticLoadBalancingv2Client::ModifyTargetGroup, request);
  }
 
  template <typename ModifyTargetGroupRequestT = Model::ModifyTargetGroupRequest>
  void ModifyTargetGroupAsync(const ModifyTargetGroupRequestT& request, const ModifyTargetGroupResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ElasticLoadBalancingv2Client::ModifyTargetGroup, request, handler, context);
  }
 
  virtual Model::ModifyTargetGroupAttributesOutcome ModifyTargetGroupAttributes(
      const Model::ModifyTargetGroupAttributesRequest& request) const;
 
  template <typename ModifyTargetGroupAttributesRequestT = Model::ModifyTargetGroupAttributesRequest>
  Model::ModifyTargetGroupAttributesOutcomeCallable ModifyTargetGroupAttributesCallable(
      const ModifyTargetGroupAttributesRequestT& request) const {
    return SubmitCallable(&ElasticLoadBalancingv2Client::ModifyTargetGroupAttributes, request);
  }
 
  template <typename ModifyTargetGroupAttributesRequestT = Model::ModifyTargetGroupAttributesRequest>
  void ModifyTargetGroupAttributesAsync(const ModifyTargetGroupAttributesRequestT& request,
                                        const ModifyTargetGroupAttributesResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ElasticLoadBalancingv2Client::ModifyTargetGroupAttributes, request, handler, context);
  }
 
  virtual Model::ModifyTrustStoreOutcome ModifyTrustStore(const Model::ModifyTrustStoreRequest& request) const;
 
  template <typename ModifyTrustStoreRequestT = Model::ModifyTrustStoreRequest>
  Model::ModifyTrustStoreOutcomeCallable ModifyTrustStoreCallable(const ModifyTrustStoreRequestT& request) const {
    return SubmitCallable(&ElasticLoadBalancingv2Client::ModifyTrustStore, request);
  }
 
  template <typename ModifyTrustStoreRequestT = Model::ModifyTrustStoreRequest>
  void ModifyTrustStoreAsync(const ModifyTrustStoreRequestT& request, const ModifyTrustStoreResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ElasticLoadBalancingv2Client::ModifyTrustStore, request, handler, context);
  }
 
  virtual Model::RegisterTargetsOutcome RegisterTargets(const Model::RegisterTargetsRequest& request) const;
 
  template <typename RegisterTargetsRequestT = Model::RegisterTargetsRequest>
  Model::RegisterTargetsOutcomeCallable RegisterTargetsCallable(const RegisterTargetsRequestT& request) const {
    return SubmitCallable(&ElasticLoadBalancingv2Client::RegisterTargets, request);
  }
 
  template <typename RegisterTargetsRequestT = Model::RegisterTargetsRequest>
  void RegisterTargetsAsync(const RegisterTargetsRequestT& request, const RegisterTargetsResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ElasticLoadBalancingv2Client::RegisterTargets, request, handler, context);
  }
 
  virtual Model::RemoveListenerCertificatesOutcome RemoveListenerCertificates(
      const Model::RemoveListenerCertificatesRequest& request) const;
 
  template <typename RemoveListenerCertificatesRequestT = Model::RemoveListenerCertificatesRequest>
  Model::RemoveListenerCertificatesOutcomeCallable RemoveListenerCertificatesCallable(
      const RemoveListenerCertificatesRequestT& request) const {
    return SubmitCallable(&ElasticLoadBalancingv2Client::RemoveListenerCertificates, request);
  }
 
  template <typename RemoveListenerCertificatesRequestT = Model::RemoveListenerCertificatesRequest>
  void RemoveListenerCertificatesAsync(const RemoveListenerCertificatesRequestT& request,
                                       const RemoveListenerCertificatesResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ElasticLoadBalancingv2Client::RemoveListenerCertificates, 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(&ElasticLoadBalancingv2Client::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(&ElasticLoadBalancingv2Client::RemoveTags, request, handler, context);
  }
 
  virtual Model::RemoveTrustStoreRevocationsOutcome RemoveTrustStoreRevocations(
      const Model::RemoveTrustStoreRevocationsRequest& request) const;
 
  template <typename RemoveTrustStoreRevocationsRequestT = Model::RemoveTrustStoreRevocationsRequest>
  Model::RemoveTrustStoreRevocationsOutcomeCallable RemoveTrustStoreRevocationsCallable(
      const RemoveTrustStoreRevocationsRequestT& request) const {
    return SubmitCallable(&ElasticLoadBalancingv2Client::RemoveTrustStoreRevocations, request);
  }
 
  template <typename RemoveTrustStoreRevocationsRequestT = Model::RemoveTrustStoreRevocationsRequest>
  void RemoveTrustStoreRevocationsAsync(const RemoveTrustStoreRevocationsRequestT& request,
                                        const RemoveTrustStoreRevocationsResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ElasticLoadBalancingv2Client::RemoveTrustStoreRevocations, request, handler, context);
  }
 
  virtual Model::SetIpAddressTypeOutcome SetIpAddressType(const Model::SetIpAddressTypeRequest& request) const;
 
  template <typename SetIpAddressTypeRequestT = Model::SetIpAddressTypeRequest>
  Model::SetIpAddressTypeOutcomeCallable SetIpAddressTypeCallable(const SetIpAddressTypeRequestT& request) const {
    return SubmitCallable(&ElasticLoadBalancingv2Client::SetIpAddressType, request);
  }
 
  template <typename SetIpAddressTypeRequestT = Model::SetIpAddressTypeRequest>
  void SetIpAddressTypeAsync(const SetIpAddressTypeRequestT& request, const SetIpAddressTypeResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ElasticLoadBalancingv2Client::SetIpAddressType, request, handler, context);
  }
 
  virtual Model::SetRulePrioritiesOutcome SetRulePriorities(const Model::SetRulePrioritiesRequest& request) const;
 
  template <typename SetRulePrioritiesRequestT = Model::SetRulePrioritiesRequest>
  Model::SetRulePrioritiesOutcomeCallable SetRulePrioritiesCallable(const SetRulePrioritiesRequestT& request) const {
    return SubmitCallable(&ElasticLoadBalancingv2Client::SetRulePriorities, request);
  }
 
  template <typename SetRulePrioritiesRequestT = Model::SetRulePrioritiesRequest>
  void SetRulePrioritiesAsync(const SetRulePrioritiesRequestT& request, const SetRulePrioritiesResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ElasticLoadBalancingv2Client::SetRulePriorities, request, handler, context);
  }
 
  virtual Model::SetSecurityGroupsOutcome SetSecurityGroups(const Model::SetSecurityGroupsRequest& request) const;
 
  template <typename SetSecurityGroupsRequestT = Model::SetSecurityGroupsRequest>
  Model::SetSecurityGroupsOutcomeCallable SetSecurityGroupsCallable(const SetSecurityGroupsRequestT& request) const {
    return SubmitCallable(&ElasticLoadBalancingv2Client::SetSecurityGroups, request);
  }
 
  template <typename SetSecurityGroupsRequestT = Model::SetSecurityGroupsRequest>
  void SetSecurityGroupsAsync(const SetSecurityGroupsRequestT& request, const SetSecurityGroupsResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ElasticLoadBalancingv2Client::SetSecurityGroups, request, handler, context);
  }
 
  virtual Model::SetSubnetsOutcome SetSubnets(const Model::SetSubnetsRequest& request) const;
 
  template <typename SetSubnetsRequestT = Model::SetSubnetsRequest>
  Model::SetSubnetsOutcomeCallable SetSubnetsCallable(const SetSubnetsRequestT& request) const {
    return SubmitCallable(&ElasticLoadBalancingv2Client::SetSubnets, request);
  }
 
  template <typename SetSubnetsRequestT = Model::SetSubnetsRequest>
  void SetSubnetsAsync(const SetSubnetsRequestT& request, const SetSubnetsResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ElasticLoadBalancingv2Client::SetSubnets, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<ElasticLoadBalancingv2EndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<ElasticLoadBalancingv2Client>;
  void init(const ElasticLoadBalancingv2ClientConfiguration& clientConfiguration);
 
  ElasticLoadBalancingv2ClientConfiguration m_clientConfiguration;
  std::shared_ptr<ElasticLoadBalancingv2EndpointProviderBase> m_endpointProvider;
};
 
}  // namespace ElasticLoadBalancingv2
}  // namespace Aws