PaymentCryptographyClient.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/payment-cryptography/PaymentCryptographyPaginationBase.h>
#include <aws/payment-cryptography/PaymentCryptographyServiceClientModel.h>
#include <aws/payment-cryptography/PaymentCryptographyWaiter.h>
#include <aws/payment-cryptography/PaymentCryptography_EXPORTS.h>
 
namespace Aws {
namespace PaymentCryptography {
class AWS_PAYMENTCRYPTOGRAPHY_API PaymentCryptographyClient : public Aws::Client::AWSJsonClient,
                                                              public Aws::Client::ClientWithAsyncTemplateMethods<PaymentCryptographyClient>,
                                                              public PaymentCryptographyPaginationBase<PaymentCryptographyClient>,
                                                              public PaymentCryptographyWaiter<PaymentCryptographyClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef PaymentCryptographyClientConfiguration ClientConfigurationType;
  typedef PaymentCryptographyEndpointProvider EndpointProviderType;
 
  PaymentCryptographyClient(const Aws::PaymentCryptography::PaymentCryptographyClientConfiguration& clientConfiguration =
                                Aws::PaymentCryptography::PaymentCryptographyClientConfiguration(),
                            std::shared_ptr<PaymentCryptographyEndpointProviderBase> endpointProvider = nullptr);
 
  PaymentCryptographyClient(const Aws::Auth::AWSCredentials& credentials,
                            std::shared_ptr<PaymentCryptographyEndpointProviderBase> endpointProvider = nullptr,
                            const Aws::PaymentCryptography::PaymentCryptographyClientConfiguration& clientConfiguration =
                                Aws::PaymentCryptography::PaymentCryptographyClientConfiguration());
 
  PaymentCryptographyClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                            std::shared_ptr<PaymentCryptographyEndpointProviderBase> endpointProvider = nullptr,
                            const Aws::PaymentCryptography::PaymentCryptographyClientConfiguration& clientConfiguration =
                                Aws::PaymentCryptography::PaymentCryptographyClientConfiguration());
 
  /* Legacy constructors due deprecation */
  PaymentCryptographyClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  PaymentCryptographyClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  PaymentCryptographyClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                            const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~PaymentCryptographyClient();
 
  virtual Model::AddKeyReplicationRegionsOutcome AddKeyReplicationRegions(const Model::AddKeyReplicationRegionsRequest& request) const;
 
  template <typename AddKeyReplicationRegionsRequestT = Model::AddKeyReplicationRegionsRequest>
  Model::AddKeyReplicationRegionsOutcomeCallable AddKeyReplicationRegionsCallable(const AddKeyReplicationRegionsRequestT& request) const {
    return SubmitCallable(&PaymentCryptographyClient::AddKeyReplicationRegions, request);
  }
 
