ElasticLoadBalancingv2Client.h

 
#pragma once
#include <aws/elasticloadbalancingv2/ElasticLoadBalancingv2_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/elasticloadbalancingv2/ElasticLoadBalancingv2ServiceClientModel.h>
 
namespace Aws
{
namespace ElasticLoadBalancingv2
{
  class AWS_ELASTICLOADBALANCINGV2_API ElasticLoadBalancingv2Client : public Aws::Client::AWSXMLClient, public Aws::Client::ClientWithAsyncTemplateMethods<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);
        }
 
 
        void OverrideEndpoint(const Aws::String& endpoint);
        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