EKSClient.h

 
#pragma once
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/eks/EKSPaginationBase.h>
#include <aws/eks/EKSServiceClientModel.h>
#include <aws/eks/EKSWaiter.h>
#include <aws/eks/EKS_EXPORTS.h>
 
namespace Aws {
namespace EKS {
class AWS_EKS_API EKSClient : public Aws::Client::AWSJsonClient,
                              public Aws::Client::ClientWithAsyncTemplateMethods<EKSClient>,
                              public EKSPaginationBase<EKSClient>,
                              public EKSWaiter<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::ActivateCertificateAuthorityOutcome ActivateCertificateAuthority(
      const Model::ActivateCertificateAuthorityRequest& request) const;
 
  template <typename ActivateCertificateAuthorityRequestT = Model::ActivateCertificateAuthorityRequest>
  Model::ActivateCertificateAuthorityOutcomeCallable ActivateCertificateAuthorityCallable(
      const ActivateCertificateAuthorityRequestT& request) const {
    return SubmitCallable(&EKSClient::ActivateCertificateAuthority, request);
  }
 
  template <typename ActivateCertificateAuthorityRequestT = Model::ActivateCertificateAuthorityRequest>
  void ActivateCertificateAuthorityAsync(const ActivateCertificateAuthorityRequestT& request,
                                         const ActivateCertificateAuthorityResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EKSClient::ActivateCertificateAuthority, request, handler, context);
  }
 
  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::CancelUpdateOutcome CancelUpdate(const Model::CancelUpdateRequest& request) const;
 
  template <typename CancelUpdateRequestT = Model::CancelUpdateRequest>
  Model::CancelUpdateOutcomeCallable CancelUpdateCallable(const CancelUpdateRequestT& request) const {
    return SubmitCallable(&EKSClient::CancelUpdate, request);
  }
 
  template <typename CancelUpdateRequestT = Model::CancelUpdateRequest>
  void CancelUpdateAsync(const CancelUpdateRequestT& request, const CancelUpdateResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EKSClient::CancelUpdate, 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::CreateCapabilityOutcome CreateCapability(const Model::CreateCapabilityRequest& request) const;
 
  template <typename CreateCapabilityRequestT = Model::CreateCapabilityRequest>
  Model::CreateCapabilityOutcomeCallable CreateCapabilityCallable(const CreateCapabilityRequestT& request) const {
    return SubmitCallable(&EKSClient::CreateCapability, request);
  }
 
  template <typename CreateCapabilityRequestT = Model::CreateCapabilityRequest>
  void CreateCapabilityAsync(const CreateCapabilityRequestT& request, const CreateCapabilityResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EKSClient::CreateCapability, request, handler, context);
  }
 
  virtual Model::CreateCertificateAuthorityOutcome CreateCertificateAuthority(
      const Model::CreateCertificateAuthorityRequest& request) const;
 
  template <typename CreateCertificateAuthorityRequestT = Model::CreateCertificateAuthorityRequest>
  Model::CreateCertificateAuthorityOutcomeCallable CreateCertificateAuthorityCallable(
      const CreateCertificateAuthorityRequestT& request) const {
    return SubmitCallable(&EKSClient::CreateCertificateAuthority, request);
  }
 
  template <typename CreateCertificateAuthorityRequestT = Model::CreateCertificateAuthorityRequest>
  void CreateCertificateAuthorityAsync(const CreateCertificateAuthorityRequestT& request,
                                       const CreateCertificateAuthorityResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EKSClient::CreateCertificateAuthority, 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::DeleteCapabilityOutcome DeleteCapability(const Model::DeleteCapabilityRequest& request) const;
 
  template <typename DeleteCapabilityRequestT = Model::DeleteCapabilityRequest>
  Model::DeleteCapabilityOutcomeCallable DeleteCapabilityCallable(const DeleteCapabilityRequestT& request) const {
    return SubmitCallable(&EKSClient::DeleteCapability, request);
  }
 
  template <typename DeleteCapabilityRequestT = Model::DeleteCapabilityRequest>
  void DeleteCapabilityAsync(const DeleteCapabilityRequestT& request, const DeleteCapabilityResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EKSClient::DeleteCapability, request, handler, context);
  }
 
  virtual Model::DeleteCertificateAuthorityOutcome DeleteCertificateAuthority(
      const Model::DeleteCertificateAuthorityRequest& request) const;
 
  template <typename DeleteCertificateAuthorityRequestT = Model::DeleteCertificateAuthorityRequest>
  Model::DeleteCertificateAuthorityOutcomeCallable DeleteCertificateAuthorityCallable(
      const DeleteCertificateAuthorityRequestT& request) const {
    return SubmitCallable(&EKSClient::DeleteCertificateAuthority, request);
  }
 
  template <typename DeleteCertificateAuthorityRequestT = Model::DeleteCertificateAuthorityRequest>
  void DeleteCertificateAuthorityAsync(const DeleteCertificateAuthorityRequestT& request,
                                       const DeleteCertificateAuthorityResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EKSClient::DeleteCertificateAuthority, 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::DescribeCapabilityOutcome DescribeCapability(const Model::DescribeCapabilityRequest& request) const;
 
  template <typename DescribeCapabilityRequestT = Model::DescribeCapabilityRequest>
  Model::DescribeCapabilityOutcomeCallable DescribeCapabilityCallable(const DescribeCapabilityRequestT& request) const {
    return SubmitCallable(&EKSClient::DescribeCapability, request);
  }
 
  template <typename DescribeCapabilityRequestT = Model::DescribeCapabilityRequest>
  void DescribeCapabilityAsync(const DescribeCapabilityRequestT& request, const DescribeCapabilityResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EKSClient::DescribeCapability, request, handler, context);
  }
 
