SignerClient.h

 
#pragma once
#include <aws/signer/Signer_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/signer/SignerServiceClientModel.h>
 
namespace Aws
{
namespace signer
{
  class AWS_SIGNER_API SignerClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<SignerClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef SignerClientConfiguration ClientConfigurationType;
      typedef SignerEndpointProvider EndpointProviderType;
 
        SignerClient(const Aws::signer::SignerClientConfiguration& clientConfiguration = Aws::signer::SignerClientConfiguration(),
                     std::shared_ptr<SignerEndpointProviderBase> endpointProvider = nullptr);
 
        SignerClient(const Aws::Auth::AWSCredentials& credentials,
                     std::shared_ptr<SignerEndpointProviderBase> endpointProvider = nullptr,
                     const Aws::signer::SignerClientConfiguration& clientConfiguration = Aws::signer::SignerClientConfiguration());
 
        SignerClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                     std::shared_ptr<SignerEndpointProviderBase> endpointProvider = nullptr,
                     const Aws::signer::SignerClientConfiguration& clientConfiguration = Aws::signer::SignerClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        SignerClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        SignerClient(const Aws::Auth::AWSCredentials& credentials,
                     const Aws::Client::ClientConfiguration& clientConfiguration);
 
        SignerClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                     const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~SignerClient();
 
        virtual Model::AddProfilePermissionOutcome AddProfilePermission(const Model::AddProfilePermissionRequest& request) const;
 
        template<typename AddProfilePermissionRequestT = Model::AddProfilePermissionRequest>
        Model::AddProfilePermissionOutcomeCallable AddProfilePermissionCallable(const AddProfilePermissionRequestT& request) const
        {
            return SubmitCallable(&SignerClient::AddProfilePermission, request);
        }
 
        template<typename AddProfilePermissionRequestT = Model::AddProfilePermissionRequest>
        void AddProfilePermissionAsync(const AddProfilePermissionRequestT& request, const AddProfilePermissionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SignerClient::AddProfilePermission, request, handler, context);
        }
 
        virtual Model::CancelSigningProfileOutcome CancelSigningProfile(const Model::CancelSigningProfileRequest& request) const;
 
        template<typename CancelSigningProfileRequestT = Model::CancelSigningProfileRequest>
        Model::CancelSigningProfileOutcomeCallable CancelSigningProfileCallable(const CancelSigningProfileRequestT& request) const
        {
            return SubmitCallable(&SignerClient::CancelSigningProfile, request);
        }
 
