VPCLatticeClient.h

 
#pragma once
#include <aws/vpc-lattice/VPCLattice_EXPORTS.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/vpc-lattice/VPCLatticeServiceClientModel.h>
 
namespace Aws
{
namespace VPCLattice
{
  class AWS_VPCLATTICE_API VPCLatticeClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<VPCLatticeClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef VPCLatticeClientConfiguration ClientConfigurationType;
      typedef VPCLatticeEndpointProvider EndpointProviderType;
 
        VPCLatticeClient(const Aws::VPCLattice::VPCLatticeClientConfiguration& clientConfiguration = Aws::VPCLattice::VPCLatticeClientConfiguration(),
                         std::shared_ptr<VPCLatticeEndpointProviderBase> endpointProvider = nullptr);
 
        VPCLatticeClient(const Aws::Auth::AWSCredentials& credentials,
                         std::shared_ptr<VPCLatticeEndpointProviderBase> endpointProvider = nullptr,
                         const Aws::VPCLattice::VPCLatticeClientConfiguration& clientConfiguration = Aws::VPCLattice::VPCLatticeClientConfiguration());
 
        VPCLatticeClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                         std::shared_ptr<VPCLatticeEndpointProviderBase> endpointProvider = nullptr,
                         const Aws::VPCLattice::VPCLatticeClientConfiguration& clientConfiguration = Aws::VPCLattice::VPCLatticeClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        VPCLatticeClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        VPCLatticeClient(const Aws::Auth::AWSCredentials& credentials,
                         const Aws::Client::ClientConfiguration& clientConfiguration);
 
        VPCLatticeClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                         const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~VPCLatticeClient();
 
        virtual Model::BatchUpdateRuleOutcome BatchUpdateRule(const Model::BatchUpdateRuleRequest& request) const;
 
        template<typename BatchUpdateRuleRequestT = Model::BatchUpdateRuleRequest>
        Model::BatchUpdateRuleOutcomeCallable BatchUpdateRuleCallable(const BatchUpdateRuleRequestT& request) const
        {
            return SubmitCallable(&VPCLatticeClient::BatchUpdateRule, request);
        }
 
        template<typename BatchUpdateRuleRequestT = Model::BatchUpdateRuleRequest>
        void BatchUpdateRuleAsync(const BatchUpdateRuleRequestT& request, const BatchUpdateRuleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&VPCLatticeClient::BatchUpdateRule, request, handler, context);
        }
 
        virtual Model::CreateAccessLogSubscriptionOutcome CreateAccessLogSubscription(const Model::CreateAccessLogSubscriptionRequest& request) const;
 
        template<typename CreateAccessLogSubscriptionRequestT = Model::CreateAccessLogSubscriptionRequest>
        Model::CreateAccessLogSubscriptionOutcomeCallable CreateAccessLogSubscriptionCallable(const CreateAccessLogSubscriptionRequestT& request) const
        {
            return SubmitCallable(&VPCLatticeClient::CreateAccessLogSubscription, request);
        }
 
        template<typename CreateAccessLogSubscriptionRequestT = Model::CreateAccessLogSubscriptionRequest>
        void CreateAccessLogSubscriptionAsync(const CreateAccessLogSubscriptionRequestT& request, const CreateAccessLogSubscriptionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&VPCLatticeClient::CreateAccessLogSubscription, 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(&VPCLatticeClient::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(&VPCLatticeClient::CreateListener, 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(&VPCLatticeClient::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(&VPCLatticeClient::CreateRule, request, handler, context);
        }
 
        virtual Model::CreateServiceOutcome CreateService(const Model::CreateServiceRequest& request) const;
 
        template<typename CreateServiceRequestT = Model::CreateServiceRequest>
        Model::CreateServiceOutcomeCallable CreateServiceCallable(const CreateServiceRequestT& request) const
        {
            return SubmitCallable(&VPCLatticeClient::CreateService, request);
        }
 
        template<typename CreateServiceRequestT = Model::CreateServiceRequest>
        void CreateServiceAsync(const CreateServiceRequestT& request, const CreateServiceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&VPCLatticeClient::CreateService, request, handler, context);
        }
 
        virtual Model::CreateServiceNetworkOutcome CreateServiceNetwork(const Model::CreateServiceNetworkRequest& request) const;
 
        template<typename CreateServiceNetworkRequestT = Model::CreateServiceNetworkRequest>
        Model::CreateServiceNetworkOutcomeCallable CreateServiceNetworkCallable(const CreateServiceNetworkRequestT& request) const
        {
            return SubmitCallable(&VPCLatticeClient::CreateServiceNetwork, request);
        }
 
        template<typename CreateServiceNetworkRequestT = Model::CreateServiceNetworkRequest>
        void CreateServiceNetworkAsync(const CreateServiceNetworkRequestT& request, const CreateServiceNetworkResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&VPCLatticeClient::CreateServiceNetwork, request, handler, context);
        }
 
        virtual Model::CreateServiceNetworkServiceAssociationOutcome CreateServiceNetworkServiceAssociation(const Model::CreateServiceNetworkServiceAssociationRequest& request) const;
 
        template<typename CreateServiceNetworkServiceAssociationRequestT = Model::CreateServiceNetworkServiceAssociationRequest>
        Model::CreateServiceNetworkServiceAssociationOutcomeCallable CreateServiceNetworkServiceAssociationCallable(const CreateServiceNetworkServiceAssociationRequestT& request) const
        {
            return SubmitCallable(&VPCLatticeClient::CreateServiceNetworkServiceAssociation, request);
        }
 
        template<typename CreateServiceNetworkServiceAssociationRequestT = Model::CreateServiceNetworkServiceAssociationRequest>
        void CreateServiceNetworkServiceAssociationAsync(const CreateServiceNetworkServiceAssociationRequestT& request, const CreateServiceNetworkServiceAssociationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&VPCLatticeClient::CreateServiceNetworkServiceAssociation, request, handler, context);
        }
 
