KMSClient.h

 
#pragma once
#include <aws/kms/KMS_EXPORTS.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/kms/KMSServiceClientModel.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