        template<typename CancelSigningProfileRequestT = Model::CancelSigningProfileRequest>
        void CancelSigningProfileAsync(const CancelSigningProfileRequestT& request, const CancelSigningProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SignerClient::CancelSigningProfile, request, handler, context);
        }
 
        virtual Model::DescribeSigningJobOutcome DescribeSigningJob(const Model::DescribeSigningJobRequest& request) const;
 
        template<typename DescribeSigningJobRequestT = Model::DescribeSigningJobRequest>
        Model::DescribeSigningJobOutcomeCallable DescribeSigningJobCallable(const DescribeSigningJobRequestT& request) const
        {
            return SubmitCallable(&SignerClient::DescribeSigningJob, request);
        }
 
        template<typename DescribeSigningJobRequestT = Model::DescribeSigningJobRequest>
        void DescribeSigningJobAsync(const DescribeSigningJobRequestT& request, const DescribeSigningJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SignerClient::DescribeSigningJob, request, handler, context);
        }
 
        virtual Model::GetRevocationStatusOutcome GetRevocationStatus(const Model::GetRevocationStatusRequest& request) const;
 
        template<typename GetRevocationStatusRequestT = Model::GetRevocationStatusRequest>
        Model::GetRevocationStatusOutcomeCallable GetRevocationStatusCallable(const GetRevocationStatusRequestT& request) const
        {
            return SubmitCallable(&SignerClient::GetRevocationStatus, request);
        }
 
        template<typename GetRevocationStatusRequestT = Model::GetRevocationStatusRequest>
        void GetRevocationStatusAsync(const GetRevocationStatusRequestT& request, const GetRevocationStatusResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SignerClient::GetRevocationStatus, request, handler, context);
        }
 
        virtual Model::GetSigningPlatformOutcome GetSigningPlatform(const Model::GetSigningPlatformRequest& request) const;
 
        template<typename GetSigningPlatformRequestT = Model::GetSigningPlatformRequest>
        Model::GetSigningPlatformOutcomeCallable GetSigningPlatformCallable(const GetSigningPlatformRequestT& request) const
        {
            return SubmitCallable(&SignerClient::GetSigningPlatform, request);
        }
 
        template<typename GetSigningPlatformRequestT = Model::GetSigningPlatformRequest>
        void GetSigningPlatformAsync(const GetSigningPlatformRequestT& request, const GetSigningPlatformResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SignerClient::GetSigningPlatform, request, handler, context);
        }
 
        virtual Model::GetSigningProfileOutcome GetSigningProfile(const Model::GetSigningProfileRequest& request) const;
 
        template<typename GetSigningProfileRequestT = Model::GetSigningProfileRequest>
        Model::GetSigningProfileOutcomeCallable GetSigningProfileCallable(const GetSigningProfileRequestT& request) const
        {
            return SubmitCallable(&SignerClient::GetSigningProfile, request);
        }
 
        template<typename GetSigningProfileRequestT = Model::GetSigningProfileRequest>
        void GetSigningProfileAsync(const GetSigningProfileRequestT& request, const GetSigningProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SignerClient::GetSigningProfile, request, handler, context);
        }
 
        virtual Model::ListProfilePermissionsOutcome ListProfilePermissions(const Model::ListProfilePermissionsRequest& request) const;
 
        template<typename ListProfilePermissionsRequestT = Model::ListProfilePermissionsRequest>
        Model::ListProfilePermissionsOutcomeCallable ListProfilePermissionsCallable(const ListProfilePermissionsRequestT& request) const
        {
            return SubmitCallable(&SignerClient::ListProfilePermissions, request);
        }
 
        template<typename ListProfilePermissionsRequestT = Model::ListProfilePermissionsRequest>
        void ListProfilePermissionsAsync(const ListProfilePermissionsRequestT& request, const ListProfilePermissionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SignerClient::ListProfilePermissions, request, handler, context);
        }
 
        virtual Model::ListSigningJobsOutcome ListSigningJobs(const Model::ListSigningJobsRequest& request = {}) const;
 
        template<typename ListSigningJobsRequestT = Model::ListSigningJobsRequest>
        Model::ListSigningJobsOutcomeCallable ListSigningJobsCallable(const ListSigningJobsRequestT& request = {}) const
        {
            return SubmitCallable(&SignerClient::ListSigningJobs, request);
        }
 
        template<typename ListSigningJobsRequestT = Model::ListSigningJobsRequest>
        void ListSigningJobsAsync(const ListSigningJobsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListSigningJobsRequestT& request = {}) const
        {
            return SubmitAsync(&SignerClient::ListSigningJobs, request, handler, context);
        }
 
        virtual Model::ListSigningPlatformsOutcome ListSigningPlatforms(const Model::ListSigningPlatformsRequest& request = {}) const;
 
        template<typename ListSigningPlatformsRequestT = Model::ListSigningPlatformsRequest>
        Model::ListSigningPlatformsOutcomeCallable ListSigningPlatformsCallable(const ListSigningPlatformsRequestT& request = {}) const
        {
            return SubmitCallable(&SignerClient::ListSigningPlatforms, request);
        }
 
        template<typename ListSigningPlatformsRequestT = Model::ListSigningPlatformsRequest>
        void ListSigningPlatformsAsync(const ListSigningPlatformsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListSigningPlatformsRequestT& request = {}) const
        {
            return SubmitAsync(&SignerClient::ListSigningPlatforms, request, handler, context);
        }
 
        virtual Model::ListSigningProfilesOutcome ListSigningProfiles(const Model::ListSigningProfilesRequest& request = {}) const;
 
        template<typename ListSigningProfilesRequestT = Model::ListSigningProfilesRequest>
        Model::ListSigningProfilesOutcomeCallable ListSigningProfilesCallable(const ListSigningProfilesRequestT& request = {}) const
        {
            return SubmitCallable(&SignerClient::ListSigningProfiles, request);
        }
 
        template<typename ListSigningProfilesRequestT = Model::ListSigningProfilesRequest>
        void ListSigningProfilesAsync(const ListSigningProfilesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListSigningProfilesRequestT& request = {}) const
        {
            return SubmitAsync(&SignerClient::ListSigningProfiles, 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(&SignerClient::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(&SignerClient::ListTagsForResource, request, handler, context);
        }
 
        virtual Model::PutSigningProfileOutcome PutSigningProfile(const Model::PutSigningProfileRequest& request) const;
 
        template<typename PutSigningProfileRequestT = Model::PutSigningProfileRequest>
        Model::PutSigningProfileOutcomeCallable PutSigningProfileCallable(const PutSigningProfileRequestT& request) const
        {
            return SubmitCallable(&SignerClient::PutSigningProfile, request);
        }
 
        template<typename PutSigningProfileRequestT = Model::PutSigningProfileRequest>
        void PutSigningProfileAsync(const PutSigningProfileRequestT& request, const PutSigningProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SignerClient::PutSigningProfile, request, handler, context);
        }
 
        virtual Model::RemoveProfilePermissionOutcome RemoveProfilePermission(const Model::RemoveProfilePermissionRequest& request) const;
 
        template<typename RemoveProfilePermissionRequestT = Model::RemoveProfilePermissionRequest>
        Model::RemoveProfilePermissionOutcomeCallable RemoveProfilePermissionCallable(const RemoveProfilePermissionRequestT& request) const
        {
            return SubmitCallable(&SignerClient::RemoveProfilePermission, request);
        }
 
        template<typename RemoveProfilePermissionRequestT = Model::RemoveProfilePermissionRequest>
        void RemoveProfilePermissionAsync(const RemoveProfilePermissionRequestT& request, const RemoveProfilePermissionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SignerClient::RemoveProfilePermission, request, handler, context);
        }
 
        virtual Model::RevokeSignatureOutcome RevokeSignature(const Model::RevokeSignatureRequest& request) const;
 
        template<typename RevokeSignatureRequestT = Model::RevokeSignatureRequest>
        Model::RevokeSignatureOutcomeCallable RevokeSignatureCallable(const RevokeSignatureRequestT& request) const
        {
            return SubmitCallable(&SignerClient::RevokeSignature, request);
        }
 
        template<typename RevokeSignatureRequestT = Model::RevokeSignatureRequest>
        void RevokeSignatureAsync(const RevokeSignatureRequestT& request, const RevokeSignatureResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SignerClient::RevokeSignature, request, handler, context);
        }
 
        virtual Model::RevokeSigningProfileOutcome RevokeSigningProfile(const Model::RevokeSigningProfileRequest& request) const;
 
        template<typename RevokeSigningProfileRequestT = Model::RevokeSigningProfileRequest>
        Model::RevokeSigningProfileOutcomeCallable RevokeSigningProfileCallable(const RevokeSigningProfileRequestT& request) const
        {
            return SubmitCallable(&SignerClient::RevokeSigningProfile, request);
        }
 
        template<typename RevokeSigningProfileRequestT = Model::RevokeSigningProfileRequest>
        void RevokeSigningProfileAsync(const RevokeSigningProfileRequestT& request, const RevokeSigningProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SignerClient::RevokeSigningProfile, request, handler, context);
        }
 
        virtual Model::SignPayloadOutcome SignPayload(const Model::SignPayloadRequest& request) const;
 
        template<typename SignPayloadRequestT = Model::SignPayloadRequest>
        Model::SignPayloadOutcomeCallable SignPayloadCallable(const SignPayloadRequestT& request) const
        {
            return SubmitCallable(&SignerClient::SignPayload, request);
        }
 
        template<typename SignPayloadRequestT = Model::SignPayloadRequest>
        void SignPayloadAsync(const SignPayloadRequestT& request, const SignPayloadResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SignerClient::SignPayload, request, handler, context);
        }
 
        virtual Model::StartSigningJobOutcome StartSigningJob(const Model::StartSigningJobRequest& request) const;
 
        template<typename StartSigningJobRequestT = Model::StartSigningJobRequest>
        Model::StartSigningJobOutcomeCallable StartSigningJobCallable(const StartSigningJobRequestT& request) const
        {
            return SubmitCallable(&SignerClient::StartSigningJob, request);
        }
 
        template<typename StartSigningJobRequestT = Model::StartSigningJobRequest>
        void StartSigningJobAsync(const StartSigningJobRequestT& request, const StartSigningJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SignerClient::StartSigningJob, 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(&SignerClient::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(&SignerClient::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(&SignerClient::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(&SignerClient::UntagResource, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<SignerEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<SignerClient>;
      void init(const SignerClientConfiguration& clientConfiguration);
 
      SignerClientConfiguration m_clientConfiguration;
      std::shared_ptr<SignerEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace signer
} // namespace Aws