EKSClient.h

 
#pragma once
#include <aws/eks/EKS_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/eks/EKSServiceClientModel.h>
 
namespace Aws
{
namespace EKS
{
  class AWS_EKS_API EKSClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<EKSClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef EKSClientConfiguration ClientConfigurationType;
      typedef EKSEndpointProvider EndpointProviderType;
 
        EKSClient(const Aws::EKS::EKSClientConfiguration& clientConfiguration = Aws::EKS::EKSClientConfiguration(),
                  std::shared_ptr<EKSEndpointProviderBase> endpointProvider = nullptr);
 
        EKSClient(const Aws::Auth::AWSCredentials& credentials,
                  std::shared_ptr<EKSEndpointProviderBase> endpointProvider = nullptr,
                  const Aws::EKS::EKSClientConfiguration& clientConfiguration = Aws::EKS::EKSClientConfiguration());
 
        EKSClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                  std::shared_ptr<EKSEndpointProviderBase> endpointProvider = nullptr,
                  const Aws::EKS::EKSClientConfiguration& clientConfiguration = Aws::EKS::EKSClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        EKSClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        EKSClient(const Aws::Auth::AWSCredentials& credentials,
                  const Aws::Client::ClientConfiguration& clientConfiguration);
 
        EKSClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                  const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~EKSClient();
 
        virtual Model::AssociateAccessPolicyOutcome AssociateAccessPolicy(const Model::AssociateAccessPolicyRequest& request) const;
 
        template<typename AssociateAccessPolicyRequestT = Model::AssociateAccessPolicyRequest>
        Model::AssociateAccessPolicyOutcomeCallable AssociateAccessPolicyCallable(const AssociateAccessPolicyRequestT& request) const
        {
            return SubmitCallable(&EKSClient::AssociateAccessPolicy, request);
        }
 
        template<typename AssociateAccessPolicyRequestT = Model::AssociateAccessPolicyRequest>
        void AssociateAccessPolicyAsync(const AssociateAccessPolicyRequestT& request, const AssociateAccessPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&EKSClient::AssociateAccessPolicy, request, handler, context);
        }
 
        virtual Model::AssociateEncryptionConfigOutcome AssociateEncryptionConfig(const Model::AssociateEncryptionConfigRequest& request) const;
 
        template<typename AssociateEncryptionConfigRequestT = Model::AssociateEncryptionConfigRequest>
        Model::AssociateEncryptionConfigOutcomeCallable AssociateEncryptionConfigCallable(const AssociateEncryptionConfigRequestT& request) const
        {
            return SubmitCallable(&EKSClient::AssociateEncryptionConfig, request);
        }
 
