ManagedBlockchainClient.h

 
#pragma once
#include <aws/managedblockchain/ManagedBlockchain_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/managedblockchain/ManagedBlockchainServiceClientModel.h>
 
namespace Aws
{
namespace ManagedBlockchain
{
  class AWS_MANAGEDBLOCKCHAIN_API ManagedBlockchainClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<ManagedBlockchainClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef ManagedBlockchainClientConfiguration ClientConfigurationType;
      typedef ManagedBlockchainEndpointProvider EndpointProviderType;
 
        ManagedBlockchainClient(const Aws::ManagedBlockchain::ManagedBlockchainClientConfiguration& clientConfiguration = Aws::ManagedBlockchain::ManagedBlockchainClientConfiguration(),
                                std::shared_ptr<ManagedBlockchainEndpointProviderBase> endpointProvider = nullptr);
 
        ManagedBlockchainClient(const Aws::Auth::AWSCredentials& credentials,
                                std::shared_ptr<ManagedBlockchainEndpointProviderBase> endpointProvider = nullptr,
                                const Aws::ManagedBlockchain::ManagedBlockchainClientConfiguration& clientConfiguration = Aws::ManagedBlockchain::ManagedBlockchainClientConfiguration());
 
        ManagedBlockchainClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                                std::shared_ptr<ManagedBlockchainEndpointProviderBase> endpointProvider = nullptr,
                                const Aws::ManagedBlockchain::ManagedBlockchainClientConfiguration& clientConfiguration = Aws::ManagedBlockchain::ManagedBlockchainClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        ManagedBlockchainClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        ManagedBlockchainClient(const Aws::Auth::AWSCredentials& credentials,
                                const Aws::Client::ClientConfiguration& clientConfiguration);
 
        ManagedBlockchainClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                                const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~ManagedBlockchainClient();
 
        virtual Model::CreateAccessorOutcome CreateAccessor(const Model::CreateAccessorRequest& request) const;
 
        template<typename CreateAccessorRequestT = Model::CreateAccessorRequest>
        Model::CreateAccessorOutcomeCallable CreateAccessorCallable(const CreateAccessorRequestT& request) const
        {
            return SubmitCallable(&ManagedBlockchainClient::CreateAccessor, request);
        }
 
        template<typename CreateAccessorRequestT = Model::CreateAccessorRequest>
        void CreateAccessorAsync(const CreateAccessorRequestT& request, const CreateAccessorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ManagedBlockchainClient::CreateAccessor, request, handler, context);
        }
 
        virtual Model::CreateMemberOutcome CreateMember(const Model::CreateMemberRequest& request) const;
 
        template<typename CreateMemberRequestT = Model::CreateMemberRequest>
        Model::CreateMemberOutcomeCallable CreateMemberCallable(const CreateMemberRequestT& request) const
        {
            return SubmitCallable(&ManagedBlockchainClient::CreateMember, request);
        }
 