        virtual Model::CreateServiceNetworkVpcAssociationOutcome CreateServiceNetworkVpcAssociation(const Model::CreateServiceNetworkVpcAssociationRequest& request) const;
 
        template<typename CreateServiceNetworkVpcAssociationRequestT = Model::CreateServiceNetworkVpcAssociationRequest>
        Model::CreateServiceNetworkVpcAssociationOutcomeCallable CreateServiceNetworkVpcAssociationCallable(const CreateServiceNetworkVpcAssociationRequestT& request) const
        {
            return SubmitCallable(&VPCLatticeClient::CreateServiceNetworkVpcAssociation, request);
        }
 
        template<typename CreateServiceNetworkVpcAssociationRequestT = Model::CreateServiceNetworkVpcAssociationRequest>
        void CreateServiceNetworkVpcAssociationAsync(const CreateServiceNetworkVpcAssociationRequestT& request, const CreateServiceNetworkVpcAssociationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&VPCLatticeClient::CreateServiceNetworkVpcAssociation, 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(&VPCLatticeClient::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(&VPCLatticeClient::CreateTargetGroup, request, handler, context);
        }
 
        virtual Model::DeleteAccessLogSubscriptionOutcome DeleteAccessLogSubscription(const Model::DeleteAccessLogSubscriptionRequest& request) const;
 
        template<typename DeleteAccessLogSubscriptionRequestT = Model::DeleteAccessLogSubscriptionRequest>
        Model::DeleteAccessLogSubscriptionOutcomeCallable DeleteAccessLogSubscriptionCallable(const DeleteAccessLogSubscriptionRequestT& request) const
        {
            return SubmitCallable(&VPCLatticeClient::DeleteAccessLogSubscription, request);
        }
 
        template<typename DeleteAccessLogSubscriptionRequestT = Model::DeleteAccessLogSubscriptionRequest>
        void DeleteAccessLogSubscriptionAsync(const DeleteAccessLogSubscriptionRequestT& request, const DeleteAccessLogSubscriptionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&VPCLatticeClient::DeleteAccessLogSubscription, request, handler, context);
        }
 
        virtual Model::DeleteAuthPolicyOutcome DeleteAuthPolicy(const Model::DeleteAuthPolicyRequest& request) const;
 
        template<typename DeleteAuthPolicyRequestT = Model::DeleteAuthPolicyRequest>
        Model::DeleteAuthPolicyOutcomeCallable DeleteAuthPolicyCallable(const DeleteAuthPolicyRequestT& request) const
        {
            return SubmitCallable(&VPCLatticeClient::DeleteAuthPolicy, request);
        }
 