  template <typename AddKeyReplicationRegionsRequestT = Model::AddKeyReplicationRegionsRequest>
  void AddKeyReplicationRegionsAsync(const AddKeyReplicationRegionsRequestT& request,
                                     const AddKeyReplicationRegionsResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PaymentCryptographyClient::AddKeyReplicationRegions, 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(&PaymentCryptographyClient::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(&PaymentCryptographyClient::CreateAlias, 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(&PaymentCryptographyClient::CreateKey, request);
  }
 
  template <typename CreateKeyRequestT = Model::CreateKeyRequest>
  void CreateKeyAsync(const CreateKeyRequestT& request, const CreateKeyResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PaymentCryptographyClient::CreateKey, 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(&PaymentCryptographyClient::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(&PaymentCryptographyClient::DeleteAlias, request, handler, context);
  }
 
  virtual Model::DeleteKeyOutcome DeleteKey(const Model::DeleteKeyRequest& request) const;
 
  template <typename DeleteKeyRequestT = Model::DeleteKeyRequest>
  Model::DeleteKeyOutcomeCallable DeleteKeyCallable(const DeleteKeyRequestT& request) const {
    return SubmitCallable(&PaymentCryptographyClient::DeleteKey, request);
  }
 
  template <typename DeleteKeyRequestT = Model::DeleteKeyRequest>
  void DeleteKeyAsync(const DeleteKeyRequestT& request, const DeleteKeyResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PaymentCryptographyClient::DeleteKey, request, handler, context);
  }
 
  virtual Model::DisableDefaultKeyReplicationRegionsOutcome DisableDefaultKeyReplicationRegions(
      const Model::DisableDefaultKeyReplicationRegionsRequest& request) const;
 
  template <typename DisableDefaultKeyReplicationRegionsRequestT = Model::DisableDefaultKeyReplicationRegionsRequest>
  Model::DisableDefaultKeyReplicationRegionsOutcomeCallable DisableDefaultKeyReplicationRegionsCallable(
      const DisableDefaultKeyReplicationRegionsRequestT& request) const {
    return SubmitCallable(&PaymentCryptographyClient::DisableDefaultKeyReplicationRegions, request);
  }
 
  template <typename DisableDefaultKeyReplicationRegionsRequestT = Model::DisableDefaultKeyReplicationRegionsRequest>
  void DisableDefaultKeyReplicationRegionsAsync(const DisableDefaultKeyReplicationRegionsRequestT& request,
                                                const DisableDefaultKeyReplicationRegionsResponseReceivedHandler& handler,
                                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PaymentCryptographyClient::DisableDefaultKeyReplicationRegions, request, handler, context);
  }
 
  virtual Model::EnableDefaultKeyReplicationRegionsOutcome EnableDefaultKeyReplicationRegions(
      const Model::EnableDefaultKeyReplicationRegionsRequest& request) const;
 
  template <typename EnableDefaultKeyReplicationRegionsRequestT = Model::EnableDefaultKeyReplicationRegionsRequest>
  Model::EnableDefaultKeyReplicationRegionsOutcomeCallable EnableDefaultKeyReplicationRegionsCallable(
      const EnableDefaultKeyReplicationRegionsRequestT& request) const {
    return SubmitCallable(&PaymentCryptographyClient::EnableDefaultKeyReplicationRegions, request);
  }
 
  template <typename EnableDefaultKeyReplicationRegionsRequestT = Model::EnableDefaultKeyReplicationRegionsRequest>
  void EnableDefaultKeyReplicationRegionsAsync(const EnableDefaultKeyReplicationRegionsRequestT& request,
                                               const EnableDefaultKeyReplicationRegionsResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PaymentCryptographyClient::EnableDefaultKeyReplicationRegions, request, handler, context);
  }
 
  virtual Model::ExportKeyOutcome ExportKey(const Model::ExportKeyRequest& request) const;
 
  template <typename ExportKeyRequestT = Model::ExportKeyRequest>
  Model::ExportKeyOutcomeCallable ExportKeyCallable(const ExportKeyRequestT& request) const {
    return SubmitCallable(&PaymentCryptographyClient::ExportKey, request);
  }
 
