KMSClient.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/kms/KMSServiceClientModel.h>
#include <aws/kms/KMS_EXPORTS.h>
 
namespace Aws {
namespace KMS {
class AWS_KMS_API KMSClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<KMSClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef KMSClientConfiguration ClientConfigurationType;
  typedef KMSEndpointProvider EndpointProviderType;
 
  KMSClient(const Aws::KMS::KMSClientConfiguration& clientConfiguration = Aws::KMS::KMSClientConfiguration(),
            std::shared_ptr<KMSEndpointProviderBase> endpointProvider = nullptr);
 
  KMSClient(const Aws::Auth::AWSCredentials& credentials, std::shared_ptr<KMSEndpointProviderBase> endpointProvider = nullptr,
            const Aws::KMS::KMSClientConfiguration& clientConfiguration = Aws::KMS::KMSClientConfiguration());
 
  KMSClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
            std::shared_ptr<KMSEndpointProviderBase> endpointProvider = nullptr,
            const Aws::KMS::KMSClientConfiguration& clientConfiguration = Aws::KMS::KMSClientConfiguration());
 
  /* Legacy constructors due deprecation */
  KMSClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  KMSClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  KMSClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
            const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~KMSClient();
 
  virtual Model::CancelKeyDeletionOutcome CancelKeyDeletion(const Model::CancelKeyDeletionRequest& request) const;
 
  template <typename CancelKeyDeletionRequestT = Model::CancelKeyDeletionRequest>
  Model::CancelKeyDeletionOutcomeCallable CancelKeyDeletionCallable(const CancelKeyDeletionRequestT& request) const {
    return SubmitCallable(&KMSClient::CancelKeyDeletion, request);
  }
 