        template<typename DeleteAuthPolicyRequestT = Model::DeleteAuthPolicyRequest>
        void DeleteAuthPolicyAsync(const DeleteAuthPolicyRequestT& request, const DeleteAuthPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&VPCLatticeClient::DeleteAuthPolicy, 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(&VPCLatticeClient::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(&VPCLatticeClient::DeleteListener, request, handler, context);
        }
 
        virtual Model::DeleteResourcePolicyOutcome DeleteResourcePolicy(const Model::DeleteResourcePolicyRequest& request) const;
 
        template<typename DeleteResourcePolicyRequestT = Model::DeleteResourcePolicyRequest>
        Model::DeleteResourcePolicyOutcomeCallable DeleteResourcePolicyCallable(const DeleteResourcePolicyRequestT& request) const
        {
            return SubmitCallable(&VPCLatticeClient::DeleteResourcePolicy, request);
        }
 
        template<typename DeleteResourcePolicyRequestT = Model::DeleteResourcePolicyRequest>
        void DeleteResourcePolicyAsync(const DeleteResourcePolicyRequestT& request, const DeleteResourcePolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&VPCLatticeClient::DeleteResourcePolicy, 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(&VPCLatticeClient::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(&VPCLatticeClient::DeleteRule, request, handler, context);
        }
 
        virtual Model::DeleteServiceOutcome DeleteService(const Model::DeleteServiceRequest& request) const;
 
        template<typename DeleteServiceRequestT = Model::DeleteServiceRequest>
        Model::DeleteServiceOutcomeCallable DeleteServiceCallable(const DeleteServiceRequestT& request) const
        {
            return SubmitCallable(&VPCLatticeClient::DeleteService, request);
        }
 
        template<typename DeleteServiceRequestT = Model::DeleteServiceRequest>
        void DeleteServiceAsync(const DeleteServiceRequestT& request, const DeleteServiceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&VPCLatticeClient::DeleteService, request, handler, context);
        }
 
        virtual Model::DeleteServiceNetworkOutcome DeleteServiceNetwork(const Model::DeleteServiceNetworkRequest& request) const;
 
        template<typename DeleteServiceNetworkRequestT = Model::DeleteServiceNetworkRequest>
        Model::DeleteServiceNetworkOutcomeCallable DeleteServiceNetworkCallable(const DeleteServiceNetworkRequestT& request) const
        {
            return SubmitCallable(&VPCLatticeClient::DeleteServiceNetwork, request);
        }
 
        template<typename DeleteServiceNetworkRequestT = Model::DeleteServiceNetworkRequest>
        void DeleteServiceNetworkAsync(const DeleteServiceNetworkRequestT& request, const DeleteServiceNetworkResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&VPCLatticeClient::DeleteServiceNetwork, request, handler, context);
        }
 
        virtual Model::DeleteServiceNetworkServiceAssociationOutcome DeleteServiceNetworkServiceAssociation(const Model::DeleteServiceNetworkServiceAssociationRequest& request) const;
 
        template<typename DeleteServiceNetworkServiceAssociationRequestT = Model::DeleteServiceNetworkServiceAssociationRequest>
        Model::DeleteServiceNetworkServiceAssociationOutcomeCallable DeleteServiceNetworkServiceAssociationCallable(const DeleteServiceNetworkServiceAssociationRequestT& request) const
        {
            return SubmitCallable(&VPCLatticeClient::DeleteServiceNetworkServiceAssociation, request);
        }
 