        template<typename AssociateEncryptionConfigRequestT = Model::AssociateEncryptionConfigRequest>
        void AssociateEncryptionConfigAsync(const AssociateEncryptionConfigRequestT& request, const AssociateEncryptionConfigResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&EKSClient::AssociateEncryptionConfig, request, handler, context);
        }
 
        virtual Model::AssociateIdentityProviderConfigOutcome AssociateIdentityProviderConfig(const Model::AssociateIdentityProviderConfigRequest& request) const;
 
        template<typename AssociateIdentityProviderConfigRequestT = Model::AssociateIdentityProviderConfigRequest>
        Model::AssociateIdentityProviderConfigOutcomeCallable AssociateIdentityProviderConfigCallable(const AssociateIdentityProviderConfigRequestT& request) const
        {
            return SubmitCallable(&EKSClient::AssociateIdentityProviderConfig, request);
        }
 
        template<typename AssociateIdentityProviderConfigRequestT = Model::AssociateIdentityProviderConfigRequest>
        void AssociateIdentityProviderConfigAsync(const AssociateIdentityProviderConfigRequestT& request, const AssociateIdentityProviderConfigResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&EKSClient::AssociateIdentityProviderConfig, request, handler, context);
        }
 
        virtual Model::CreateAccessEntryOutcome CreateAccessEntry(const Model::CreateAccessEntryRequest& request) const;
 
        template<typename CreateAccessEntryRequestT = Model::CreateAccessEntryRequest>
        Model::CreateAccessEntryOutcomeCallable CreateAccessEntryCallable(const CreateAccessEntryRequestT& request) const
        {
            return SubmitCallable(&EKSClient::CreateAccessEntry, request);
        }
 
        template<typename CreateAccessEntryRequestT = Model::CreateAccessEntryRequest>
        void CreateAccessEntryAsync(const CreateAccessEntryRequestT& request, const CreateAccessEntryResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&EKSClient::CreateAccessEntry, request, handler, context);
        }
 
        virtual Model::CreateAddonOutcome CreateAddon(const Model::CreateAddonRequest& request) const;
 
        template<typename CreateAddonRequestT = Model::CreateAddonRequest>
        Model::CreateAddonOutcomeCallable CreateAddonCallable(const CreateAddonRequestT& request) const
        {
            return SubmitCallable(&EKSClient::CreateAddon, request);
        }
 
        template<typename CreateAddonRequestT = Model::CreateAddonRequest>
        void CreateAddonAsync(const CreateAddonRequestT& request, const CreateAddonResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&EKSClient::CreateAddon, request, handler, context);
        }
 
        virtual Model::CreateClusterOutcome CreateCluster(const Model::CreateClusterRequest& request) const;
 
        template<typename CreateClusterRequestT = Model::CreateClusterRequest>
        Model::CreateClusterOutcomeCallable CreateClusterCallable(const CreateClusterRequestT& request) const
        {
            return SubmitCallable(&EKSClient::CreateCluster, request);
        }
 
        template<typename CreateClusterRequestT = Model::CreateClusterRequest>
        void CreateClusterAsync(const CreateClusterRequestT& request, const CreateClusterResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&EKSClient::CreateCluster, request, handler, context);
        }
 
        virtual Model::CreateEksAnywhereSubscriptionOutcome CreateEksAnywhereSubscription(const Model::CreateEksAnywhereSubscriptionRequest& request) const;
 
        template<typename CreateEksAnywhereSubscriptionRequestT = Model::CreateEksAnywhereSubscriptionRequest>
        Model::CreateEksAnywhereSubscriptionOutcomeCallable CreateEksAnywhereSubscriptionCallable(const CreateEksAnywhereSubscriptionRequestT& request) const
        {
            return SubmitCallable(&EKSClient::CreateEksAnywhereSubscription, request);
        }
 
        template<typename CreateEksAnywhereSubscriptionRequestT = Model::CreateEksAnywhereSubscriptionRequest>
        void CreateEksAnywhereSubscriptionAsync(const CreateEksAnywhereSubscriptionRequestT& request, const CreateEksAnywhereSubscriptionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&EKSClient::CreateEksAnywhereSubscription, request, handler, context);
        }
 
        virtual Model::CreateFargateProfileOutcome CreateFargateProfile(const Model::CreateFargateProfileRequest& request) const;
 
        template<typename CreateFargateProfileRequestT = Model::CreateFargateProfileRequest>
        Model::CreateFargateProfileOutcomeCallable CreateFargateProfileCallable(const CreateFargateProfileRequestT& request) const
        {
            return SubmitCallable(&EKSClient::CreateFargateProfile, request);
        }
 
        template<typename CreateFargateProfileRequestT = Model::CreateFargateProfileRequest>
        void CreateFargateProfileAsync(const CreateFargateProfileRequestT& request, const CreateFargateProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&EKSClient::CreateFargateProfile, request, handler, context);
        }
 
        virtual Model::CreateNodegroupOutcome CreateNodegroup(const Model::CreateNodegroupRequest& request) const;
 
        template<typename CreateNodegroupRequestT = Model::CreateNodegroupRequest>
        Model::CreateNodegroupOutcomeCallable CreateNodegroupCallable(const CreateNodegroupRequestT& request) const
        {
            return SubmitCallable(&EKSClient::CreateNodegroup, request);
        }
 
        template<typename CreateNodegroupRequestT = Model::CreateNodegroupRequest>
        void CreateNodegroupAsync(const CreateNodegroupRequestT& request, const CreateNodegroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&EKSClient::CreateNodegroup, request, handler, context);
        }
 
        virtual Model::CreatePodIdentityAssociationOutcome CreatePodIdentityAssociation(const Model::CreatePodIdentityAssociationRequest& request) const;
 
        template<typename CreatePodIdentityAssociationRequestT = Model::CreatePodIdentityAssociationRequest>
        Model::CreatePodIdentityAssociationOutcomeCallable CreatePodIdentityAssociationCallable(const CreatePodIdentityAssociationRequestT& request) const
        {
            return SubmitCallable(&EKSClient::CreatePodIdentityAssociation, request);
        }
 
        template<typename CreatePodIdentityAssociationRequestT = Model::CreatePodIdentityAssociationRequest>
        void CreatePodIdentityAssociationAsync(const CreatePodIdentityAssociationRequestT& request, const CreatePodIdentityAssociationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&EKSClient::CreatePodIdentityAssociation, request, handler, context);
        }
 
        virtual Model::DeleteAccessEntryOutcome DeleteAccessEntry(const Model::DeleteAccessEntryRequest& request) const;
 
        template<typename DeleteAccessEntryRequestT = Model::DeleteAccessEntryRequest>
        Model::DeleteAccessEntryOutcomeCallable DeleteAccessEntryCallable(const DeleteAccessEntryRequestT& request) const
        {
            return SubmitCallable(&EKSClient::DeleteAccessEntry, request);
        }
 
        template<typename DeleteAccessEntryRequestT = Model::DeleteAccessEntryRequest>
        void DeleteAccessEntryAsync(const DeleteAccessEntryRequestT& request, const DeleteAccessEntryResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&EKSClient::DeleteAccessEntry, request, handler, context);
        }
 
        virtual Model::DeleteAddonOutcome DeleteAddon(const Model::DeleteAddonRequest& request) const;
 
        template<typename DeleteAddonRequestT = Model::DeleteAddonRequest>
        Model::DeleteAddonOutcomeCallable DeleteAddonCallable(const DeleteAddonRequestT& request) const
        {
            return SubmitCallable(&EKSClient::DeleteAddon, request);
        }
 
        template<typename DeleteAddonRequestT = Model::DeleteAddonRequest>
        void DeleteAddonAsync(const DeleteAddonRequestT& request, const DeleteAddonResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&EKSClient::DeleteAddon, request, handler, context);
        }
 
        virtual Model::DeleteClusterOutcome DeleteCluster(const Model::DeleteClusterRequest& request) const;
 
        template<typename DeleteClusterRequestT = Model::DeleteClusterRequest>
        Model::DeleteClusterOutcomeCallable DeleteClusterCallable(const DeleteClusterRequestT& request) const
        {
            return SubmitCallable(&EKSClient::DeleteCluster, request);
        }
 
        template<typename DeleteClusterRequestT = Model::DeleteClusterRequest>
        void DeleteClusterAsync(const DeleteClusterRequestT& request, const DeleteClusterResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&EKSClient::DeleteCluster, request, handler, context);
        }
 
        virtual Model::DeleteEksAnywhereSubscriptionOutcome DeleteEksAnywhereSubscription(const Model::DeleteEksAnywhereSubscriptionRequest& request) const;
 
        template<typename DeleteEksAnywhereSubscriptionRequestT = Model::DeleteEksAnywhereSubscriptionRequest>
        Model::DeleteEksAnywhereSubscriptionOutcomeCallable DeleteEksAnywhereSubscriptionCallable(const DeleteEksAnywhereSubscriptionRequestT& request) const
        {
            return SubmitCallable(&EKSClient::DeleteEksAnywhereSubscription, request);
        }
 
        template<typename DeleteEksAnywhereSubscriptionRequestT = Model::DeleteEksAnywhereSubscriptionRequest>
        void DeleteEksAnywhereSubscriptionAsync(const DeleteEksAnywhereSubscriptionRequestT& request, const DeleteEksAnywhereSubscriptionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&EKSClient::DeleteEksAnywhereSubscription, request, handler, context);
        }
 
        virtual Model::DeleteFargateProfileOutcome DeleteFargateProfile(const Model::DeleteFargateProfileRequest& request) const;
 
        template<typename DeleteFargateProfileRequestT = Model::DeleteFargateProfileRequest>
        Model::DeleteFargateProfileOutcomeCallable DeleteFargateProfileCallable(const DeleteFargateProfileRequestT& request) const
        {
            return SubmitCallable(&EKSClient::DeleteFargateProfile, request);
        }
 
        template<typename DeleteFargateProfileRequestT = Model::DeleteFargateProfileRequest>
        void DeleteFargateProfileAsync(const DeleteFargateProfileRequestT& request, const DeleteFargateProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&EKSClient::DeleteFargateProfile, request, handler, context);
        }
 
        virtual Model::DeleteNodegroupOutcome DeleteNodegroup(const Model::DeleteNodegroupRequest& request) const;
 
        template<typename DeleteNodegroupRequestT = Model::DeleteNodegroupRequest>
        Model::DeleteNodegroupOutcomeCallable DeleteNodegroupCallable(const DeleteNodegroupRequestT& request) const
        {
            return SubmitCallable(&EKSClient::DeleteNodegroup, request);
        }
 
        template<typename DeleteNodegroupRequestT = Model::DeleteNodegroupRequest>
        void DeleteNodegroupAsync(const DeleteNodegroupRequestT& request, const DeleteNodegroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&EKSClient::DeleteNodegroup, request, handler, context);
        }
 
        virtual Model::DeletePodIdentityAssociationOutcome DeletePodIdentityAssociation(const Model::DeletePodIdentityAssociationRequest& request) const;
 
        template<typename DeletePodIdentityAssociationRequestT = Model::DeletePodIdentityAssociationRequest>
        Model::DeletePodIdentityAssociationOutcomeCallable DeletePodIdentityAssociationCallable(const DeletePodIdentityAssociationRequestT& request) const
        {
            return SubmitCallable(&EKSClient::DeletePodIdentityAssociation, request);
        }
 
        template<typename DeletePodIdentityAssociationRequestT = Model::DeletePodIdentityAssociationRequest>
        void DeletePodIdentityAssociationAsync(const DeletePodIdentityAssociationRequestT& request, const DeletePodIdentityAssociationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&EKSClient::DeletePodIdentityAssociation, request, handler, context);
        }
 
        virtual Model::DeregisterClusterOutcome DeregisterCluster(const Model::DeregisterClusterRequest& request) const;
 
        template<typename DeregisterClusterRequestT = Model::DeregisterClusterRequest>
        Model::DeregisterClusterOutcomeCallable DeregisterClusterCallable(const DeregisterClusterRequestT& request) const
        {
            return SubmitCallable(&EKSClient::DeregisterCluster, request);
        }
 
        template<typename DeregisterClusterRequestT = Model::DeregisterClusterRequest>
        void DeregisterClusterAsync(const DeregisterClusterRequestT& request, const DeregisterClusterResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&EKSClient::DeregisterCluster, request, handler, context);
        }
 
        virtual Model::DescribeAccessEntryOutcome DescribeAccessEntry(const Model::DescribeAccessEntryRequest& request) const;
 
        template<typename DescribeAccessEntryRequestT = Model::DescribeAccessEntryRequest>
        Model::DescribeAccessEntryOutcomeCallable DescribeAccessEntryCallable(const DescribeAccessEntryRequestT& request) const
        {
            return SubmitCallable(&EKSClient::DescribeAccessEntry, request);
        }
 
        template<typename DescribeAccessEntryRequestT = Model::DescribeAccessEntryRequest>
        void DescribeAccessEntryAsync(const DescribeAccessEntryRequestT& request, const DescribeAccessEntryResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&EKSClient::DescribeAccessEntry, request, handler, context);
        }
 
        virtual Model::DescribeAddonOutcome DescribeAddon(const Model::DescribeAddonRequest& request) const;
 
        template<typename DescribeAddonRequestT = Model::DescribeAddonRequest>
        Model::DescribeAddonOutcomeCallable DescribeAddonCallable(const DescribeAddonRequestT& request) const
        {
            return SubmitCallable(&EKSClient::DescribeAddon, request);
        }
 
        template<typename DescribeAddonRequestT = Model::DescribeAddonRequest>
        void DescribeAddonAsync(const DescribeAddonRequestT& request, const DescribeAddonResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&EKSClient::DescribeAddon, request, handler, context);
        }
 
        virtual Model::DescribeAddonConfigurationOutcome DescribeAddonConfiguration(const Model::DescribeAddonConfigurationRequest& request) const;
 
        template<typename DescribeAddonConfigurationRequestT = Model::DescribeAddonConfigurationRequest>
        Model::DescribeAddonConfigurationOutcomeCallable DescribeAddonConfigurationCallable(const DescribeAddonConfigurationRequestT& request) const
        {
            return SubmitCallable(&EKSClient::DescribeAddonConfiguration, request);
        }
 
        template<typename DescribeAddonConfigurationRequestT = Model::DescribeAddonConfigurationRequest>
        void DescribeAddonConfigurationAsync(const DescribeAddonConfigurationRequestT& request, const DescribeAddonConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&EKSClient::DescribeAddonConfiguration, request, handler, context);
        }
 
        virtual Model::DescribeAddonVersionsOutcome DescribeAddonVersions(const Model::DescribeAddonVersionsRequest& request = {}) const;
 
        template<typename DescribeAddonVersionsRequestT = Model::DescribeAddonVersionsRequest>
        Model::DescribeAddonVersionsOutcomeCallable DescribeAddonVersionsCallable(const DescribeAddonVersionsRequestT& request = {}) const
        {
            return SubmitCallable(&EKSClient::DescribeAddonVersions, request);
        }
 
        template<typename DescribeAddonVersionsRequestT = Model::DescribeAddonVersionsRequest>
        void DescribeAddonVersionsAsync(const DescribeAddonVersionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeAddonVersionsRequestT& request = {}) const
        {
            return SubmitAsync(&EKSClient::DescribeAddonVersions, request, handler, context);
        }
 
        virtual Model::DescribeClusterOutcome DescribeCluster(const Model::DescribeClusterRequest& request) const;
 
        template<typename DescribeClusterRequestT = Model::DescribeClusterRequest>
        Model::DescribeClusterOutcomeCallable DescribeClusterCallable(const DescribeClusterRequestT& request) const
        {
            return SubmitCallable(&EKSClient::DescribeCluster, request);
        }
 
        template<typename DescribeClusterRequestT = Model::DescribeClusterRequest>
        void DescribeClusterAsync(const DescribeClusterRequestT& request, const DescribeClusterResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&EKSClient::DescribeCluster, request, handler, context);
        }
 
        virtual Model::DescribeClusterVersionsOutcome DescribeClusterVersions(const Model::DescribeClusterVersionsRequest& request = {}) const;
 
        template<typename DescribeClusterVersionsRequestT = Model::DescribeClusterVersionsRequest>
        Model::DescribeClusterVersionsOutcomeCallable DescribeClusterVersionsCallable(const DescribeClusterVersionsRequestT& request = {}) const
        {
            return SubmitCallable(&EKSClient::DescribeClusterVersions, request);
        }
 
        template<typename DescribeClusterVersionsRequestT = Model::DescribeClusterVersionsRequest>
        void DescribeClusterVersionsAsync(const DescribeClusterVersionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeClusterVersionsRequestT& request = {}) const
        {
            return SubmitAsync(&EKSClient::DescribeClusterVersions, request, handler, context);
        }
 
        virtual Model::DescribeEksAnywhereSubscriptionOutcome DescribeEksAnywhereSubscription(const Model::DescribeEksAnywhereSubscriptionRequest& request) const;
 
        template<typename DescribeEksAnywhereSubscriptionRequestT = Model::DescribeEksAnywhereSubscriptionRequest>
        Model::DescribeEksAnywhereSubscriptionOutcomeCallable DescribeEksAnywhereSubscriptionCallable(const DescribeEksAnywhereSubscriptionRequestT& request) const
        {
            return SubmitCallable(&EKSClient::DescribeEksAnywhereSubscription, request);
        }
 
        template<typename DescribeEksAnywhereSubscriptionRequestT = Model::DescribeEksAnywhereSubscriptionRequest>
        void DescribeEksAnywhereSubscriptionAsync(const DescribeEksAnywhereSubscriptionRequestT& request, const DescribeEksAnywhereSubscriptionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&EKSClient::DescribeEksAnywhereSubscription, request, handler, context);
        }
 
        virtual Model::DescribeFargateProfileOutcome DescribeFargateProfile(const Model::DescribeFargateProfileRequest& request) const;
 
        template<typename DescribeFargateProfileRequestT = Model::DescribeFargateProfileRequest>
        Model::DescribeFargateProfileOutcomeCallable DescribeFargateProfileCallable(const DescribeFargateProfileRequestT& request) const
        {
            return SubmitCallable(&EKSClient::DescribeFargateProfile, request);
        }
 
        template<typename DescribeFargateProfileRequestT = Model::DescribeFargateProfileRequest>
        void DescribeFargateProfileAsync(const DescribeFargateProfileRequestT& request, const DescribeFargateProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&EKSClient::DescribeFargateProfile, request, handler, context);
        }
 
        virtual Model::DescribeIdentityProviderConfigOutcome DescribeIdentityProviderConfig(const Model::DescribeIdentityProviderConfigRequest& request) const;
 
        template<typename DescribeIdentityProviderConfigRequestT = Model::DescribeIdentityProviderConfigRequest>
        Model::DescribeIdentityProviderConfigOutcomeCallable DescribeIdentityProviderConfigCallable(const DescribeIdentityProviderConfigRequestT& request) const
        {
            return SubmitCallable(&EKSClient::DescribeIdentityProviderConfig, request);
        }
 
        template<typename DescribeIdentityProviderConfigRequestT = Model::DescribeIdentityProviderConfigRequest>
        void DescribeIdentityProviderConfigAsync(const DescribeIdentityProviderConfigRequestT& request, const DescribeIdentityProviderConfigResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&EKSClient::DescribeIdentityProviderConfig, request, handler, context);
        }
 
        virtual Model::DescribeInsightOutcome DescribeInsight(const Model::DescribeInsightRequest& request) const;
 
        template<typename DescribeInsightRequestT = Model::DescribeInsightRequest>
        Model::DescribeInsightOutcomeCallable DescribeInsightCallable(const DescribeInsightRequestT& request) const
        {
            return SubmitCallable(&EKSClient::DescribeInsight, request);
        }
 
        template<typename DescribeInsightRequestT = Model::DescribeInsightRequest>
        void DescribeInsightAsync(const DescribeInsightRequestT& request, const DescribeInsightResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&EKSClient::DescribeInsight, request, handler, context);
        }
 
        virtual Model::DescribeNodegroupOutcome DescribeNodegroup(const Model::DescribeNodegroupRequest& request) const;
 
        template<typename DescribeNodegroupRequestT = Model::DescribeNodegroupRequest>
        Model::DescribeNodegroupOutcomeCallable DescribeNodegroupCallable(const DescribeNodegroupRequestT& request) const
        {
            return SubmitCallable(&EKSClient::DescribeNodegroup, request);
        }
 
        template<typename DescribeNodegroupRequestT = Model::DescribeNodegroupRequest>
        void DescribeNodegroupAsync(const DescribeNodegroupRequestT& request, const DescribeNodegroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&EKSClient::DescribeNodegroup, request, handler, context);
        }
 
        virtual Model::DescribePodIdentityAssociationOutcome DescribePodIdentityAssociation(const Model::DescribePodIdentityAssociationRequest& request) const;
 
        template<typename DescribePodIdentityAssociationRequestT = Model::DescribePodIdentityAssociationRequest>
        Model::DescribePodIdentityAssociationOutcomeCallable DescribePodIdentityAssociationCallable(const DescribePodIdentityAssociationRequestT& request) const
        {
            return SubmitCallable(&EKSClient::DescribePodIdentityAssociation, request);
        }
 
        template<typename DescribePodIdentityAssociationRequestT = Model::DescribePodIdentityAssociationRequest>
        void DescribePodIdentityAssociationAsync(const DescribePodIdentityAssociationRequestT& request, const DescribePodIdentityAssociationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&EKSClient::DescribePodIdentityAssociation, request, handler, context);
        }
 
        virtual Model::DescribeUpdateOutcome DescribeUpdate(const Model::DescribeUpdateRequest& request) const;
 
        template<typename DescribeUpdateRequestT = Model::DescribeUpdateRequest>
        Model::DescribeUpdateOutcomeCallable DescribeUpdateCallable(const DescribeUpdateRequestT& request) const
        {
            return SubmitCallable(&EKSClient::DescribeUpdate, request);
        }
 
        template<typename DescribeUpdateRequestT = Model::DescribeUpdateRequest>
        void DescribeUpdateAsync(const DescribeUpdateRequestT& request, const DescribeUpdateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&EKSClient::DescribeUpdate, request, handler, context);
        }
 
        virtual Model::DisassociateAccessPolicyOutcome DisassociateAccessPolicy(const Model::DisassociateAccessPolicyRequest& request) const;
 
        template<typename DisassociateAccessPolicyRequestT = Model::DisassociateAccessPolicyRequest>
        Model::DisassociateAccessPolicyOutcomeCallable DisassociateAccessPolicyCallable(const DisassociateAccessPolicyRequestT& request) const
        {
            return SubmitCallable(&EKSClient::DisassociateAccessPolicy, request);
        }
 
        template<typename DisassociateAccessPolicyRequestT = Model::DisassociateAccessPolicyRequest>
        void DisassociateAccessPolicyAsync(const DisassociateAccessPolicyRequestT& request, const DisassociateAccessPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&EKSClient::DisassociateAccessPolicy, request, handler, context);
        }
 
        virtual Model::DisassociateIdentityProviderConfigOutcome DisassociateIdentityProviderConfig(const Model::DisassociateIdentityProviderConfigRequest& request) const;
 
        template<typename DisassociateIdentityProviderConfigRequestT = Model::DisassociateIdentityProviderConfigRequest>
        Model::DisassociateIdentityProviderConfigOutcomeCallable DisassociateIdentityProviderConfigCallable(const DisassociateIdentityProviderConfigRequestT& request) const
        {
            return SubmitCallable(&EKSClient::DisassociateIdentityProviderConfig, request);
        }
 
        template<typename DisassociateIdentityProviderConfigRequestT = Model::DisassociateIdentityProviderConfigRequest>
        void DisassociateIdentityProviderConfigAsync(const DisassociateIdentityProviderConfigRequestT& request, const DisassociateIdentityProviderConfigResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&EKSClient::DisassociateIdentityProviderConfig, request, handler, context);
        }
 
        virtual Model::ListAccessEntriesOutcome ListAccessEntries(const Model::ListAccessEntriesRequest& request) const;
 
        template<typename ListAccessEntriesRequestT = Model::ListAccessEntriesRequest>
        Model::ListAccessEntriesOutcomeCallable ListAccessEntriesCallable(const ListAccessEntriesRequestT& request) const
        {
            return SubmitCallable(&EKSClient::ListAccessEntries, request);
        }
 
        template<typename ListAccessEntriesRequestT = Model::ListAccessEntriesRequest>
        void ListAccessEntriesAsync(const ListAccessEntriesRequestT& request, const ListAccessEntriesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&EKSClient::ListAccessEntries, request, handler, context);
        }
 
        virtual Model::ListAccessPoliciesOutcome ListAccessPolicies(const Model::ListAccessPoliciesRequest& request = {}) const;
 
        template<typename ListAccessPoliciesRequestT = Model::ListAccessPoliciesRequest>
        Model::ListAccessPoliciesOutcomeCallable ListAccessPoliciesCallable(const ListAccessPoliciesRequestT& request = {}) const
        {
            return SubmitCallable(&EKSClient::ListAccessPolicies, request);
        }
 
        template<typename ListAccessPoliciesRequestT = Model::ListAccessPoliciesRequest>
        void ListAccessPoliciesAsync(const ListAccessPoliciesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListAccessPoliciesRequestT& request = {}) const
        {
            return SubmitAsync(&EKSClient::ListAccessPolicies, request, handler, context);
        }
 
        virtual Model::ListAddonsOutcome ListAddons(const Model::ListAddonsRequest& request) const;
 
        template<typename ListAddonsRequestT = Model::ListAddonsRequest>
        Model::ListAddonsOutcomeCallable ListAddonsCallable(const ListAddonsRequestT& request) const
        {
            return SubmitCallable(&EKSClient::ListAddons, request);
        }
 
        template<typename ListAddonsRequestT = Model::ListAddonsRequest>
        void ListAddonsAsync(const ListAddonsRequestT& request, const ListAddonsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&EKSClient::ListAddons, request, handler, context);
        }
 
        virtual Model::ListAssociatedAccessPoliciesOutcome ListAssociatedAccessPolicies(const Model::ListAssociatedAccessPoliciesRequest& request) const;
 
        template<typename ListAssociatedAccessPoliciesRequestT = Model::ListAssociatedAccessPoliciesRequest>
        Model::ListAssociatedAccessPoliciesOutcomeCallable ListAssociatedAccessPoliciesCallable(const ListAssociatedAccessPoliciesRequestT& request) const
        {
            return SubmitCallable(&EKSClient::ListAssociatedAccessPolicies, request);
        }
 
        template<typename ListAssociatedAccessPoliciesRequestT = Model::ListAssociatedAccessPoliciesRequest>
        void ListAssociatedAccessPoliciesAsync(const ListAssociatedAccessPoliciesRequestT& request, const ListAssociatedAccessPoliciesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&EKSClient::ListAssociatedAccessPolicies, request, handler, context);
        }
 
        virtual Model::ListClustersOutcome ListClusters(const Model::ListClustersRequest& request = {}) const;
 
        template<typename ListClustersRequestT = Model::ListClustersRequest>
        Model::ListClustersOutcomeCallable ListClustersCallable(const ListClustersRequestT& request = {}) const
        {
            return SubmitCallable(&EKSClient::ListClusters, request);
        }
 
        template<typename ListClustersRequestT = Model::ListClustersRequest>
        void ListClustersAsync(const ListClustersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListClustersRequestT& request = {}) const
        {
            return SubmitAsync(&EKSClient::ListClusters, request, handler, context);
        }
 
        virtual Model::ListEksAnywhereSubscriptionsOutcome ListEksAnywhereSubscriptions(const Model::ListEksAnywhereSubscriptionsRequest& request = {}) const;
 
        template<typename ListEksAnywhereSubscriptionsRequestT = Model::ListEksAnywhereSubscriptionsRequest>
        Model::ListEksAnywhereSubscriptionsOutcomeCallable ListEksAnywhereSubscriptionsCallable(const ListEksAnywhereSubscriptionsRequestT& request = {}) const
        {
            return SubmitCallable(&EKSClient::ListEksAnywhereSubscriptions, request);
        }
 
        template<typename ListEksAnywhereSubscriptionsRequestT = Model::ListEksAnywhereSubscriptionsRequest>
        void ListEksAnywhereSubscriptionsAsync(const ListEksAnywhereSubscriptionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListEksAnywhereSubscriptionsRequestT& request = {}) const
        {
            return SubmitAsync(&EKSClient::ListEksAnywhereSubscriptions, request, handler, context);
        }
 
        virtual Model::ListFargateProfilesOutcome ListFargateProfiles(const Model::ListFargateProfilesRequest& request) const;
 
        template<typename ListFargateProfilesRequestT = Model::ListFargateProfilesRequest>
        Model::ListFargateProfilesOutcomeCallable ListFargateProfilesCallable(const ListFargateProfilesRequestT& request) const
        {
            return SubmitCallable(&EKSClient::ListFargateProfiles, request);
        }
 
        template<typename ListFargateProfilesRequestT = Model::ListFargateProfilesRequest>
        void ListFargateProfilesAsync(const ListFargateProfilesRequestT& request, const ListFargateProfilesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&EKSClient::ListFargateProfiles, request, handler, context);
        }
 
        virtual Model::ListIdentityProviderConfigsOutcome ListIdentityProviderConfigs(const Model::ListIdentityProviderConfigsRequest& request) const;
 
        template<typename ListIdentityProviderConfigsRequestT = Model::ListIdentityProviderConfigsRequest>
        Model::ListIdentityProviderConfigsOutcomeCallable ListIdentityProviderConfigsCallable(const ListIdentityProviderConfigsRequestT& request) const
        {
            return SubmitCallable(&EKSClient::ListIdentityProviderConfigs, request);
        }
 
        template<typename ListIdentityProviderConfigsRequestT = Model::ListIdentityProviderConfigsRequest>
        void ListIdentityProviderConfigsAsync(const ListIdentityProviderConfigsRequestT& request, const ListIdentityProviderConfigsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&EKSClient::ListIdentityProviderConfigs, request, handler, context);
        }
 
        virtual Model::ListInsightsOutcome ListInsights(const Model::ListInsightsRequest& request) const;
 
        template<typename ListInsightsRequestT = Model::ListInsightsRequest>
        Model::ListInsightsOutcomeCallable ListInsightsCallable(const ListInsightsRequestT& request) const
        {
            return SubmitCallable(&EKSClient::ListInsights, request);
        }
 
        template<typename ListInsightsRequestT = Model::ListInsightsRequest>
        void ListInsightsAsync(const ListInsightsRequestT& request, const ListInsightsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&EKSClient::ListInsights, request, handler, context);
        }
 
        virtual Model::ListNodegroupsOutcome ListNodegroups(const Model::ListNodegroupsRequest& request) const;
 
        template<typename ListNodegroupsRequestT = Model::ListNodegroupsRequest>
        Model::ListNodegroupsOutcomeCallable ListNodegroupsCallable(const ListNodegroupsRequestT& request) const
        {
            return SubmitCallable(&EKSClient::ListNodegroups, request);
        }
 
        template<typename ListNodegroupsRequestT = Model::ListNodegroupsRequest>
        void ListNodegroupsAsync(const ListNodegroupsRequestT& request, const ListNodegroupsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&EKSClient::ListNodegroups, request, handler, context);
        }
 
        virtual Model::ListPodIdentityAssociationsOutcome ListPodIdentityAssociations(const Model::ListPodIdentityAssociationsRequest& request) const;
 
        template<typename ListPodIdentityAssociationsRequestT = Model::ListPodIdentityAssociationsRequest>
        Model::ListPodIdentityAssociationsOutcomeCallable ListPodIdentityAssociationsCallable(const ListPodIdentityAssociationsRequestT& request) const
        {
            return SubmitCallable(&EKSClient::ListPodIdentityAssociations, request);
        }
 
        template<typename ListPodIdentityAssociationsRequestT = Model::ListPodIdentityAssociationsRequest>
        void ListPodIdentityAssociationsAsync(const ListPodIdentityAssociationsRequestT& request, const ListPodIdentityAssociationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&EKSClient::ListPodIdentityAssociations, 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(&EKSClient::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(&EKSClient::ListTagsForResource, request, handler, context);
        }
 
        virtual Model::ListUpdatesOutcome ListUpdates(const Model::ListUpdatesRequest& request) const;
 
        template<typename ListUpdatesRequestT = Model::ListUpdatesRequest>
        Model::ListUpdatesOutcomeCallable ListUpdatesCallable(const ListUpdatesRequestT& request) const
        {
            return SubmitCallable(&EKSClient::ListUpdates, request);
        }
 
        template<typename ListUpdatesRequestT = Model::ListUpdatesRequest>
        void ListUpdatesAsync(const ListUpdatesRequestT& request, const ListUpdatesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&EKSClient::ListUpdates, request, handler, context);
        }
 
        virtual Model::RegisterClusterOutcome RegisterCluster(const Model::RegisterClusterRequest& request) const;
 
        template<typename RegisterClusterRequestT = Model::RegisterClusterRequest>
        Model::RegisterClusterOutcomeCallable RegisterClusterCallable(const RegisterClusterRequestT& request) const
        {
            return SubmitCallable(&EKSClient::RegisterCluster, request);
        }
 
        template<typename RegisterClusterRequestT = Model::RegisterClusterRequest>
        void RegisterClusterAsync(const RegisterClusterRequestT& request, const RegisterClusterResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&EKSClient::RegisterCluster, 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(&EKSClient::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(&EKSClient::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(&EKSClient::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(&EKSClient::UntagResource, request, handler, context);
        }
 
        virtual Model::UpdateAccessEntryOutcome UpdateAccessEntry(const Model::UpdateAccessEntryRequest& request) const;
 
        template<typename UpdateAccessEntryRequestT = Model::UpdateAccessEntryRequest>
        Model::UpdateAccessEntryOutcomeCallable UpdateAccessEntryCallable(const UpdateAccessEntryRequestT& request) const
        {
            return SubmitCallable(&EKSClient::UpdateAccessEntry, request);
        }
 
        template<typename UpdateAccessEntryRequestT = Model::UpdateAccessEntryRequest>
        void UpdateAccessEntryAsync(const UpdateAccessEntryRequestT& request, const UpdateAccessEntryResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&EKSClient::UpdateAccessEntry, request, handler, context);
        }
 
        virtual Model::UpdateAddonOutcome UpdateAddon(const Model::UpdateAddonRequest& request) const;
 
        template<typename UpdateAddonRequestT = Model::UpdateAddonRequest>
        Model::UpdateAddonOutcomeCallable UpdateAddonCallable(const UpdateAddonRequestT& request) const
        {
            return SubmitCallable(&EKSClient::UpdateAddon, request);
        }
 
        template<typename UpdateAddonRequestT = Model::UpdateAddonRequest>
        void UpdateAddonAsync(const UpdateAddonRequestT& request, const UpdateAddonResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&EKSClient::UpdateAddon, request, handler, context);
        }
 
        virtual Model::UpdateClusterConfigOutcome UpdateClusterConfig(const Model::UpdateClusterConfigRequest& request) const;
 
        template<typename UpdateClusterConfigRequestT = Model::UpdateClusterConfigRequest>
        Model::UpdateClusterConfigOutcomeCallable UpdateClusterConfigCallable(const UpdateClusterConfigRequestT& request) const
        {
            return SubmitCallable(&EKSClient::UpdateClusterConfig, request);
        }
 
        template<typename UpdateClusterConfigRequestT = Model::UpdateClusterConfigRequest>
        void UpdateClusterConfigAsync(const UpdateClusterConfigRequestT& request, const UpdateClusterConfigResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&EKSClient::UpdateClusterConfig, request, handler, context);
        }
 
        virtual Model::UpdateClusterVersionOutcome UpdateClusterVersion(const Model::UpdateClusterVersionRequest& request) const;
 
        template<typename UpdateClusterVersionRequestT = Model::UpdateClusterVersionRequest>
        Model::UpdateClusterVersionOutcomeCallable UpdateClusterVersionCallable(const UpdateClusterVersionRequestT& request) const
        {
            return SubmitCallable(&EKSClient::UpdateClusterVersion, request);
        }
 
        template<typename UpdateClusterVersionRequestT = Model::UpdateClusterVersionRequest>
        void UpdateClusterVersionAsync(const UpdateClusterVersionRequestT& request, const UpdateClusterVersionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&EKSClient::UpdateClusterVersion, request, handler, context);
        }
 
        virtual Model::UpdateEksAnywhereSubscriptionOutcome UpdateEksAnywhereSubscription(const Model::UpdateEksAnywhereSubscriptionRequest& request) const;
 
        template<typename UpdateEksAnywhereSubscriptionRequestT = Model::UpdateEksAnywhereSubscriptionRequest>
        Model::UpdateEksAnywhereSubscriptionOutcomeCallable UpdateEksAnywhereSubscriptionCallable(const UpdateEksAnywhereSubscriptionRequestT& request) const
        {
            return SubmitCallable(&EKSClient::UpdateEksAnywhereSubscription, request);
        }
 
        template<typename UpdateEksAnywhereSubscriptionRequestT = Model::UpdateEksAnywhereSubscriptionRequest>
        void UpdateEksAnywhereSubscriptionAsync(const UpdateEksAnywhereSubscriptionRequestT& request, const UpdateEksAnywhereSubscriptionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&EKSClient::UpdateEksAnywhereSubscription, request, handler, context);
        }
 
        virtual Model::UpdateNodegroupConfigOutcome UpdateNodegroupConfig(const Model::UpdateNodegroupConfigRequest& request) const;
 
        template<typename UpdateNodegroupConfigRequestT = Model::UpdateNodegroupConfigRequest>
        Model::UpdateNodegroupConfigOutcomeCallable UpdateNodegroupConfigCallable(const UpdateNodegroupConfigRequestT& request) const
        {
            return SubmitCallable(&EKSClient::UpdateNodegroupConfig, request);
        }
 
        template<typename UpdateNodegroupConfigRequestT = Model::UpdateNodegroupConfigRequest>
        void UpdateNodegroupConfigAsync(const UpdateNodegroupConfigRequestT& request, const UpdateNodegroupConfigResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&EKSClient::UpdateNodegroupConfig, request, handler, context);
        }
 
        virtual Model::UpdateNodegroupVersionOutcome UpdateNodegroupVersion(const Model::UpdateNodegroupVersionRequest& request) const;
 
        template<typename UpdateNodegroupVersionRequestT = Model::UpdateNodegroupVersionRequest>
        Model::UpdateNodegroupVersionOutcomeCallable UpdateNodegroupVersionCallable(const UpdateNodegroupVersionRequestT& request) const
        {
            return SubmitCallable(&EKSClient::UpdateNodegroupVersion, request);
        }
 
        template<typename UpdateNodegroupVersionRequestT = Model::UpdateNodegroupVersionRequest>
        void UpdateNodegroupVersionAsync(const UpdateNodegroupVersionRequestT& request, const UpdateNodegroupVersionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&EKSClient::UpdateNodegroupVersion, request, handler, context);
        }
 
        virtual Model::UpdatePodIdentityAssociationOutcome UpdatePodIdentityAssociation(const Model::UpdatePodIdentityAssociationRequest& request) const;
 
        template<typename UpdatePodIdentityAssociationRequestT = Model::UpdatePodIdentityAssociationRequest>
        Model::UpdatePodIdentityAssociationOutcomeCallable UpdatePodIdentityAssociationCallable(const UpdatePodIdentityAssociationRequestT& request) const
        {
            return SubmitCallable(&EKSClient::UpdatePodIdentityAssociation, request);
        }
 
        template<typename UpdatePodIdentityAssociationRequestT = Model::UpdatePodIdentityAssociationRequest>
        void UpdatePodIdentityAssociationAsync(const UpdatePodIdentityAssociationRequestT& request, const UpdatePodIdentityAssociationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&EKSClient::UpdatePodIdentityAssociation, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<EKSEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<EKSClient>;
      void init(const EKSClientConfiguration& clientConfiguration);
 
      EKSClientConfiguration m_clientConfiguration;
      std::shared_ptr<EKSEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace EKS
} // namespace Aws