ManagedBlockchainClient.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/managedblockchain/ManagedBlockchainPaginationBase.h>
#include <aws/managedblockchain/ManagedBlockchainServiceClientModel.h>
#include <aws/managedblockchain/ManagedBlockchainWaiter.h>
#include <aws/managedblockchain/ManagedBlockchain_EXPORTS.h>
 
namespace Aws {
namespace ManagedBlockchain {
class AWS_MANAGEDBLOCKCHAIN_API ManagedBlockchainClient : public Aws::Client::AWSJsonClient,
                                                          public Aws::Client::ClientWithAsyncTemplateMethods<ManagedBlockchainClient>,
                                                          public ManagedBlockchainPaginationBase<ManagedBlockchainClient>,
                                                          public ManagedBlockchainWaiter<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);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<ManagedBlockchainEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<ManagedBlockchainClient>;
  void init(const ManagedBlockchainClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, ManagedBlockchainError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request,
                                                const std::function<void(Aws::Endpoint::ResolveEndpointOutcome&)>& resolveUri,
                                                Aws::Http::HttpMethod httpMethod) const;
 
  ManagedBlockchainClientConfiguration m_clientConfiguration;
  std::shared_ptr<ManagedBlockchainEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace ManagedBlockchain
}  // namespace Aws