  template <typename ExportKeyRequestT = Model::ExportKeyRequest>
  void ExportKeyAsync(const ExportKeyRequestT& request, const ExportKeyResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PaymentCryptographyClient::ExportKey, request, handler, context);
  }
 
  virtual Model::GetAliasOutcome GetAlias(const Model::GetAliasRequest& request) const;
 
  template <typename GetAliasRequestT = Model::GetAliasRequest>
  Model::GetAliasOutcomeCallable GetAliasCallable(const GetAliasRequestT& request) const {
    return SubmitCallable(&PaymentCryptographyClient::GetAlias, request);
  }
 
  template <typename GetAliasRequestT = Model::GetAliasRequest>
  void GetAliasAsync(const GetAliasRequestT& request, const GetAliasResponseReceivedHandler& handler,
                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PaymentCryptographyClient::GetAlias, request, handler, context);
  }
 
  virtual Model::GetCertificateSigningRequestOutcome GetCertificateSigningRequest(
      const Model::GetCertificateSigningRequestRequest& request) const;
 
  template <typename GetCertificateSigningRequestRequestT = Model::GetCertificateSigningRequestRequest>
  Model::GetCertificateSigningRequestOutcomeCallable GetCertificateSigningRequestCallable(
      const GetCertificateSigningRequestRequestT& request) const {
    return SubmitCallable(&PaymentCryptographyClient::GetCertificateSigningRequest, request);
  }
 
  template <typename GetCertificateSigningRequestRequestT = Model::GetCertificateSigningRequestRequest>
  void GetCertificateSigningRequestAsync(const GetCertificateSigningRequestRequestT& request,
                                         const GetCertificateSigningRequestResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PaymentCryptographyClient::GetCertificateSigningRequest, request, handler, context);
  }
 
  virtual Model::GetDefaultKeyReplicationRegionsOutcome GetDefaultKeyReplicationRegions(
      const Model::GetDefaultKeyReplicationRegionsRequest& request = {}) const;
 
  template <typename GetDefaultKeyReplicationRegionsRequestT = Model::GetDefaultKeyReplicationRegionsRequest>
  Model::GetDefaultKeyReplicationRegionsOutcomeCallable GetDefaultKeyReplicationRegionsCallable(
      const GetDefaultKeyReplicationRegionsRequestT& request = {}) const {
    return SubmitCallable(&PaymentCryptographyClient::GetDefaultKeyReplicationRegions, request);
  }
 
  template <typename GetDefaultKeyReplicationRegionsRequestT = Model::GetDefaultKeyReplicationRegionsRequest>
  void GetDefaultKeyReplicationRegionsAsync(const GetDefaultKeyReplicationRegionsResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                            const GetDefaultKeyReplicationRegionsRequestT& request = {}) const {
    return SubmitAsync(&PaymentCryptographyClient::GetDefaultKeyReplicationRegions, request, handler, context);
  }
 
  virtual Model::GetKeyOutcome GetKey(const Model::GetKeyRequest& request) const;
 
  template <typename GetKeyRequestT = Model::GetKeyRequest>
  Model::GetKeyOutcomeCallable GetKeyCallable(const GetKeyRequestT& request) const {
    return SubmitCallable(&PaymentCryptographyClient::GetKey, request);
  }
 
  template <typename GetKeyRequestT = Model::GetKeyRequest>
  void GetKeyAsync(const GetKeyRequestT& request, const GetKeyResponseReceivedHandler& handler,
                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PaymentCryptographyClient::GetKey, request, handler, context);
  }
 
  virtual Model::GetParametersForExportOutcome GetParametersForExport(const Model::GetParametersForExportRequest& request) const;
 
  template <typename GetParametersForExportRequestT = Model::GetParametersForExportRequest>
  Model::GetParametersForExportOutcomeCallable GetParametersForExportCallable(const GetParametersForExportRequestT& request) const {
    return SubmitCallable(&PaymentCryptographyClient::GetParametersForExport, request);
  }
 
  template <typename GetParametersForExportRequestT = Model::GetParametersForExportRequest>
  void GetParametersForExportAsync(const GetParametersForExportRequestT& request,
                                   const GetParametersForExportResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PaymentCryptographyClient::GetParametersForExport, 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(&PaymentCryptographyClient::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(&PaymentCryptographyClient::GetParametersForImport, request, handler, context);
  }
 
  virtual Model::GetPublicKeyCertificateOutcome GetPublicKeyCertificate(const Model::GetPublicKeyCertificateRequest& request) const;
 
  template <typename GetPublicKeyCertificateRequestT = Model::GetPublicKeyCertificateRequest>
  Model::GetPublicKeyCertificateOutcomeCallable GetPublicKeyCertificateCallable(const GetPublicKeyCertificateRequestT& request) const {
    return SubmitCallable(&PaymentCryptographyClient::GetPublicKeyCertificate, request);
  }
 
  template <typename GetPublicKeyCertificateRequestT = Model::GetPublicKeyCertificateRequest>
  void GetPublicKeyCertificateAsync(const GetPublicKeyCertificateRequestT& request,
                                    const GetPublicKeyCertificateResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PaymentCryptographyClient::GetPublicKeyCertificate, request, handler, context);
  }
 
  virtual Model::ImportKeyOutcome ImportKey(const Model::ImportKeyRequest& request) const;
 
  template <typename ImportKeyRequestT = Model::ImportKeyRequest>
  Model::ImportKeyOutcomeCallable ImportKeyCallable(const ImportKeyRequestT& request) const {
    return SubmitCallable(&PaymentCryptographyClient::ImportKey, request);
  }
 
  template <typename ImportKeyRequestT = Model::ImportKeyRequest>
  void ImportKeyAsync(const ImportKeyRequestT& request, const ImportKeyResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PaymentCryptographyClient::ImportKey, 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(&PaymentCryptographyClient::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(&PaymentCryptographyClient::ListAliases, 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(&PaymentCryptographyClient::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(&PaymentCryptographyClient::ListKeys, 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(&PaymentCryptographyClient::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(&PaymentCryptographyClient::ListTagsForResource, request, handler, context);
  }
 
  virtual Model::RemoveKeyReplicationRegionsOutcome RemoveKeyReplicationRegions(
      const Model::RemoveKeyReplicationRegionsRequest& request) const;
 
  template <typename RemoveKeyReplicationRegionsRequestT = Model::RemoveKeyReplicationRegionsRequest>
  Model::RemoveKeyReplicationRegionsOutcomeCallable RemoveKeyReplicationRegionsCallable(
      const RemoveKeyReplicationRegionsRequestT& request) const {
    return SubmitCallable(&PaymentCryptographyClient::RemoveKeyReplicationRegions, request);
  }
 
  template <typename RemoveKeyReplicationRegionsRequestT = Model::RemoveKeyReplicationRegionsRequest>
  void RemoveKeyReplicationRegionsAsync(const RemoveKeyReplicationRegionsRequestT& request,
                                        const RemoveKeyReplicationRegionsResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PaymentCryptographyClient::RemoveKeyReplicationRegions, request, handler, context);
  }
 
  virtual Model::RestoreKeyOutcome RestoreKey(const Model::RestoreKeyRequest& request) const;
 
  template <typename RestoreKeyRequestT = Model::RestoreKeyRequest>
  Model::RestoreKeyOutcomeCallable RestoreKeyCallable(const RestoreKeyRequestT& request) const {
    return SubmitCallable(&PaymentCryptographyClient::RestoreKey, request);
  }
 
  template <typename RestoreKeyRequestT = Model::RestoreKeyRequest>
  void RestoreKeyAsync(const RestoreKeyRequestT& request, const RestoreKeyResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PaymentCryptographyClient::RestoreKey, request, handler, context);
  }
 
  virtual Model::StartKeyUsageOutcome StartKeyUsage(const Model::StartKeyUsageRequest& request) const;
 
  template <typename StartKeyUsageRequestT = Model::StartKeyUsageRequest>
  Model::StartKeyUsageOutcomeCallable StartKeyUsageCallable(const StartKeyUsageRequestT& request) const {
    return SubmitCallable(&PaymentCryptographyClient::StartKeyUsage, request);
  }
 
  template <typename StartKeyUsageRequestT = Model::StartKeyUsageRequest>
  void StartKeyUsageAsync(const StartKeyUsageRequestT& request, const StartKeyUsageResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PaymentCryptographyClient::StartKeyUsage, request, handler, context);
  }
 
  virtual Model::StopKeyUsageOutcome StopKeyUsage(const Model::StopKeyUsageRequest& request) const;
 
  template <typename StopKeyUsageRequestT = Model::StopKeyUsageRequest>
  Model::StopKeyUsageOutcomeCallable StopKeyUsageCallable(const StopKeyUsageRequestT& request) const {
    return SubmitCallable(&PaymentCryptographyClient::StopKeyUsage, request);
  }
 
  template <typename StopKeyUsageRequestT = Model::StopKeyUsageRequest>
  void StopKeyUsageAsync(const StopKeyUsageRequestT& request, const StopKeyUsageResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PaymentCryptographyClient::StopKeyUsage, 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(&PaymentCryptographyClient::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(&PaymentCryptographyClient::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(&PaymentCryptographyClient::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(&PaymentCryptographyClient::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(&PaymentCryptographyClient::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(&PaymentCryptographyClient::UpdateAlias, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<PaymentCryptographyEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<PaymentCryptographyClient>;
  void init(const PaymentCryptographyClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, PaymentCryptographyError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request, Aws::Http::HttpMethod httpMethod) const;
 
  PaymentCryptographyClientConfiguration m_clientConfiguration;
  std::shared_ptr<PaymentCryptographyEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace PaymentCryptography
}  // namespace Aws