  virtual Model::DescribeCertificateAuthorityOutcome DescribeCertificateAuthority(
      const Model::DescribeCertificateAuthorityRequest& request) const;
 
  template <typename DescribeCertificateAuthorityRequestT = Model::DescribeCertificateAuthorityRequest>
  Model::DescribeCertificateAuthorityOutcomeCallable DescribeCertificateAuthorityCallable(
      const DescribeCertificateAuthorityRequestT& request) const {
    return SubmitCallable(&EKSClient::DescribeCertificateAuthority, request);
  }
 
  template <typename DescribeCertificateAuthorityRequestT = Model::DescribeCertificateAuthorityRequest>
  void DescribeCertificateAuthorityAsync(const DescribeCertificateAuthorityRequestT& request,
                                         const DescribeCertificateAuthorityResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EKSClient::DescribeCertificateAuthority, 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::DescribeInsightsRefreshOutcome DescribeInsightsRefresh(const Model::DescribeInsightsRefreshRequest& request) const;
 
  template <typename DescribeInsightsRefreshRequestT = Model::DescribeInsightsRefreshRequest>
  Model::DescribeInsightsRefreshOutcomeCallable DescribeInsightsRefreshCallable(const DescribeInsightsRefreshRequestT& request) const {
    return SubmitCallable(&EKSClient::DescribeInsightsRefresh, request);
  }
 
  template <typename DescribeInsightsRefreshRequestT = Model::DescribeInsightsRefreshRequest>
  void DescribeInsightsRefreshAsync(const DescribeInsightsRefreshRequestT& request,
                                    const DescribeInsightsRefreshResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EKSClient::DescribeInsightsRefresh, 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::ListCapabilitiesOutcome ListCapabilities(const Model::ListCapabilitiesRequest& request) const;
 
  template <typename ListCapabilitiesRequestT = Model::ListCapabilitiesRequest>
  Model::ListCapabilitiesOutcomeCallable ListCapabilitiesCallable(const ListCapabilitiesRequestT& request) const {
    return SubmitCallable(&EKSClient::ListCapabilities, request);
  }
 
  template <typename ListCapabilitiesRequestT = Model::ListCapabilitiesRequest>
  void ListCapabilitiesAsync(const ListCapabilitiesRequestT& request, const ListCapabilitiesResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EKSClient::ListCapabilities, request, handler, context);
  }
 
  virtual Model::ListCertificateAuthoritiesOutcome ListCertificateAuthorities(
      const Model::ListCertificateAuthoritiesRequest& request) const;
 
  template <typename ListCertificateAuthoritiesRequestT = Model::ListCertificateAuthoritiesRequest>
  Model::ListCertificateAuthoritiesOutcomeCallable ListCertificateAuthoritiesCallable(
      const ListCertificateAuthoritiesRequestT& request) const {
    return SubmitCallable(&EKSClient::ListCertificateAuthorities, request);
  }
 
  template <typename ListCertificateAuthoritiesRequestT = Model::ListCertificateAuthoritiesRequest>
  void ListCertificateAuthoritiesAsync(const ListCertificateAuthoritiesRequestT& request,
                                       const ListCertificateAuthoritiesResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EKSClient::ListCertificateAuthorities, 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::StartInsightsRefreshOutcome StartInsightsRefresh(const Model::StartInsightsRefreshRequest& request) const;
 
  template <typename StartInsightsRefreshRequestT = Model::StartInsightsRefreshRequest>
  Model::StartInsightsRefreshOutcomeCallable StartInsightsRefreshCallable(const StartInsightsRefreshRequestT& request) const {
    return SubmitCallable(&EKSClient::StartInsightsRefresh, request);
  }
 
  template <typename StartInsightsRefreshRequestT = Model::StartInsightsRefreshRequest>
  void StartInsightsRefreshAsync(const StartInsightsRefreshRequestT& request, const StartInsightsRefreshResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EKSClient::StartInsightsRefresh, 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::UpdateCapabilityOutcome UpdateCapability(const Model::UpdateCapabilityRequest& request) const;
 
  template <typename UpdateCapabilityRequestT = Model::UpdateCapabilityRequest>
  Model::UpdateCapabilityOutcomeCallable UpdateCapabilityCallable(const UpdateCapabilityRequestT& request) const {
    return SubmitCallable(&EKSClient::UpdateCapability, request);
  }
 
  template <typename UpdateCapabilityRequestT = Model::UpdateCapabilityRequest>
  void UpdateCapabilityAsync(const UpdateCapabilityRequestT& request, const UpdateCapabilityResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EKSClient::UpdateCapability, 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);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<EKSEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<EKSClient>;
  void init(const EKSClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, EKSError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request,
                                                const std::function<void(Aws::Endpoint::ResolveEndpointOutcome&)>& resolveUri,
                                                Aws::Http::HttpMethod httpMethod) const;
 
  EKSClientConfiguration m_clientConfiguration;
  std::shared_ptr<EKSEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace EKS
}  // namespace Aws