        template<typename CreateMemberRequestT = Model::CreateMemberRequest>
        void CreateMemberAsync(const CreateMemberRequestT& request, const CreateMemberResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ManagedBlockchainClient::CreateMember, request, handler, context);
        }
 
        virtual Model::CreateNetworkOutcome CreateNetwork(const Model::CreateNetworkRequest& request) const;
 
        template<typename CreateNetworkRequestT = Model::CreateNetworkRequest>
        Model::CreateNetworkOutcomeCallable CreateNetworkCallable(const CreateNetworkRequestT& request) const
        {
            return SubmitCallable(&ManagedBlockchainClient::CreateNetwork, request);
        }
 
        template<typename CreateNetworkRequestT = Model::CreateNetworkRequest>
        void CreateNetworkAsync(const CreateNetworkRequestT& request, const CreateNetworkResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ManagedBlockchainClient::CreateNetwork, request, handler, context);
        }
 
        virtual Model::CreateNodeOutcome CreateNode(const Model::CreateNodeRequest& request) const;
 
        template<typename CreateNodeRequestT = Model::CreateNodeRequest>
        Model::CreateNodeOutcomeCallable CreateNodeCallable(const CreateNodeRequestT& request) const
        {
            return SubmitCallable(&ManagedBlockchainClient::CreateNode, request);
        }
 
        template<typename CreateNodeRequestT = Model::CreateNodeRequest>
        void CreateNodeAsync(const CreateNodeRequestT& request, const CreateNodeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ManagedBlockchainClient::CreateNode, request, handler, context);
        }
 
        virtual Model::CreateProposalOutcome CreateProposal(const Model::CreateProposalRequest& request) const;
 
        template<typename CreateProposalRequestT = Model::CreateProposalRequest>
        Model::CreateProposalOutcomeCallable CreateProposalCallable(const CreateProposalRequestT& request) const
        {
            return SubmitCallable(&ManagedBlockchainClient::CreateProposal, request);
        }
 
        template<typename CreateProposalRequestT = Model::CreateProposalRequest>
        void CreateProposalAsync(const CreateProposalRequestT& request, const CreateProposalResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ManagedBlockchainClient::CreateProposal, request, handler, context);
        }
 
        virtual Model::DeleteAccessorOutcome DeleteAccessor(const Model::DeleteAccessorRequest& request) const;
 
        template<typename DeleteAccessorRequestT = Model::DeleteAccessorRequest>
        Model::DeleteAccessorOutcomeCallable DeleteAccessorCallable(const DeleteAccessorRequestT& request) const
        {
            return SubmitCallable(&ManagedBlockchainClient::DeleteAccessor, request);
        }
 
        template<typename DeleteAccessorRequestT = Model::DeleteAccessorRequest>
        void DeleteAccessorAsync(const DeleteAccessorRequestT& request, const DeleteAccessorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ManagedBlockchainClient::DeleteAccessor, request, handler, context);
        }
 
        virtual Model::DeleteMemberOutcome DeleteMember(const Model::DeleteMemberRequest& request) const;
 
        template<typename DeleteMemberRequestT = Model::DeleteMemberRequest>
        Model::DeleteMemberOutcomeCallable DeleteMemberCallable(const DeleteMemberRequestT& request) const
        {
            return SubmitCallable(&ManagedBlockchainClient::DeleteMember, request);
        }
 
        template<typename DeleteMemberRequestT = Model::DeleteMemberRequest>
        void DeleteMemberAsync(const DeleteMemberRequestT& request, const DeleteMemberResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ManagedBlockchainClient::DeleteMember, request, handler, context);
        }
 
        virtual Model::DeleteNodeOutcome DeleteNode(const Model::DeleteNodeRequest& request) const;
 
        template<typename DeleteNodeRequestT = Model::DeleteNodeRequest>
        Model::DeleteNodeOutcomeCallable DeleteNodeCallable(const DeleteNodeRequestT& request) const
        {
            return SubmitCallable(&ManagedBlockchainClient::DeleteNode, request);
        }
 
        template<typename DeleteNodeRequestT = Model::DeleteNodeRequest>
        void DeleteNodeAsync(const DeleteNodeRequestT& request, const DeleteNodeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ManagedBlockchainClient::DeleteNode, request, handler, context);
        }
 
        virtual Model::GetAccessorOutcome GetAccessor(const Model::GetAccessorRequest& request) const;
 
        template<typename GetAccessorRequestT = Model::GetAccessorRequest>
        Model::GetAccessorOutcomeCallable GetAccessorCallable(const GetAccessorRequestT& request) const
        {
            return SubmitCallable(&ManagedBlockchainClient::GetAccessor, request);
        }
 
        template<typename GetAccessorRequestT = Model::GetAccessorRequest>
        void GetAccessorAsync(const GetAccessorRequestT& request, const GetAccessorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ManagedBlockchainClient::GetAccessor, request, handler, context);
        }
 
        virtual Model::GetMemberOutcome GetMember(const Model::GetMemberRequest& request) const;
 
        template<typename GetMemberRequestT = Model::GetMemberRequest>
        Model::GetMemberOutcomeCallable GetMemberCallable(const GetMemberRequestT& request) const
        {
            return SubmitCallable(&ManagedBlockchainClient::GetMember, request);
        }
 
        template<typename GetMemberRequestT = Model::GetMemberRequest>
        void GetMemberAsync(const GetMemberRequestT& request, const GetMemberResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ManagedBlockchainClient::GetMember, request, handler, context);
        }
 
        virtual Model::GetNetworkOutcome GetNetwork(const Model::GetNetworkRequest& request) const;
 
        template<typename GetNetworkRequestT = Model::GetNetworkRequest>
        Model::GetNetworkOutcomeCallable GetNetworkCallable(const GetNetworkRequestT& request) const
        {
            return SubmitCallable(&ManagedBlockchainClient::GetNetwork, request);
        }
 
        template<typename GetNetworkRequestT = Model::GetNetworkRequest>
        void GetNetworkAsync(const GetNetworkRequestT& request, const GetNetworkResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ManagedBlockchainClient::GetNetwork, request, handler, context);
        }
 
        virtual Model::GetNodeOutcome GetNode(const Model::GetNodeRequest& request) const;
 
        template<typename GetNodeRequestT = Model::GetNodeRequest>
        Model::GetNodeOutcomeCallable GetNodeCallable(const GetNodeRequestT& request) const
        {
            return SubmitCallable(&ManagedBlockchainClient::GetNode, request);
        }
 
        template<typename GetNodeRequestT = Model::GetNodeRequest>
        void GetNodeAsync(const GetNodeRequestT& request, const GetNodeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ManagedBlockchainClient::GetNode, request, handler, context);
        }
 
        virtual Model::GetProposalOutcome GetProposal(const Model::GetProposalRequest& request) const;
 
        template<typename GetProposalRequestT = Model::GetProposalRequest>
        Model::GetProposalOutcomeCallable GetProposalCallable(const GetProposalRequestT& request) const
        {
            return SubmitCallable(&ManagedBlockchainClient::GetProposal, request);
        }
 
        template<typename GetProposalRequestT = Model::GetProposalRequest>
        void GetProposalAsync(const GetProposalRequestT& request, const GetProposalResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ManagedBlockchainClient::GetProposal, request, handler, context);
        }
 
        virtual Model::ListAccessorsOutcome ListAccessors(const Model::ListAccessorsRequest& request = {}) const;
 
        template<typename ListAccessorsRequestT = Model::ListAccessorsRequest>
        Model::ListAccessorsOutcomeCallable ListAccessorsCallable(const ListAccessorsRequestT& request = {}) const
        {
            return SubmitCallable(&ManagedBlockchainClient::ListAccessors, request);
        }
 
        template<typename ListAccessorsRequestT = Model::ListAccessorsRequest>
        void ListAccessorsAsync(const ListAccessorsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListAccessorsRequestT& request = {}) const
        {
            return SubmitAsync(&ManagedBlockchainClient::ListAccessors, request, handler, context);
        }
 
        virtual Model::ListInvitationsOutcome ListInvitations(const Model::ListInvitationsRequest& request = {}) const;
 
        template<typename ListInvitationsRequestT = Model::ListInvitationsRequest>
        Model::ListInvitationsOutcomeCallable ListInvitationsCallable(const ListInvitationsRequestT& request = {}) const
        {
            return SubmitCallable(&ManagedBlockchainClient::ListInvitations, request);
        }
 
        template<typename ListInvitationsRequestT = Model::ListInvitationsRequest>
        void ListInvitationsAsync(const ListInvitationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListInvitationsRequestT& request = {}) const
        {
            return SubmitAsync(&ManagedBlockchainClient::ListInvitations, request, handler, context);
        }
 
        virtual Model::ListMembersOutcome ListMembers(const Model::ListMembersRequest& request) const;
 
        template<typename ListMembersRequestT = Model::ListMembersRequest>
        Model::ListMembersOutcomeCallable ListMembersCallable(const ListMembersRequestT& request) const
        {
            return SubmitCallable(&ManagedBlockchainClient::ListMembers, request);
        }
 
        template<typename ListMembersRequestT = Model::ListMembersRequest>
        void ListMembersAsync(const ListMembersRequestT& request, const ListMembersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ManagedBlockchainClient::ListMembers, request, handler, context);
        }
 
        virtual Model::ListNetworksOutcome ListNetworks(const Model::ListNetworksRequest& request = {}) const;
 
        template<typename ListNetworksRequestT = Model::ListNetworksRequest>
        Model::ListNetworksOutcomeCallable ListNetworksCallable(const ListNetworksRequestT& request = {}) const
        {
            return SubmitCallable(&ManagedBlockchainClient::ListNetworks, request);
        }
 
        template<typename ListNetworksRequestT = Model::ListNetworksRequest>
        void ListNetworksAsync(const ListNetworksResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListNetworksRequestT& request = {}) const
        {
            return SubmitAsync(&ManagedBlockchainClient::ListNetworks, request, handler, context);
        }
 
        virtual Model::ListNodesOutcome ListNodes(const Model::ListNodesRequest& request) const;
 
        template<typename ListNodesRequestT = Model::ListNodesRequest>
        Model::ListNodesOutcomeCallable ListNodesCallable(const ListNodesRequestT& request) const
        {
            return SubmitCallable(&ManagedBlockchainClient::ListNodes, request);
        }
 
        template<typename ListNodesRequestT = Model::ListNodesRequest>
        void ListNodesAsync(const ListNodesRequestT& request, const ListNodesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ManagedBlockchainClient::ListNodes, request, handler, context);
        }
 
        virtual Model::ListProposalVotesOutcome ListProposalVotes(const Model::ListProposalVotesRequest& request) const;
 
        template<typename ListProposalVotesRequestT = Model::ListProposalVotesRequest>
        Model::ListProposalVotesOutcomeCallable ListProposalVotesCallable(const ListProposalVotesRequestT& request) const
        {
            return SubmitCallable(&ManagedBlockchainClient::ListProposalVotes, request);
        }
 
        template<typename ListProposalVotesRequestT = Model::ListProposalVotesRequest>
        void ListProposalVotesAsync(const ListProposalVotesRequestT& request, const ListProposalVotesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ManagedBlockchainClient::ListProposalVotes, request, handler, context);
        }
 
        virtual Model::ListProposalsOutcome ListProposals(const Model::ListProposalsRequest& request) const;
 
        template<typename ListProposalsRequestT = Model::ListProposalsRequest>
        Model::ListProposalsOutcomeCallable ListProposalsCallable(const ListProposalsRequestT& request) const
        {
            return SubmitCallable(&ManagedBlockchainClient::ListProposals, request);
        }
 
        template<typename ListProposalsRequestT = Model::ListProposalsRequest>
        void ListProposalsAsync(const ListProposalsRequestT& request, const ListProposalsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ManagedBlockchainClient::ListProposals, 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(&ManagedBlockchainClient::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(&ManagedBlockchainClient::ListTagsForResource, request, handler, context);
        }
 
        virtual Model::RejectInvitationOutcome RejectInvitation(const Model::RejectInvitationRequest& request) const;
 
        template<typename RejectInvitationRequestT = Model::RejectInvitationRequest>
        Model::RejectInvitationOutcomeCallable RejectInvitationCallable(const RejectInvitationRequestT& request) const
        {
            return SubmitCallable(&ManagedBlockchainClient::RejectInvitation, request);
        }
 
        template<typename RejectInvitationRequestT = Model::RejectInvitationRequest>
        void RejectInvitationAsync(const RejectInvitationRequestT& request, const RejectInvitationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ManagedBlockchainClient::RejectInvitation, 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(&ManagedBlockchainClient::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(&ManagedBlockchainClient::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(&ManagedBlockchainClient::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(&ManagedBlockchainClient::UntagResource, request, handler, context);
        }
 
        virtual Model::UpdateMemberOutcome UpdateMember(const Model::UpdateMemberRequest& request) const;
 
        template<typename UpdateMemberRequestT = Model::UpdateMemberRequest>
        Model::UpdateMemberOutcomeCallable UpdateMemberCallable(const UpdateMemberRequestT& request) const
        {
            return SubmitCallable(&ManagedBlockchainClient::UpdateMember, request);
        }
 
        template<typename UpdateMemberRequestT = Model::UpdateMemberRequest>
        void UpdateMemberAsync(const UpdateMemberRequestT& request, const UpdateMemberResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ManagedBlockchainClient::UpdateMember, request, handler, context);
        }
 
        virtual Model::UpdateNodeOutcome UpdateNode(const Model::UpdateNodeRequest& request) const;
 
        template<typename UpdateNodeRequestT = Model::UpdateNodeRequest>
        Model::UpdateNodeOutcomeCallable UpdateNodeCallable(const UpdateNodeRequestT& request) const
        {
            return SubmitCallable(&ManagedBlockchainClient::UpdateNode, request);
        }
 
        template<typename UpdateNodeRequestT = Model::UpdateNodeRequest>
        void UpdateNodeAsync(const UpdateNodeRequestT& request, const UpdateNodeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ManagedBlockchainClient::UpdateNode, request, handler, context);
        }
 
        virtual Model::VoteOnProposalOutcome VoteOnProposal(const Model::VoteOnProposalRequest& request) const;
 
        template<typename VoteOnProposalRequestT = Model::VoteOnProposalRequest>
        Model::VoteOnProposalOutcomeCallable VoteOnProposalCallable(const VoteOnProposalRequestT& request) const
        {
            return SubmitCallable(&ManagedBlockchainClient::VoteOnProposal, request);
        }
 
        template<typename VoteOnProposalRequestT = Model::VoteOnProposalRequest>
        void VoteOnProposalAsync(const VoteOnProposalRequestT& request, const VoteOnProposalResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ManagedBlockchainClient::VoteOnProposal, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<ManagedBlockchainEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<ManagedBlockchainClient>;
      void init(const ManagedBlockchainClientConfiguration& clientConfiguration);
 
      ManagedBlockchainClientConfiguration m_clientConfiguration;
      std::shared_ptr<ManagedBlockchainEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace ManagedBlockchain
} // namespace Aws