  template <typename CancelKeyDeletionRequestT = Model::CancelKeyDeletionRequest>
  void CancelKeyDeletionAsync(const CancelKeyDeletionRequestT& request, const CancelKeyDeletionResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KMSClient::CancelKeyDeletion, request, handler, context);
  }
 
  virtual Model::ConnectCustomKeyStoreOutcome ConnectCustomKeyStore(const Model::ConnectCustomKeyStoreRequest& request) const;
 
  template <typename ConnectCustomKeyStoreRequestT = Model::ConnectCustomKeyStoreRequest>
  Model::ConnectCustomKeyStoreOutcomeCallable ConnectCustomKeyStoreCallable(const ConnectCustomKeyStoreRequestT& request) const {
    return SubmitCallable(&KMSClient::ConnectCustomKeyStore, request);
  }
 
  template <typename ConnectCustomKeyStoreRequestT = Model::ConnectCustomKeyStoreRequest>
  void ConnectCustomKeyStoreAsync(const ConnectCustomKeyStoreRequestT& request, const ConnectCustomKeyStoreResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KMSClient::ConnectCustomKeyStore, request, handler, context);
  }
 
  virtual Model::CreateAliasOutcome CreateAlias(const Model::CreateAliasRequest& request) const;
 
  template <typename CreateAliasRequestT = Model::CreateAliasRequest>
  Model::CreateAliasOutcomeCallable CreateAliasCallable(const CreateAliasRequestT& request) const {
    return SubmitCallable(&KMSClient::CreateAlias, request);
  }
 
  template <typename CreateAliasRequestT = Model::CreateAliasRequest>
  void CreateAliasAsync(const CreateAliasRequestT& request, const CreateAliasResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KMSClient::CreateAlias, request, handler, context);
  }
 
  virtual Model::CreateCustomKeyStoreOutcome CreateCustomKeyStore(const Model::CreateCustomKeyStoreRequest& request) const;
 
  template <typename CreateCustomKeyStoreRequestT = Model::CreateCustomKeyStoreRequest>
  Model::CreateCustomKeyStoreOutcomeCallable CreateCustomKeyStoreCallable(const CreateCustomKeyStoreRequestT& request) const {
    return SubmitCallable(&KMSClient::CreateCustomKeyStore, request);
  }
 
  template <typename CreateCustomKeyStoreRequestT = Model::CreateCustomKeyStoreRequest>
  void CreateCustomKeyStoreAsync(const CreateCustomKeyStoreRequestT& request, const CreateCustomKeyStoreResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KMSClient::CreateCustomKeyStore, request, handler, context);
  }
 
  virtual Model::CreateGrantOutcome CreateGrant(const Model::CreateGrantRequest& request) const;
 
  template <typename CreateGrantRequestT = Model::CreateGrantRequest>
  Model::CreateGrantOutcomeCallable CreateGrantCallable(const CreateGrantRequestT& request) const {
    return SubmitCallable(&KMSClient::CreateGrant, request);
  }
 
  template <typename CreateGrantRequestT = Model::CreateGrantRequest>
  void CreateGrantAsync(const CreateGrantRequestT& request, const CreateGrantResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KMSClient::CreateGrant, request, handler, context);
  }
 
  virtual Model::CreateKeyOutcome CreateKey(const Model::CreateKeyRequest& request = {}) const;
 
  template <typename CreateKeyRequestT = Model::CreateKeyRequest>
  Model::CreateKeyOutcomeCallable CreateKeyCallable(const CreateKeyRequestT& request = {}) const {
    return SubmitCallable(&KMSClient::CreateKey, request);
  }
 
  template <typename CreateKeyRequestT = Model::CreateKeyRequest>
  void CreateKeyAsync(const CreateKeyResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                      const CreateKeyRequestT& request = {}) const {
    return SubmitAsync(&KMSClient::CreateKey, request, handler, context);
  }
 
  virtual Model::DecryptOutcome Decrypt(const Model::DecryptRequest& request) const;
 
  template <typename DecryptRequestT = Model::DecryptRequest>
  Model::DecryptOutcomeCallable DecryptCallable(const DecryptRequestT& request) const {
    return SubmitCallable(&KMSClient::Decrypt, request);
  }
 
  template <typename DecryptRequestT = Model::DecryptRequest>
  void DecryptAsync(const DecryptRequestT& request, const DecryptResponseReceivedHandler& handler,
                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KMSClient::Decrypt, request, handler, context);
  }
 
  virtual Model::DeleteAliasOutcome DeleteAlias(const Model::DeleteAliasRequest& request) const;
 
  template <typename DeleteAliasRequestT = Model::DeleteAliasRequest>
  Model::DeleteAliasOutcomeCallable DeleteAliasCallable(const DeleteAliasRequestT& request) const {
    return SubmitCallable(&KMSClient::DeleteAlias, request);
  }
 
  template <typename DeleteAliasRequestT = Model::DeleteAliasRequest>
  void DeleteAliasAsync(const DeleteAliasRequestT& request, const DeleteAliasResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KMSClient::DeleteAlias, request, handler, context);
  }
 
  virtual Model::DeleteCustomKeyStoreOutcome DeleteCustomKeyStore(const Model::DeleteCustomKeyStoreRequest& request) const;
 
  template <typename DeleteCustomKeyStoreRequestT = Model::DeleteCustomKeyStoreRequest>
  Model::DeleteCustomKeyStoreOutcomeCallable DeleteCustomKeyStoreCallable(const DeleteCustomKeyStoreRequestT& request) const {
    return SubmitCallable(&KMSClient::DeleteCustomKeyStore, request);
  }
 
  template <typename DeleteCustomKeyStoreRequestT = Model::DeleteCustomKeyStoreRequest>
  void DeleteCustomKeyStoreAsync(const DeleteCustomKeyStoreRequestT& request, const DeleteCustomKeyStoreResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KMSClient::DeleteCustomKeyStore, request, handler, context);
  }
 
  virtual Model::DeleteImportedKeyMaterialOutcome DeleteImportedKeyMaterial(const Model::DeleteImportedKeyMaterialRequest& request) const;
 
  template <typename DeleteImportedKeyMaterialRequestT = Model::DeleteImportedKeyMaterialRequest>
  Model::DeleteImportedKeyMaterialOutcomeCallable DeleteImportedKeyMaterialCallable(
      const DeleteImportedKeyMaterialRequestT& request) const {
    return SubmitCallable(&KMSClient::DeleteImportedKeyMaterial, request);
  }
 
  template <typename DeleteImportedKeyMaterialRequestT = Model::DeleteImportedKeyMaterialRequest>
  void DeleteImportedKeyMaterialAsync(const DeleteImportedKeyMaterialRequestT& request,
                                      const DeleteImportedKeyMaterialResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KMSClient::DeleteImportedKeyMaterial, request, handler, context);
  }
 
  virtual Model::DeriveSharedSecretOutcome DeriveSharedSecret(const Model::DeriveSharedSecretRequest& request) const;
 
  template <typename DeriveSharedSecretRequestT = Model::DeriveSharedSecretRequest>
  Model::DeriveSharedSecretOutcomeCallable DeriveSharedSecretCallable(const DeriveSharedSecretRequestT& request) const {
    return SubmitCallable(&KMSClient::DeriveSharedSecret, request);
  }
 
  template <typename DeriveSharedSecretRequestT = Model::DeriveSharedSecretRequest>
  void DeriveSharedSecretAsync(const DeriveSharedSecretRequestT& request, const DeriveSharedSecretResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KMSClient::DeriveSharedSecret, request, handler, context);
  }
 
  virtual Model::DescribeCustomKeyStoresOutcome DescribeCustomKeyStores(const Model::DescribeCustomKeyStoresRequest& request = {}) const;
 
  template <typename DescribeCustomKeyStoresRequestT = Model::DescribeCustomKeyStoresRequest>
  Model::DescribeCustomKeyStoresOutcomeCallable DescribeCustomKeyStoresCallable(const DescribeCustomKeyStoresRequestT& request = {}) const {
    return SubmitCallable(&KMSClient::DescribeCustomKeyStores, request);
  }
 
  template <typename DescribeCustomKeyStoresRequestT = Model::DescribeCustomKeyStoresRequest>
  void DescribeCustomKeyStoresAsync(const DescribeCustomKeyStoresResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                    const DescribeCustomKeyStoresRequestT& request = {}) const {
    return SubmitAsync(&KMSClient::DescribeCustomKeyStores, request, handler, context);
  }
 
  virtual Model::DescribeKeyOutcome DescribeKey(const Model::DescribeKeyRequest& request) const;
 
  template <typename DescribeKeyRequestT = Model::DescribeKeyRequest>
  Model::DescribeKeyOutcomeCallable DescribeKeyCallable(const DescribeKeyRequestT& request) const {
    return SubmitCallable(&KMSClient::DescribeKey, request);
  }
 
  template <typename DescribeKeyRequestT = Model::DescribeKeyRequest>
  void DescribeKeyAsync(const DescribeKeyRequestT& request, const DescribeKeyResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KMSClient::DescribeKey, request, handler, context);
  }
 
  virtual Model::DisableKeyOutcome DisableKey(const Model::DisableKeyRequest& request) const;
 
  template <typename DisableKeyRequestT = Model::DisableKeyRequest>
  Model::DisableKeyOutcomeCallable DisableKeyCallable(const DisableKeyRequestT& request) const {
    return SubmitCallable(&KMSClient::DisableKey, request);
  }
 
  template <typename DisableKeyRequestT = Model::DisableKeyRequest>
  void DisableKeyAsync(const DisableKeyRequestT& request, const DisableKeyResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KMSClient::DisableKey, request, handler, context);
  }
 
  virtual Model::DisableKeyRotationOutcome DisableKeyRotation(const Model::DisableKeyRotationRequest& request) const;
 
  template <typename DisableKeyRotationRequestT = Model::DisableKeyRotationRequest>
  Model::DisableKeyRotationOutcomeCallable DisableKeyRotationCallable(const DisableKeyRotationRequestT& request) const {
    return SubmitCallable(&KMSClient::DisableKeyRotation, request);
  }
 
  template <typename DisableKeyRotationRequestT = Model::DisableKeyRotationRequest>
  void DisableKeyRotationAsync(const DisableKeyRotationRequestT& request, const DisableKeyRotationResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KMSClient::DisableKeyRotation, request, handler, context);
  }
 
  virtual Model::DisconnectCustomKeyStoreOutcome DisconnectCustomKeyStore(const Model::DisconnectCustomKeyStoreRequest& request) const;
 
  template <typename DisconnectCustomKeyStoreRequestT = Model::DisconnectCustomKeyStoreRequest>
  Model::DisconnectCustomKeyStoreOutcomeCallable DisconnectCustomKeyStoreCallable(const DisconnectCustomKeyStoreRequestT& request) const {
    return SubmitCallable(&KMSClient::DisconnectCustomKeyStore, request);
  }
 
  template <typename DisconnectCustomKeyStoreRequestT = Model::DisconnectCustomKeyStoreRequest>
  void DisconnectCustomKeyStoreAsync(const DisconnectCustomKeyStoreRequestT& request,
                                     const DisconnectCustomKeyStoreResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KMSClient::DisconnectCustomKeyStore, request, handler, context);
  }
 
  virtual Model::EnableKeyOutcome EnableKey(const Model::EnableKeyRequest& request) const;
 
  template <typename EnableKeyRequestT = Model::EnableKeyRequest>
  Model::EnableKeyOutcomeCallable EnableKeyCallable(const EnableKeyRequestT& request) const {
    return SubmitCallable(&KMSClient::EnableKey, request);
  }
 
  template <typename EnableKeyRequestT = Model::EnableKeyRequest>
  void EnableKeyAsync(const EnableKeyRequestT& request, const EnableKeyResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KMSClient::EnableKey, request, handler, context);
  }
 
  virtual Model::EnableKeyRotationOutcome EnableKeyRotation(const Model::EnableKeyRotationRequest& request) const;
 
  template <typename EnableKeyRotationRequestT = Model::EnableKeyRotationRequest>
  Model::EnableKeyRotationOutcomeCallable EnableKeyRotationCallable(const EnableKeyRotationRequestT& request) const {
    return SubmitCallable(&KMSClient::EnableKeyRotation, request);
  }
 
  template <typename EnableKeyRotationRequestT = Model::EnableKeyRotationRequest>
  void EnableKeyRotationAsync(const EnableKeyRotationRequestT& request, const EnableKeyRotationResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KMSClient::EnableKeyRotation, request, handler, context);
  }
 
  virtual Model::EncryptOutcome Encrypt(const Model::EncryptRequest& request) const;
 
  template <typename EncryptRequestT = Model::EncryptRequest>
  Model::EncryptOutcomeCallable EncryptCallable(const EncryptRequestT& request) const {
    return SubmitCallable(&KMSClient::Encrypt, request);
  }
 
  template <typename EncryptRequestT = Model::EncryptRequest>
  void EncryptAsync(const EncryptRequestT& request, const EncryptResponseReceivedHandler& handler,
                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KMSClient::Encrypt, request, handler, context);
  }
 
  virtual Model::GenerateDataKeyOutcome GenerateDataKey(const Model::GenerateDataKeyRequest& request) const;
 
  template <typename GenerateDataKeyRequestT = Model::GenerateDataKeyRequest>
  Model::GenerateDataKeyOutcomeCallable GenerateDataKeyCallable(const GenerateDataKeyRequestT& request) const {
    return SubmitCallable(&KMSClient::GenerateDataKey, request);
  }
 
  template <typename GenerateDataKeyRequestT = Model::GenerateDataKeyRequest>
  void GenerateDataKeyAsync(const GenerateDataKeyRequestT& request, const GenerateDataKeyResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KMSClient::GenerateDataKey, request, handler, context);
  }
 
  virtual Model::GenerateDataKeyPairOutcome GenerateDataKeyPair(const Model::GenerateDataKeyPairRequest& request) const;
 
  template <typename GenerateDataKeyPairRequestT = Model::GenerateDataKeyPairRequest>
  Model::GenerateDataKeyPairOutcomeCallable GenerateDataKeyPairCallable(const GenerateDataKeyPairRequestT& request) const {
    return SubmitCallable(&KMSClient::GenerateDataKeyPair, request);
  }
 
  template <typename GenerateDataKeyPairRequestT = Model::GenerateDataKeyPairRequest>
  void GenerateDataKeyPairAsync(const GenerateDataKeyPairRequestT& request, const GenerateDataKeyPairResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KMSClient::GenerateDataKeyPair, request, handler, context);
  }
 
  virtual Model::GenerateDataKeyPairWithoutPlaintextOutcome GenerateDataKeyPairWithoutPlaintext(
      const Model::GenerateDataKeyPairWithoutPlaintextRequest& request) const;
 
  template <typename GenerateDataKeyPairWithoutPlaintextRequestT = Model::GenerateDataKeyPairWithoutPlaintextRequest>
  Model::GenerateDataKeyPairWithoutPlaintextOutcomeCallable GenerateDataKeyPairWithoutPlaintextCallable(
      const GenerateDataKeyPairWithoutPlaintextRequestT& request) const {
    return SubmitCallable(&KMSClient::GenerateDataKeyPairWithoutPlaintext, request);
  }
 
  template <typename GenerateDataKeyPairWithoutPlaintextRequestT = Model::GenerateDataKeyPairWithoutPlaintextRequest>
  void GenerateDataKeyPairWithoutPlaintextAsync(const GenerateDataKeyPairWithoutPlaintextRequestT& request,
                                                const GenerateDataKeyPairWithoutPlaintextResponseReceivedHandler& handler,
                                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KMSClient::GenerateDataKeyPairWithoutPlaintext, request, handler, context);
  }
 
  virtual Model::GenerateDataKeyWithoutPlaintextOutcome GenerateDataKeyWithoutPlaintext(
      const Model::GenerateDataKeyWithoutPlaintextRequest& request) const;
 
  template <typename GenerateDataKeyWithoutPlaintextRequestT = Model::GenerateDataKeyWithoutPlaintextRequest>
  Model::GenerateDataKeyWithoutPlaintextOutcomeCallable GenerateDataKeyWithoutPlaintextCallable(
      const GenerateDataKeyWithoutPlaintextRequestT& request) const {
    return SubmitCallable(&KMSClient::GenerateDataKeyWithoutPlaintext, request);
  }
 
  template <typename GenerateDataKeyWithoutPlaintextRequestT = Model::GenerateDataKeyWithoutPlaintextRequest>
  void GenerateDataKeyWithoutPlaintextAsync(const GenerateDataKeyWithoutPlaintextRequestT& request,
                                            const GenerateDataKeyWithoutPlaintextResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KMSClient::GenerateDataKeyWithoutPlaintext, request, handler, context);
  }
 
  virtual Model::GenerateMacOutcome GenerateMac(const Model::GenerateMacRequest& request) const;
 
  template <typename GenerateMacRequestT = Model::GenerateMacRequest>
  Model::GenerateMacOutcomeCallable GenerateMacCallable(const GenerateMacRequestT& request) const {
    return SubmitCallable(&KMSClient::GenerateMac, request);
  }
 
  template <typename GenerateMacRequestT = Model::GenerateMacRequest>
  void GenerateMacAsync(const GenerateMacRequestT& request, const GenerateMacResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KMSClient::GenerateMac, request, handler, context);
  }
 
  virtual Model::GenerateRandomOutcome GenerateRandom(const Model::GenerateRandomRequest& request = {}) const;
 
  template <typename GenerateRandomRequestT = Model::GenerateRandomRequest>
  Model::GenerateRandomOutcomeCallable GenerateRandomCallable(const GenerateRandomRequestT& request = {}) const {
    return SubmitCallable(&KMSClient::GenerateRandom, request);
  }
 
  template <typename GenerateRandomRequestT = Model::GenerateRandomRequest>
  void GenerateRandomAsync(const GenerateRandomResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                           const GenerateRandomRequestT& request = {}) const {
    return SubmitAsync(&KMSClient::GenerateRandom, request, handler, context);
  }
 
  virtual Model::GetKeyPolicyOutcome GetKeyPolicy(const Model::GetKeyPolicyRequest& request) const;
 
  template <typename GetKeyPolicyRequestT = Model::GetKeyPolicyRequest>
  Model::GetKeyPolicyOutcomeCallable GetKeyPolicyCallable(const GetKeyPolicyRequestT& request) const {
    return SubmitCallable(&KMSClient::GetKeyPolicy, request);
  }
 
  template <typename GetKeyPolicyRequestT = Model::GetKeyPolicyRequest>
  void GetKeyPolicyAsync(const GetKeyPolicyRequestT& request, const GetKeyPolicyResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KMSClient::GetKeyPolicy, request, handler, context);
  }
 
  virtual Model::GetKeyRotationStatusOutcome GetKeyRotationStatus(const Model::GetKeyRotationStatusRequest& request) const;
 
  template <typename GetKeyRotationStatusRequestT = Model::GetKeyRotationStatusRequest>
  Model::GetKeyRotationStatusOutcomeCallable GetKeyRotationStatusCallable(const GetKeyRotationStatusRequestT& request) const {
    return SubmitCallable(&KMSClient::GetKeyRotationStatus, request);
  }
 
  template <typename GetKeyRotationStatusRequestT = Model::GetKeyRotationStatusRequest>
  void GetKeyRotationStatusAsync(const GetKeyRotationStatusRequestT& request, const GetKeyRotationStatusResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KMSClient::GetKeyRotationStatus, request, handler, context);
  }
 
  virtual Model::GetParametersForImportOutcome GetParametersForImport(const Model::GetParametersForImportRequest& request) const;
 
  template <typename GetParametersForImportRequestT = Model::GetParametersForImportRequest>
  Model::GetParametersForImportOutcomeCallable GetParametersForImportCallable(const GetParametersForImportRequestT& request) const {
    return SubmitCallable(&KMSClient::GetParametersForImport, request);
  }
 
  template <typename GetParametersForImportRequestT = Model::GetParametersForImportRequest>
  void GetParametersForImportAsync(const GetParametersForImportRequestT& request,
                                   const GetParametersForImportResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KMSClient::GetParametersForImport, request, handler, context);
  }
 
  virtual Model::GetPublicKeyOutcome GetPublicKey(const Model::GetPublicKeyRequest& request) const;
 
  template <typename GetPublicKeyRequestT = Model::GetPublicKeyRequest>
  Model::GetPublicKeyOutcomeCallable GetPublicKeyCallable(const GetPublicKeyRequestT& request) const {
    return SubmitCallable(&KMSClient::GetPublicKey, request);
  }
 
  template <typename GetPublicKeyRequestT = Model::GetPublicKeyRequest>
  void GetPublicKeyAsync(const GetPublicKeyRequestT& request, const GetPublicKeyResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KMSClient::GetPublicKey, request, handler, context);
  }
 
  virtual Model::ImportKeyMaterialOutcome ImportKeyMaterial(const Model::ImportKeyMaterialRequest& request) const;
 
  template <typename ImportKeyMaterialRequestT = Model::ImportKeyMaterialRequest>
  Model::ImportKeyMaterialOutcomeCallable ImportKeyMaterialCallable(const ImportKeyMaterialRequestT& request) const {
    return SubmitCallable(&KMSClient::ImportKeyMaterial, request);
  }
 
  template <typename ImportKeyMaterialRequestT = Model::ImportKeyMaterialRequest>
  void ImportKeyMaterialAsync(const ImportKeyMaterialRequestT& request, const ImportKeyMaterialResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KMSClient::ImportKeyMaterial, request, handler, context);
  }
 
  virtual Model::ListAliasesOutcome ListAliases(const Model::ListAliasesRequest& request = {}) const;
 
  template <typename ListAliasesRequestT = Model::ListAliasesRequest>
  Model::ListAliasesOutcomeCallable ListAliasesCallable(const ListAliasesRequestT& request = {}) const {
    return SubmitCallable(&KMSClient::ListAliases, request);
  }
 
  template <typename ListAliasesRequestT = Model::ListAliasesRequest>
  void ListAliasesAsync(const ListAliasesResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                        const ListAliasesRequestT& request = {}) const {
    return SubmitAsync(&KMSClient::ListAliases, request, handler, context);
  }
 
  virtual Model::ListGrantsOutcome ListGrants(const Model::ListGrantsRequest& request) const;
 
  template <typename ListGrantsRequestT = Model::ListGrantsRequest>
  Model::ListGrantsOutcomeCallable ListGrantsCallable(const ListGrantsRequestT& request) const {
    return SubmitCallable(&KMSClient::ListGrants, request);
  }
 
  template <typename ListGrantsRequestT = Model::ListGrantsRequest>
  void ListGrantsAsync(const ListGrantsRequestT& request, const ListGrantsResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KMSClient::ListGrants, request, handler, context);
  }
 
  virtual Model::ListKeyPoliciesOutcome ListKeyPolicies(const Model::ListKeyPoliciesRequest& request) const;
 
  template <typename ListKeyPoliciesRequestT = Model::ListKeyPoliciesRequest>
  Model::ListKeyPoliciesOutcomeCallable ListKeyPoliciesCallable(const ListKeyPoliciesRequestT& request) const {
    return SubmitCallable(&KMSClient::ListKeyPolicies, request);
  }
 
  template <typename ListKeyPoliciesRequestT = Model::ListKeyPoliciesRequest>
  void ListKeyPoliciesAsync(const ListKeyPoliciesRequestT& request, const ListKeyPoliciesResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KMSClient::ListKeyPolicies, request, handler, context);
  }
 
  virtual Model::ListKeyRotationsOutcome ListKeyRotations(const Model::ListKeyRotationsRequest& request) const;
 
  template <typename ListKeyRotationsRequestT = Model::ListKeyRotationsRequest>
  Model::ListKeyRotationsOutcomeCallable ListKeyRotationsCallable(const ListKeyRotationsRequestT& request) const {
    return SubmitCallable(&KMSClient::ListKeyRotations, request);
  }
 
  template <typename ListKeyRotationsRequestT = Model::ListKeyRotationsRequest>
  void ListKeyRotationsAsync(const ListKeyRotationsRequestT& request, const ListKeyRotationsResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KMSClient::ListKeyRotations, request, handler, context);
  }
 
  virtual Model::ListKeysOutcome ListKeys(const Model::ListKeysRequest& request = {}) const;
 
  template <typename ListKeysRequestT = Model::ListKeysRequest>
  Model::ListKeysOutcomeCallable ListKeysCallable(const ListKeysRequestT& request = {}) const {
    return SubmitCallable(&KMSClient::ListKeys, request);
  }
 
  template <typename ListKeysRequestT = Model::ListKeysRequest>
  void ListKeysAsync(const ListKeysResponseReceivedHandler& handler,
                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                     const ListKeysRequestT& request = {}) const {
    return SubmitAsync(&KMSClient::ListKeys, request, handler, context);
  }
 
  virtual Model::ListResourceTagsOutcome ListResourceTags(const Model::ListResourceTagsRequest& request) const;
 
  template <typename ListResourceTagsRequestT = Model::ListResourceTagsRequest>
  Model::ListResourceTagsOutcomeCallable ListResourceTagsCallable(const ListResourceTagsRequestT& request) const {
    return SubmitCallable(&KMSClient::ListResourceTags, request);
  }
 
  template <typename ListResourceTagsRequestT = Model::ListResourceTagsRequest>
  void ListResourceTagsAsync(const ListResourceTagsRequestT& request, const ListResourceTagsResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KMSClient::ListResourceTags, request, handler, context);
  }
 
  virtual Model::ListRetirableGrantsOutcome ListRetirableGrants(const Model::ListRetirableGrantsRequest& request) const;
 
  template <typename ListRetirableGrantsRequestT = Model::ListRetirableGrantsRequest>
  Model::ListRetirableGrantsOutcomeCallable ListRetirableGrantsCallable(const ListRetirableGrantsRequestT& request) const {
    return SubmitCallable(&KMSClient::ListRetirableGrants, request);
  }
 
  template <typename ListRetirableGrantsRequestT = Model::ListRetirableGrantsRequest>
  void ListRetirableGrantsAsync(const ListRetirableGrantsRequestT& request, const ListRetirableGrantsResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KMSClient::ListRetirableGrants, request, handler, context);
  }
 
  virtual Model::PutKeyPolicyOutcome PutKeyPolicy(const Model::PutKeyPolicyRequest& request) const;
 
  template <typename PutKeyPolicyRequestT = Model::PutKeyPolicyRequest>
  Model::PutKeyPolicyOutcomeCallable PutKeyPolicyCallable(const PutKeyPolicyRequestT& request) const {
    return SubmitCallable(&KMSClient::PutKeyPolicy, request);
  }
 
  template <typename PutKeyPolicyRequestT = Model::PutKeyPolicyRequest>
  void PutKeyPolicyAsync(const PutKeyPolicyRequestT& request, const PutKeyPolicyResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KMSClient::PutKeyPolicy, request, handler, context);
  }
 
  virtual Model::ReEncryptOutcome ReEncrypt(const Model::ReEncryptRequest& request) const;
 
  template <typename ReEncryptRequestT = Model::ReEncryptRequest>
  Model::ReEncryptOutcomeCallable ReEncryptCallable(const ReEncryptRequestT& request) const {
    return SubmitCallable(&KMSClient::ReEncrypt, request);
  }
 
  template <typename ReEncryptRequestT = Model::ReEncryptRequest>
  void ReEncryptAsync(const ReEncryptRequestT& request, const ReEncryptResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KMSClient::ReEncrypt, request, handler, context);
  }
 
  virtual Model::ReplicateKeyOutcome ReplicateKey(const Model::ReplicateKeyRequest& request) const;
 
  template <typename ReplicateKeyRequestT = Model::ReplicateKeyRequest>
  Model::ReplicateKeyOutcomeCallable ReplicateKeyCallable(const ReplicateKeyRequestT& request) const {
    return SubmitCallable(&KMSClient::ReplicateKey, request);
  }
 
  template <typename ReplicateKeyRequestT = Model::ReplicateKeyRequest>
  void ReplicateKeyAsync(const ReplicateKeyRequestT& request, const ReplicateKeyResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KMSClient::ReplicateKey, request, handler, context);
  }
 
  virtual Model::RetireGrantOutcome RetireGrant(const Model::RetireGrantRequest& request = {}) const;
 
  template <typename RetireGrantRequestT = Model::RetireGrantRequest>
  Model::RetireGrantOutcomeCallable RetireGrantCallable(const RetireGrantRequestT& request = {}) const {
    return SubmitCallable(&KMSClient::RetireGrant, request);
  }
 
  template <typename RetireGrantRequestT = Model::RetireGrantRequest>
  void RetireGrantAsync(const RetireGrantResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                        const RetireGrantRequestT& request = {}) const {
    return SubmitAsync(&KMSClient::RetireGrant, request, handler, context);
  }
 
  virtual Model::RevokeGrantOutcome RevokeGrant(const Model::RevokeGrantRequest& request) const;
 
  template <typename RevokeGrantRequestT = Model::RevokeGrantRequest>
  Model::RevokeGrantOutcomeCallable RevokeGrantCallable(const RevokeGrantRequestT& request) const {
    return SubmitCallable(&KMSClient::RevokeGrant, request);
  }
 
  template <typename RevokeGrantRequestT = Model::RevokeGrantRequest>
  void RevokeGrantAsync(const RevokeGrantRequestT& request, const RevokeGrantResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KMSClient::RevokeGrant, request, handler, context);
  }
 
  virtual Model::RotateKeyOnDemandOutcome RotateKeyOnDemand(const Model::RotateKeyOnDemandRequest& request) const;
 
  template <typename RotateKeyOnDemandRequestT = Model::RotateKeyOnDemandRequest>
  Model::RotateKeyOnDemandOutcomeCallable RotateKeyOnDemandCallable(const RotateKeyOnDemandRequestT& request) const {
    return SubmitCallable(&KMSClient::RotateKeyOnDemand, request);
  }
 
  template <typename RotateKeyOnDemandRequestT = Model::RotateKeyOnDemandRequest>
  void RotateKeyOnDemandAsync(const RotateKeyOnDemandRequestT& request, const RotateKeyOnDemandResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KMSClient::RotateKeyOnDemand, request, handler, context);
  }
 
  virtual Model::ScheduleKeyDeletionOutcome ScheduleKeyDeletion(const Model::ScheduleKeyDeletionRequest& request) const;
 
  template <typename ScheduleKeyDeletionRequestT = Model::ScheduleKeyDeletionRequest>
  Model::ScheduleKeyDeletionOutcomeCallable ScheduleKeyDeletionCallable(const ScheduleKeyDeletionRequestT& request) const {
    return SubmitCallable(&KMSClient::ScheduleKeyDeletion, request);
  }
 
  template <typename ScheduleKeyDeletionRequestT = Model::ScheduleKeyDeletionRequest>
  void ScheduleKeyDeletionAsync(const ScheduleKeyDeletionRequestT& request, const ScheduleKeyDeletionResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KMSClient::ScheduleKeyDeletion, request, handler, context);
  }
 
  virtual Model::SignOutcome Sign(const Model::SignRequest& request) const;
 
  template <typename SignRequestT = Model::SignRequest>
  Model::SignOutcomeCallable SignCallable(const SignRequestT& request) const {
    return SubmitCallable(&KMSClient::Sign, request);
  }
 
  template <typename SignRequestT = Model::SignRequest>
  void SignAsync(const SignRequestT& request, const SignResponseReceivedHandler& handler,
                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KMSClient::Sign, 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(&KMSClient::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(&KMSClient::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(&KMSClient::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(&KMSClient::UntagResource, request, handler, context);
  }
 
  virtual Model::UpdateAliasOutcome UpdateAlias(const Model::UpdateAliasRequest& request) const;
 
  template <typename UpdateAliasRequestT = Model::UpdateAliasRequest>
  Model::UpdateAliasOutcomeCallable UpdateAliasCallable(const UpdateAliasRequestT& request) const {
    return SubmitCallable(&KMSClient::UpdateAlias, request);
  }
 
  template <typename UpdateAliasRequestT = Model::UpdateAliasRequest>
  void UpdateAliasAsync(const UpdateAliasRequestT& request, const UpdateAliasResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KMSClient::UpdateAlias, request, handler, context);
  }
 
  virtual Model::UpdateCustomKeyStoreOutcome UpdateCustomKeyStore(const Model::UpdateCustomKeyStoreRequest& request) const;
 
  template <typename UpdateCustomKeyStoreRequestT = Model::UpdateCustomKeyStoreRequest>
  Model::UpdateCustomKeyStoreOutcomeCallable UpdateCustomKeyStoreCallable(const UpdateCustomKeyStoreRequestT& request) const {
    return SubmitCallable(&KMSClient::UpdateCustomKeyStore, request);
  }
 
  template <typename UpdateCustomKeyStoreRequestT = Model::UpdateCustomKeyStoreRequest>
  void UpdateCustomKeyStoreAsync(const UpdateCustomKeyStoreRequestT& request, const UpdateCustomKeyStoreResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KMSClient::UpdateCustomKeyStore, request, handler, context);
  }
 
  virtual Model::UpdateKeyDescriptionOutcome UpdateKeyDescription(const Model::UpdateKeyDescriptionRequest& request) const;
 
  template <typename UpdateKeyDescriptionRequestT = Model::UpdateKeyDescriptionRequest>
  Model::UpdateKeyDescriptionOutcomeCallable UpdateKeyDescriptionCallable(const UpdateKeyDescriptionRequestT& request) const {
    return SubmitCallable(&KMSClient::UpdateKeyDescription, request);
  }
 
  template <typename UpdateKeyDescriptionRequestT = Model::UpdateKeyDescriptionRequest>
  void UpdateKeyDescriptionAsync(const UpdateKeyDescriptionRequestT& request, const UpdateKeyDescriptionResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KMSClient::UpdateKeyDescription, request, handler, context);
  }
 
  virtual Model::UpdatePrimaryRegionOutcome UpdatePrimaryRegion(const Model::UpdatePrimaryRegionRequest& request) const;
 
  template <typename UpdatePrimaryRegionRequestT = Model::UpdatePrimaryRegionRequest>
  Model::UpdatePrimaryRegionOutcomeCallable UpdatePrimaryRegionCallable(const UpdatePrimaryRegionRequestT& request) const {
    return SubmitCallable(&KMSClient::UpdatePrimaryRegion, request);
  }
 
  template <typename UpdatePrimaryRegionRequestT = Model::UpdatePrimaryRegionRequest>
  void UpdatePrimaryRegionAsync(const UpdatePrimaryRegionRequestT& request, const UpdatePrimaryRegionResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KMSClient::UpdatePrimaryRegion, request, handler, context);
  }
 
  virtual Model::VerifyOutcome Verify(const Model::VerifyRequest& request) const;
 
  template <typename VerifyRequestT = Model::VerifyRequest>
  Model::VerifyOutcomeCallable VerifyCallable(const VerifyRequestT& request) const {
    return SubmitCallable(&KMSClient::Verify, request);
  }
 
  template <typename VerifyRequestT = Model::VerifyRequest>
  void VerifyAsync(const VerifyRequestT& request, const VerifyResponseReceivedHandler& handler,
                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KMSClient::Verify, request, handler, context);
  }
 
  virtual Model::VerifyMacOutcome VerifyMac(const Model::VerifyMacRequest& request) const;
 
  template <typename VerifyMacRequestT = Model::VerifyMacRequest>
  Model::VerifyMacOutcomeCallable VerifyMacCallable(const VerifyMacRequestT& request) const {
    return SubmitCallable(&KMSClient::VerifyMac, request);
  }
 
  template <typename VerifyMacRequestT = Model::VerifyMacRequest>
  void VerifyMacAsync(const VerifyMacRequestT& request, const VerifyMacResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KMSClient::VerifyMac, request, handler, context);
  }
 
  void OverrideEndpoint(const Aws::String& endpoint);
  std::shared_ptr<KMSEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<KMSClient>;
  void init(const KMSClientConfiguration& clientConfiguration);
 
  KMSClientConfiguration m_clientConfiguration;
  std::shared_ptr<KMSEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace KMS
}  // namespace Aws