        template<typename DeleteServiceNetworkServiceAssociationRequestT = Model::DeleteServiceNetworkServiceAssociationRequest>
        void DeleteServiceNetworkServiceAssociationAsync(const DeleteServiceNetworkServiceAssociationRequestT& request, const DeleteServiceNetworkServiceAssociationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&VPCLatticeClient::DeleteServiceNetworkServiceAssociation, request, handler, context);
        }
 
        virtual Model::DeleteServiceNetworkVpcAssociationOutcome DeleteServiceNetworkVpcAssociation(const Model::DeleteServiceNetworkVpcAssociationRequest& request) const;
 
        template<typename DeleteServiceNetworkVpcAssociationRequestT = Model::DeleteServiceNetworkVpcAssociationRequest>
        Model::DeleteServiceNetworkVpcAssociationOutcomeCallable DeleteServiceNetworkVpcAssociationCallable(const DeleteServiceNetworkVpcAssociationRequestT& request) const
        {
            return SubmitCallable(&VPCLatticeClient::DeleteServiceNetworkVpcAssociation, request);
        }
 
        template<typename DeleteServiceNetworkVpcAssociationRequestT = Model::DeleteServiceNetworkVpcAssociationRequest>
        void DeleteServiceNetworkVpcAssociationAsync(const DeleteServiceNetworkVpcAssociationRequestT& request, const DeleteServiceNetworkVpcAssociationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&VPCLatticeClient::DeleteServiceNetworkVpcAssociation, 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(&VPCLatticeClient::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(&VPCLatticeClient::DeleteTargetGroup, 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(&VPCLatticeClient::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(&VPCLatticeClient::DeregisterTargets, request, handler, context);
        }
 
        virtual Model::GetAccessLogSubscriptionOutcome GetAccessLogSubscription(const Model::GetAccessLogSubscriptionRequest& request) const;
 
        template<typename GetAccessLogSubscriptionRequestT = Model::GetAccessLogSubscriptionRequest>
        Model::GetAccessLogSubscriptionOutcomeCallable GetAccessLogSubscriptionCallable(const GetAccessLogSubscriptionRequestT& request) const
        {
            return SubmitCallable(&VPCLatticeClient::GetAccessLogSubscription, request);
        }
 
        template<typename GetAccessLogSubscriptionRequestT = Model::GetAccessLogSubscriptionRequest>
        void GetAccessLogSubscriptionAsync(const GetAccessLogSubscriptionRequestT& request, const GetAccessLogSubscriptionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&VPCLatticeClient::GetAccessLogSubscription, request, handler, context);
        }
 
        virtual Model::GetAuthPolicyOutcome GetAuthPolicy(const Model::GetAuthPolicyRequest& request) const;
 
        template<typename GetAuthPolicyRequestT = Model::GetAuthPolicyRequest>
        Model::GetAuthPolicyOutcomeCallable GetAuthPolicyCallable(const GetAuthPolicyRequestT& request) const
        {
            return SubmitCallable(&VPCLatticeClient::GetAuthPolicy, request);
        }
 
        template<typename GetAuthPolicyRequestT = Model::GetAuthPolicyRequest>
        void GetAuthPolicyAsync(const GetAuthPolicyRequestT& request, const GetAuthPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&VPCLatticeClient::GetAuthPolicy, request, handler, context);
        }
 
        virtual Model::GetListenerOutcome GetListener(const Model::GetListenerRequest& request) const;
 
        template<typename GetListenerRequestT = Model::GetListenerRequest>
        Model::GetListenerOutcomeCallable GetListenerCallable(const GetListenerRequestT& request) const
        {
            return SubmitCallable(&VPCLatticeClient::GetListener, request);
        }
 
        template<typename GetListenerRequestT = Model::GetListenerRequest>
        void GetListenerAsync(const GetListenerRequestT& request, const GetListenerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&VPCLatticeClient::GetListener, 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(&VPCLatticeClient::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(&VPCLatticeClient::GetResourcePolicy, request, handler, context);
        }
 
        virtual Model::GetRuleOutcome GetRule(const Model::GetRuleRequest& request) const;
 
        template<typename GetRuleRequestT = Model::GetRuleRequest>
        Model::GetRuleOutcomeCallable GetRuleCallable(const GetRuleRequestT& request) const
        {
            return SubmitCallable(&VPCLatticeClient::GetRule, request);
        }
 
        template<typename GetRuleRequestT = Model::GetRuleRequest>
        void GetRuleAsync(const GetRuleRequestT& request, const GetRuleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&VPCLatticeClient::GetRule, request, handler, context);
        }
 
        virtual Model::GetServiceOutcome GetService(const Model::GetServiceRequest& request) const;
 
        template<typename GetServiceRequestT = Model::GetServiceRequest>
        Model::GetServiceOutcomeCallable GetServiceCallable(const GetServiceRequestT& request) const
        {
            return SubmitCallable(&VPCLatticeClient::GetService, request);
        }
 
        template<typename GetServiceRequestT = Model::GetServiceRequest>
        void GetServiceAsync(const GetServiceRequestT& request, const GetServiceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&VPCLatticeClient::GetService, request, handler, context);
        }
 
        virtual Model::GetServiceNetworkOutcome GetServiceNetwork(const Model::GetServiceNetworkRequest& request) const;
 
        template<typename GetServiceNetworkRequestT = Model::GetServiceNetworkRequest>
        Model::GetServiceNetworkOutcomeCallable GetServiceNetworkCallable(const GetServiceNetworkRequestT& request) const
        {
            return SubmitCallable(&VPCLatticeClient::GetServiceNetwork, request);
        }
 
        template<typename GetServiceNetworkRequestT = Model::GetServiceNetworkRequest>
        void GetServiceNetworkAsync(const GetServiceNetworkRequestT& request, const GetServiceNetworkResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&VPCLatticeClient::GetServiceNetwork, request, handler, context);
        }
 
        virtual Model::GetServiceNetworkServiceAssociationOutcome GetServiceNetworkServiceAssociation(const Model::GetServiceNetworkServiceAssociationRequest& request) const;
 
        template<typename GetServiceNetworkServiceAssociationRequestT = Model::GetServiceNetworkServiceAssociationRequest>
        Model::GetServiceNetworkServiceAssociationOutcomeCallable GetServiceNetworkServiceAssociationCallable(const GetServiceNetworkServiceAssociationRequestT& request) const
        {
            return SubmitCallable(&VPCLatticeClient::GetServiceNetworkServiceAssociation, request);
        }
 
        template<typename GetServiceNetworkServiceAssociationRequestT = Model::GetServiceNetworkServiceAssociationRequest>
        void GetServiceNetworkServiceAssociationAsync(const GetServiceNetworkServiceAssociationRequestT& request, const GetServiceNetworkServiceAssociationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&VPCLatticeClient::GetServiceNetworkServiceAssociation, request, handler, context);
        }
 
        virtual Model::GetServiceNetworkVpcAssociationOutcome GetServiceNetworkVpcAssociation(const Model::GetServiceNetworkVpcAssociationRequest& request) const;
 
        template<typename GetServiceNetworkVpcAssociationRequestT = Model::GetServiceNetworkVpcAssociationRequest>
        Model::GetServiceNetworkVpcAssociationOutcomeCallable GetServiceNetworkVpcAssociationCallable(const GetServiceNetworkVpcAssociationRequestT& request) const
        {
            return SubmitCallable(&VPCLatticeClient::GetServiceNetworkVpcAssociation, request);
        }
 
        template<typename GetServiceNetworkVpcAssociationRequestT = Model::GetServiceNetworkVpcAssociationRequest>
        void GetServiceNetworkVpcAssociationAsync(const GetServiceNetworkVpcAssociationRequestT& request, const GetServiceNetworkVpcAssociationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&VPCLatticeClient::GetServiceNetworkVpcAssociation, request, handler, context);
        }
 
        virtual Model::GetTargetGroupOutcome GetTargetGroup(const Model::GetTargetGroupRequest& request) const;
 
        template<typename GetTargetGroupRequestT = Model::GetTargetGroupRequest>
        Model::GetTargetGroupOutcomeCallable GetTargetGroupCallable(const GetTargetGroupRequestT& request) const
        {
            return SubmitCallable(&VPCLatticeClient::GetTargetGroup, request);
        }
 
        template<typename GetTargetGroupRequestT = Model::GetTargetGroupRequest>
        void GetTargetGroupAsync(const GetTargetGroupRequestT& request, const GetTargetGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&VPCLatticeClient::GetTargetGroup, request, handler, context);
        }
 
        virtual Model::ListAccessLogSubscriptionsOutcome ListAccessLogSubscriptions(const Model::ListAccessLogSubscriptionsRequest& request) const;
 
        template<typename ListAccessLogSubscriptionsRequestT = Model::ListAccessLogSubscriptionsRequest>
        Model::ListAccessLogSubscriptionsOutcomeCallable ListAccessLogSubscriptionsCallable(const ListAccessLogSubscriptionsRequestT& request) const
        {
            return SubmitCallable(&VPCLatticeClient::ListAccessLogSubscriptions, request);
        }
 
        template<typename ListAccessLogSubscriptionsRequestT = Model::ListAccessLogSubscriptionsRequest>
        void ListAccessLogSubscriptionsAsync(const ListAccessLogSubscriptionsRequestT& request, const ListAccessLogSubscriptionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&VPCLatticeClient::ListAccessLogSubscriptions, request, handler, context);
        }
 
        virtual Model::ListListenersOutcome ListListeners(const Model::ListListenersRequest& request) const;
 
        template<typename ListListenersRequestT = Model::ListListenersRequest>
        Model::ListListenersOutcomeCallable ListListenersCallable(const ListListenersRequestT& request) const
        {
            return SubmitCallable(&VPCLatticeClient::ListListeners, request);
        }
 
        template<typename ListListenersRequestT = Model::ListListenersRequest>
        void ListListenersAsync(const ListListenersRequestT& request, const ListListenersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&VPCLatticeClient::ListListeners, request, handler, context);
        }
 
        virtual Model::ListRulesOutcome ListRules(const Model::ListRulesRequest& request) const;
 
        template<typename ListRulesRequestT = Model::ListRulesRequest>
        Model::ListRulesOutcomeCallable ListRulesCallable(const ListRulesRequestT& request) const
        {
            return SubmitCallable(&VPCLatticeClient::ListRules, request);
        }
 
        template<typename ListRulesRequestT = Model::ListRulesRequest>
        void ListRulesAsync(const ListRulesRequestT& request, const ListRulesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&VPCLatticeClient::ListRules, request, handler, context);
        }
 
        virtual Model::ListServiceNetworkServiceAssociationsOutcome ListServiceNetworkServiceAssociations(const Model::ListServiceNetworkServiceAssociationsRequest& request = {}) const;
 
        template<typename ListServiceNetworkServiceAssociationsRequestT = Model::ListServiceNetworkServiceAssociationsRequest>
        Model::ListServiceNetworkServiceAssociationsOutcomeCallable ListServiceNetworkServiceAssociationsCallable(const ListServiceNetworkServiceAssociationsRequestT& request = {}) const
        {
            return SubmitCallable(&VPCLatticeClient::ListServiceNetworkServiceAssociations, request);
        }
 
        template<typename ListServiceNetworkServiceAssociationsRequestT = Model::ListServiceNetworkServiceAssociationsRequest>
        void ListServiceNetworkServiceAssociationsAsync(const ListServiceNetworkServiceAssociationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListServiceNetworkServiceAssociationsRequestT& request = {}) const
        {
            return SubmitAsync(&VPCLatticeClient::ListServiceNetworkServiceAssociations, request, handler, context);
        }
 
        virtual Model::ListServiceNetworkVpcAssociationsOutcome ListServiceNetworkVpcAssociations(const Model::ListServiceNetworkVpcAssociationsRequest& request = {}) const;
 
        template<typename ListServiceNetworkVpcAssociationsRequestT = Model::ListServiceNetworkVpcAssociationsRequest>
        Model::ListServiceNetworkVpcAssociationsOutcomeCallable ListServiceNetworkVpcAssociationsCallable(const ListServiceNetworkVpcAssociationsRequestT& request = {}) const
        {
            return SubmitCallable(&VPCLatticeClient::ListServiceNetworkVpcAssociations, request);
        }
 
        template<typename ListServiceNetworkVpcAssociationsRequestT = Model::ListServiceNetworkVpcAssociationsRequest>
        void ListServiceNetworkVpcAssociationsAsync(const ListServiceNetworkVpcAssociationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListServiceNetworkVpcAssociationsRequestT& request = {}) const
        {
            return SubmitAsync(&VPCLatticeClient::ListServiceNetworkVpcAssociations, request, handler, context);
        }
 
        virtual Model::ListServiceNetworksOutcome ListServiceNetworks(const Model::ListServiceNetworksRequest& request = {}) const;
 
        template<typename ListServiceNetworksRequestT = Model::ListServiceNetworksRequest>
        Model::ListServiceNetworksOutcomeCallable ListServiceNetworksCallable(const ListServiceNetworksRequestT& request = {}) const
        {
            return SubmitCallable(&VPCLatticeClient::ListServiceNetworks, request);
        }
 
        template<typename ListServiceNetworksRequestT = Model::ListServiceNetworksRequest>
        void ListServiceNetworksAsync(const ListServiceNetworksResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListServiceNetworksRequestT& request = {}) const
        {
            return SubmitAsync(&VPCLatticeClient::ListServiceNetworks, request, handler, context);
        }
 
        virtual Model::ListServicesOutcome ListServices(const Model::ListServicesRequest& request = {}) const;
 
        template<typename ListServicesRequestT = Model::ListServicesRequest>
        Model::ListServicesOutcomeCallable ListServicesCallable(const ListServicesRequestT& request = {}) const
        {
            return SubmitCallable(&VPCLatticeClient::ListServices, request);
        }
 
        template<typename ListServicesRequestT = Model::ListServicesRequest>
        void ListServicesAsync(const ListServicesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListServicesRequestT& request = {}) const
        {
            return SubmitAsync(&VPCLatticeClient::ListServices, request, handler, context);
        }
 
        virtual Model::ListTagsForResourceOutcome ListTagsForResource(const Model::ListTagsForResourceRequest& request) const;
 
        template<typename ListTagsForResourceRequestT = Model::ListTagsForResourceRequest>
        Model::ListTagsForResourceOutcomeCallable ListTagsForResourceCallable(const ListTagsForResourceRequestT& request) const
        {
            return SubmitCallable(&VPCLatticeClient::ListTagsForResource, request);
        }
 
        template<typename ListTagsForResourceRequestT = Model::ListTagsForResourceRequest>
        void ListTagsForResourceAsync(const ListTagsForResourceRequestT& request, const ListTagsForResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&VPCLatticeClient::ListTagsForResource, request, handler, context);
        }
 
        virtual Model::ListTargetGroupsOutcome ListTargetGroups(const Model::ListTargetGroupsRequest& request = {}) const;
 
        template<typename ListTargetGroupsRequestT = Model::ListTargetGroupsRequest>
        Model::ListTargetGroupsOutcomeCallable ListTargetGroupsCallable(const ListTargetGroupsRequestT& request = {}) const
        {
            return SubmitCallable(&VPCLatticeClient::ListTargetGroups, request);
        }
 
        template<typename ListTargetGroupsRequestT = Model::ListTargetGroupsRequest>
        void ListTargetGroupsAsync(const ListTargetGroupsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListTargetGroupsRequestT& request = {}) const
        {
            return SubmitAsync(&VPCLatticeClient::ListTargetGroups, request, handler, context);
        }
 
        virtual Model::ListTargetsOutcome ListTargets(const Model::ListTargetsRequest& request) const;
 
        template<typename ListTargetsRequestT = Model::ListTargetsRequest>
        Model::ListTargetsOutcomeCallable ListTargetsCallable(const ListTargetsRequestT& request) const
        {
            return SubmitCallable(&VPCLatticeClient::ListTargets, request);
        }
 
        template<typename ListTargetsRequestT = Model::ListTargetsRequest>
        void ListTargetsAsync(const ListTargetsRequestT& request, const ListTargetsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&VPCLatticeClient::ListTargets, request, handler, context);
        }
 
        virtual Model::PutAuthPolicyOutcome PutAuthPolicy(const Model::PutAuthPolicyRequest& request) const;
 
        template<typename PutAuthPolicyRequestT = Model::PutAuthPolicyRequest>
        Model::PutAuthPolicyOutcomeCallable PutAuthPolicyCallable(const PutAuthPolicyRequestT& request) const
        {
            return SubmitCallable(&VPCLatticeClient::PutAuthPolicy, request);
        }
 
        template<typename PutAuthPolicyRequestT = Model::PutAuthPolicyRequest>
        void PutAuthPolicyAsync(const PutAuthPolicyRequestT& request, const PutAuthPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&VPCLatticeClient::PutAuthPolicy, request, handler, context);
        }
 
        virtual Model::PutResourcePolicyOutcome PutResourcePolicy(const Model::PutResourcePolicyRequest& request) const;
 
        template<typename PutResourcePolicyRequestT = Model::PutResourcePolicyRequest>
        Model::PutResourcePolicyOutcomeCallable PutResourcePolicyCallable(const PutResourcePolicyRequestT& request) const
        {
            return SubmitCallable(&VPCLatticeClient::PutResourcePolicy, request);
        }
 
        template<typename PutResourcePolicyRequestT = Model::PutResourcePolicyRequest>
        void PutResourcePolicyAsync(const PutResourcePolicyRequestT& request, const PutResourcePolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&VPCLatticeClient::PutResourcePolicy, 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(&VPCLatticeClient::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(&VPCLatticeClient::RegisterTargets, request, handler, context);
        }
 
        virtual Model::TagResourceOutcome TagResource(const Model::TagResourceRequest& request) const;
 
        template<typename TagResourceRequestT = Model::TagResourceRequest>
        Model::TagResourceOutcomeCallable TagResourceCallable(const TagResourceRequestT& request) const
        {
            return SubmitCallable(&VPCLatticeClient::TagResource, request);
        }
 
        template<typename TagResourceRequestT = Model::TagResourceRequest>
        void TagResourceAsync(const TagResourceRequestT& request, const TagResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&VPCLatticeClient::TagResource, request, handler, context);
        }
 
        virtual Model::UntagResourceOutcome UntagResource(const Model::UntagResourceRequest& request) const;
 
        template<typename UntagResourceRequestT = Model::UntagResourceRequest>
        Model::UntagResourceOutcomeCallable UntagResourceCallable(const UntagResourceRequestT& request) const
        {
            return SubmitCallable(&VPCLatticeClient::UntagResource, request);
        }
 
        template<typename UntagResourceRequestT = Model::UntagResourceRequest>
        void UntagResourceAsync(const UntagResourceRequestT& request, const UntagResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&VPCLatticeClient::UntagResource, request, handler, context);
        }
 
        virtual Model::UpdateAccessLogSubscriptionOutcome UpdateAccessLogSubscription(const Model::UpdateAccessLogSubscriptionRequest& request) const;
 
        template<typename UpdateAccessLogSubscriptionRequestT = Model::UpdateAccessLogSubscriptionRequest>
        Model::UpdateAccessLogSubscriptionOutcomeCallable UpdateAccessLogSubscriptionCallable(const UpdateAccessLogSubscriptionRequestT& request) const
        {
            return SubmitCallable(&VPCLatticeClient::UpdateAccessLogSubscription, request);
        }
 
        template<typename UpdateAccessLogSubscriptionRequestT = Model::UpdateAccessLogSubscriptionRequest>
        void UpdateAccessLogSubscriptionAsync(const UpdateAccessLogSubscriptionRequestT& request, const UpdateAccessLogSubscriptionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&VPCLatticeClient::UpdateAccessLogSubscription, request, handler, context);
        }
 
        virtual Model::UpdateListenerOutcome UpdateListener(const Model::UpdateListenerRequest& request) const;
 
        template<typename UpdateListenerRequestT = Model::UpdateListenerRequest>
        Model::UpdateListenerOutcomeCallable UpdateListenerCallable(const UpdateListenerRequestT& request) const
        {
            return SubmitCallable(&VPCLatticeClient::UpdateListener, request);
        }
 
        template<typename UpdateListenerRequestT = Model::UpdateListenerRequest>
        void UpdateListenerAsync(const UpdateListenerRequestT& request, const UpdateListenerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&VPCLatticeClient::UpdateListener, request, handler, context);
        }
 
        virtual Model::UpdateRuleOutcome UpdateRule(const Model::UpdateRuleRequest& request) const;
 
        template<typename UpdateRuleRequestT = Model::UpdateRuleRequest>
        Model::UpdateRuleOutcomeCallable UpdateRuleCallable(const UpdateRuleRequestT& request) const
        {
            return SubmitCallable(&VPCLatticeClient::UpdateRule, request);
        }
 
        template<typename UpdateRuleRequestT = Model::UpdateRuleRequest>
        void UpdateRuleAsync(const UpdateRuleRequestT& request, const UpdateRuleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&VPCLatticeClient::UpdateRule, request, handler, context);
        }
 
        virtual Model::UpdateServiceOutcome UpdateService(const Model::UpdateServiceRequest& request) const;
 
        template<typename UpdateServiceRequestT = Model::UpdateServiceRequest>
        Model::UpdateServiceOutcomeCallable UpdateServiceCallable(const UpdateServiceRequestT& request) const
        {
            return SubmitCallable(&VPCLatticeClient::UpdateService, request);
        }
 
        template<typename UpdateServiceRequestT = Model::UpdateServiceRequest>
        void UpdateServiceAsync(const UpdateServiceRequestT& request, const UpdateServiceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&VPCLatticeClient::UpdateService, request, handler, context);
        }
 
        virtual Model::UpdateServiceNetworkOutcome UpdateServiceNetwork(const Model::UpdateServiceNetworkRequest& request) const;
 
        template<typename UpdateServiceNetworkRequestT = Model::UpdateServiceNetworkRequest>
        Model::UpdateServiceNetworkOutcomeCallable UpdateServiceNetworkCallable(const UpdateServiceNetworkRequestT& request) const
        {
            return SubmitCallable(&VPCLatticeClient::UpdateServiceNetwork, request);
        }
 
        template<typename UpdateServiceNetworkRequestT = Model::UpdateServiceNetworkRequest>
        void UpdateServiceNetworkAsync(const UpdateServiceNetworkRequestT& request, const UpdateServiceNetworkResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&VPCLatticeClient::UpdateServiceNetwork, request, handler, context);
        }
 
        virtual Model::UpdateServiceNetworkVpcAssociationOutcome UpdateServiceNetworkVpcAssociation(const Model::UpdateServiceNetworkVpcAssociationRequest& request) const;
 
        template<typename UpdateServiceNetworkVpcAssociationRequestT = Model::UpdateServiceNetworkVpcAssociationRequest>
        Model::UpdateServiceNetworkVpcAssociationOutcomeCallable UpdateServiceNetworkVpcAssociationCallable(const UpdateServiceNetworkVpcAssociationRequestT& request) const
        {
            return SubmitCallable(&VPCLatticeClient::UpdateServiceNetworkVpcAssociation, request);
        }
 
        template<typename UpdateServiceNetworkVpcAssociationRequestT = Model::UpdateServiceNetworkVpcAssociationRequest>
        void UpdateServiceNetworkVpcAssociationAsync(const UpdateServiceNetworkVpcAssociationRequestT& request, const UpdateServiceNetworkVpcAssociationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&VPCLatticeClient::UpdateServiceNetworkVpcAssociation, request, handler, context);
        }
 
        virtual Model::UpdateTargetGroupOutcome UpdateTargetGroup(const Model::UpdateTargetGroupRequest& request) const;
 
        template<typename UpdateTargetGroupRequestT = Model::UpdateTargetGroupRequest>
        Model::UpdateTargetGroupOutcomeCallable UpdateTargetGroupCallable(const UpdateTargetGroupRequestT& request) const
        {
            return SubmitCallable(&VPCLatticeClient::UpdateTargetGroup, request);
        }
 
        template<typename UpdateTargetGroupRequestT = Model::UpdateTargetGroupRequest>
        void UpdateTargetGroupAsync(const UpdateTargetGroupRequestT& request, const UpdateTargetGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&VPCLatticeClient::UpdateTargetGroup, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<VPCLatticeEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<VPCLatticeClient>;
      void init(const VPCLatticeClientConfiguration& clientConfiguration);
 
      VPCLatticeClientConfiguration m_clientConfiguration;
      std::shared_ptr<VPCLatticeEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace VPCLattice
} // namespace Aws