PaymentCryptographyClient.h

 
#pragma once
#include <aws/payment-cryptography/PaymentCryptography_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/payment-cryptography/PaymentCryptographyServiceClientModel.h>
 
namespace Aws
{
namespace PaymentCryptography
{
  class AWS_PAYMENTCRYPTOGRAPHY_API PaymentCryptographyClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<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::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::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::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::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);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<PaymentCryptographyEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<PaymentCryptographyClient>;
      void init(const PaymentCryptographyClientConfiguration& clientConfiguration);
 
      PaymentCryptographyClientConfiguration m_clientConfiguration;
      std::shared_ptr<PaymentCryptographyEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace PaymentCryptography
} // namespace Aws