software.amazon.awssdk.services.managedblockchain.ManagedBlockchainAsyncClient Maven / Gradle / Ivy
/*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License"). You may not use this file except in compliance with
* the License. A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions
* and limitations under the License.
*/
package software.amazon.awssdk.services.managedblockchain;
import java.util.concurrent.CompletableFuture;
import java.util.function.Consumer;
import software.amazon.awssdk.annotations.Generated;
import software.amazon.awssdk.annotations.SdkPublicApi;
import software.amazon.awssdk.annotations.ThreadSafe;
import software.amazon.awssdk.core.SdkClient;
import software.amazon.awssdk.services.managedblockchain.model.CreateAccessorRequest;
import software.amazon.awssdk.services.managedblockchain.model.CreateAccessorResponse;
import software.amazon.awssdk.services.managedblockchain.model.CreateMemberRequest;
import software.amazon.awssdk.services.managedblockchain.model.CreateMemberResponse;
import software.amazon.awssdk.services.managedblockchain.model.CreateNetworkRequest;
import software.amazon.awssdk.services.managedblockchain.model.CreateNetworkResponse;
import software.amazon.awssdk.services.managedblockchain.model.CreateNodeRequest;
import software.amazon.awssdk.services.managedblockchain.model.CreateNodeResponse;
import software.amazon.awssdk.services.managedblockchain.model.CreateProposalRequest;
import software.amazon.awssdk.services.managedblockchain.model.CreateProposalResponse;
import software.amazon.awssdk.services.managedblockchain.model.DeleteAccessorRequest;
import software.amazon.awssdk.services.managedblockchain.model.DeleteAccessorResponse;
import software.amazon.awssdk.services.managedblockchain.model.DeleteMemberRequest;
import software.amazon.awssdk.services.managedblockchain.model.DeleteMemberResponse;
import software.amazon.awssdk.services.managedblockchain.model.DeleteNodeRequest;
import software.amazon.awssdk.services.managedblockchain.model.DeleteNodeResponse;
import software.amazon.awssdk.services.managedblockchain.model.GetAccessorRequest;
import software.amazon.awssdk.services.managedblockchain.model.GetAccessorResponse;
import software.amazon.awssdk.services.managedblockchain.model.GetMemberRequest;
import software.amazon.awssdk.services.managedblockchain.model.GetMemberResponse;
import software.amazon.awssdk.services.managedblockchain.model.GetNetworkRequest;
import software.amazon.awssdk.services.managedblockchain.model.GetNetworkResponse;
import software.amazon.awssdk.services.managedblockchain.model.GetNodeRequest;
import software.amazon.awssdk.services.managedblockchain.model.GetNodeResponse;
import software.amazon.awssdk.services.managedblockchain.model.GetProposalRequest;
import software.amazon.awssdk.services.managedblockchain.model.GetProposalResponse;
import software.amazon.awssdk.services.managedblockchain.model.ListAccessorsRequest;
import software.amazon.awssdk.services.managedblockchain.model.ListAccessorsResponse;
import software.amazon.awssdk.services.managedblockchain.model.ListInvitationsRequest;
import software.amazon.awssdk.services.managedblockchain.model.ListInvitationsResponse;
import software.amazon.awssdk.services.managedblockchain.model.ListMembersRequest;
import software.amazon.awssdk.services.managedblockchain.model.ListMembersResponse;
import software.amazon.awssdk.services.managedblockchain.model.ListNetworksRequest;
import software.amazon.awssdk.services.managedblockchain.model.ListNetworksResponse;
import software.amazon.awssdk.services.managedblockchain.model.ListNodesRequest;
import software.amazon.awssdk.services.managedblockchain.model.ListNodesResponse;
import software.amazon.awssdk.services.managedblockchain.model.ListProposalVotesRequest;
import software.amazon.awssdk.services.managedblockchain.model.ListProposalVotesResponse;
import software.amazon.awssdk.services.managedblockchain.model.ListProposalsRequest;
import software.amazon.awssdk.services.managedblockchain.model.ListProposalsResponse;
import software.amazon.awssdk.services.managedblockchain.model.ListTagsForResourceRequest;
import software.amazon.awssdk.services.managedblockchain.model.ListTagsForResourceResponse;
import software.amazon.awssdk.services.managedblockchain.model.RejectInvitationRequest;
import software.amazon.awssdk.services.managedblockchain.model.RejectInvitationResponse;
import software.amazon.awssdk.services.managedblockchain.model.TagResourceRequest;
import software.amazon.awssdk.services.managedblockchain.model.TagResourceResponse;
import software.amazon.awssdk.services.managedblockchain.model.UntagResourceRequest;
import software.amazon.awssdk.services.managedblockchain.model.UntagResourceResponse;
import software.amazon.awssdk.services.managedblockchain.model.UpdateMemberRequest;
import software.amazon.awssdk.services.managedblockchain.model.UpdateMemberResponse;
import software.amazon.awssdk.services.managedblockchain.model.UpdateNodeRequest;
import software.amazon.awssdk.services.managedblockchain.model.UpdateNodeResponse;
import software.amazon.awssdk.services.managedblockchain.model.VoteOnProposalRequest;
import software.amazon.awssdk.services.managedblockchain.model.VoteOnProposalResponse;
import software.amazon.awssdk.services.managedblockchain.paginators.ListAccessorsPublisher;
import software.amazon.awssdk.services.managedblockchain.paginators.ListInvitationsPublisher;
import software.amazon.awssdk.services.managedblockchain.paginators.ListMembersPublisher;
import software.amazon.awssdk.services.managedblockchain.paginators.ListNetworksPublisher;
import software.amazon.awssdk.services.managedblockchain.paginators.ListNodesPublisher;
import software.amazon.awssdk.services.managedblockchain.paginators.ListProposalVotesPublisher;
import software.amazon.awssdk.services.managedblockchain.paginators.ListProposalsPublisher;
/**
* Service client for accessing ManagedBlockchain asynchronously. This can be created using the static
* {@link #builder()} method.
*
*
*
* Amazon Managed Blockchain is a fully managed service for creating and managing blockchain networks using open-source
* frameworks. Blockchain allows you to build applications where multiple parties can securely and transparently run
* transactions and share data without the need for a trusted, central authority.
*
*
* Managed Blockchain supports the Hyperledger Fabric and Ethereum open-source frameworks. Because of fundamental
* differences between the frameworks, some API actions or data types may only apply in the context of one framework and
* not the other. For example, actions related to Hyperledger Fabric network members such as CreateMember
* and DeleteMember don't apply to Ethereum.
*
*
* The description for each action indicates the framework or frameworks to which it applies. Data types and properties
* that apply only in the context of a particular framework are similarly indicated.
*
*/
@Generated("software.amazon.awssdk:codegen")
@SdkPublicApi
@ThreadSafe
public interface ManagedBlockchainAsyncClient extends SdkClient {
String SERVICE_NAME = "managedblockchain";
/**
* Value for looking up the service's metadata from the
* {@link software.amazon.awssdk.regions.ServiceMetadataProvider}.
*/
String SERVICE_METADATA_ID = "managedblockchain";
/**
* Create a {@link ManagedBlockchainAsyncClient} with the region loaded from the
* {@link software.amazon.awssdk.regions.providers.DefaultAwsRegionProviderChain} and credentials loaded from the
* {@link software.amazon.awssdk.auth.credentials.DefaultCredentialsProvider}.
*/
static ManagedBlockchainAsyncClient create() {
return builder().build();
}
/**
* Create a builder that can be used to configure and create a {@link ManagedBlockchainAsyncClient}.
*/
static ManagedBlockchainAsyncClientBuilder builder() {
return new DefaultManagedBlockchainAsyncClientBuilder();
}
/**
*
*
* The token based access feature is in preview release for Ethereum on Amazon Managed Blockchain and is subject to
* change. We recommend that you use this feature only with test scenarios, and not in production environments.
*
*
*
* Creates a new accessor for use with Managed Blockchain Ethereum nodes. An accessor object is a container that has
* the information required for token based access to your Ethereum nodes.
*
*
* @param createAccessorRequest
* @return A Java Future containing the result of the CreateAccessor operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InvalidRequestException The action or operation requested is invalid. Verify that the action is typed
* correctly.
* - AccessDeniedException You don't have sufficient access to perform this action.
* - ResourceAlreadyExistsException A resource request is issued for a resource that already exists.
* - ThrottlingException The request or operation couldn't be performed because a service is throttling
* requests. The most common source of throttling errors is creating resources that exceed your service
* limit for this resource type. Request a limit increase or delete unused resources if possible.
* - ResourceLimitExceededException The maximum number of resources of that type already exist. Ensure the
* resources requested are within the boundaries of the service edition and your account limits.
* - InternalServiceErrorException The request processing has failed because of an unknown error,
* exception or failure.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - ManagedBlockchainException Base class for all service exceptions. Unknown exceptions will be thrown
* as an instance of this type.
*
* @sample ManagedBlockchainAsyncClient.CreateAccessor
* @see AWS API Documentation
*/
default CompletableFuture createAccessor(CreateAccessorRequest createAccessorRequest) {
throw new UnsupportedOperationException();
}
/**
*
*
* The token based access feature is in preview release for Ethereum on Amazon Managed Blockchain and is subject to
* change. We recommend that you use this feature only with test scenarios, and not in production environments.
*
*
*
* Creates a new accessor for use with Managed Blockchain Ethereum nodes. An accessor object is a container that has
* the information required for token based access to your Ethereum nodes.
*
*
*
* This is a convenience which creates an instance of the {@link CreateAccessorRequest.Builder} avoiding the need to
* create one manually via {@link CreateAccessorRequest#builder()}
*
*
* @param createAccessorRequest
* A {@link Consumer} that will call methods on {@link CreateAccessorInput.Builder} to create a request.
* @return A Java Future containing the result of the CreateAccessor operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InvalidRequestException The action or operation requested is invalid. Verify that the action is typed
* correctly.
* - AccessDeniedException You don't have sufficient access to perform this action.
* - ResourceAlreadyExistsException A resource request is issued for a resource that already exists.
* - ThrottlingException The request or operation couldn't be performed because a service is throttling
* requests. The most common source of throttling errors is creating resources that exceed your service
* limit for this resource type. Request a limit increase or delete unused resources if possible.
* - ResourceLimitExceededException The maximum number of resources of that type already exist. Ensure the
* resources requested are within the boundaries of the service edition and your account limits.
* - InternalServiceErrorException The request processing has failed because of an unknown error,
* exception or failure.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - ManagedBlockchainException Base class for all service exceptions. Unknown exceptions will be thrown
* as an instance of this type.
*
* @sample ManagedBlockchainAsyncClient.CreateAccessor
* @see AWS API Documentation
*/
default CompletableFuture createAccessor(Consumer createAccessorRequest) {
return createAccessor(CreateAccessorRequest.builder().applyMutation(createAccessorRequest).build());
}
/**
*
* Creates a member within a Managed Blockchain network.
*
*
* Applies only to Hyperledger Fabric.
*
*
* @param createMemberRequest
* @return A Java Future containing the result of the CreateMember operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InvalidRequestException The action or operation requested is invalid. Verify that the action is typed
* correctly.
* - AccessDeniedException You don't have sufficient access to perform this action.
* - ResourceNotFoundException A requested resource doesn't exist. It may have been deleted or referenced
* incorrectly.
* - ResourceAlreadyExistsException A resource request is issued for a resource that already exists.
* - ResourceNotReadyException The requested resource exists but isn't in a status that can complete the
* operation.
* - ThrottlingException The request or operation couldn't be performed because a service is throttling
* requests. The most common source of throttling errors is creating resources that exceed your service
* limit for this resource type. Request a limit increase or delete unused resources if possible.
* - ResourceLimitExceededException The maximum number of resources of that type already exist. Ensure the
* resources requested are within the boundaries of the service edition and your account limits.
* - InternalServiceErrorException The request processing has failed because of an unknown error,
* exception or failure.
* - TooManyTagsException
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - ManagedBlockchainException Base class for all service exceptions. Unknown exceptions will be thrown
* as an instance of this type.
*
* @sample ManagedBlockchainAsyncClient.CreateMember
* @see AWS API Documentation
*/
default CompletableFuture createMember(CreateMemberRequest createMemberRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Creates a member within a Managed Blockchain network.
*
*
* Applies only to Hyperledger Fabric.
*
*
*
* This is a convenience which creates an instance of the {@link CreateMemberRequest.Builder} avoiding the need to
* create one manually via {@link CreateMemberRequest#builder()}
*
*
* @param createMemberRequest
* A {@link Consumer} that will call methods on {@link CreateMemberInput.Builder} to create a request.
* @return A Java Future containing the result of the CreateMember operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InvalidRequestException The action or operation requested is invalid. Verify that the action is typed
* correctly.
* - AccessDeniedException You don't have sufficient access to perform this action.
* - ResourceNotFoundException A requested resource doesn't exist. It may have been deleted or referenced
* incorrectly.
* - ResourceAlreadyExistsException A resource request is issued for a resource that already exists.
* - ResourceNotReadyException The requested resource exists but isn't in a status that can complete the
* operation.
* - ThrottlingException The request or operation couldn't be performed because a service is throttling
* requests. The most common source of throttling errors is creating resources that exceed your service
* limit for this resource type. Request a limit increase or delete unused resources if possible.
* - ResourceLimitExceededException The maximum number of resources of that type already exist. Ensure the
* resources requested are within the boundaries of the service edition and your account limits.
* - InternalServiceErrorException The request processing has failed because of an unknown error,
* exception or failure.
* - TooManyTagsException
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - ManagedBlockchainException Base class for all service exceptions. Unknown exceptions will be thrown
* as an instance of this type.
*
* @sample ManagedBlockchainAsyncClient.CreateMember
* @see AWS API Documentation
*/
default CompletableFuture createMember(Consumer createMemberRequest) {
return createMember(CreateMemberRequest.builder().applyMutation(createMemberRequest).build());
}
/**
*
* Creates a new blockchain network using Amazon Managed Blockchain.
*
*
* Applies only to Hyperledger Fabric.
*
*
* @param createNetworkRequest
* @return A Java Future containing the result of the CreateNetwork operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InvalidRequestException The action or operation requested is invalid. Verify that the action is typed
* correctly.
* - AccessDeniedException You don't have sufficient access to perform this action.
* - ResourceAlreadyExistsException A resource request is issued for a resource that already exists.
* - ThrottlingException The request or operation couldn't be performed because a service is throttling
* requests. The most common source of throttling errors is creating resources that exceed your service
* limit for this resource type. Request a limit increase or delete unused resources if possible.
* - ResourceLimitExceededException The maximum number of resources of that type already exist. Ensure the
* resources requested are within the boundaries of the service edition and your account limits.
* - InternalServiceErrorException The request processing has failed because of an unknown error,
* exception or failure.
* - TooManyTagsException
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - ManagedBlockchainException Base class for all service exceptions. Unknown exceptions will be thrown
* as an instance of this type.
*
* @sample ManagedBlockchainAsyncClient.CreateNetwork
* @see AWS API Documentation
*/
default CompletableFuture createNetwork(CreateNetworkRequest createNetworkRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Creates a new blockchain network using Amazon Managed Blockchain.
*
*
* Applies only to Hyperledger Fabric.
*
*
*
* This is a convenience which creates an instance of the {@link CreateNetworkRequest.Builder} avoiding the need to
* create one manually via {@link CreateNetworkRequest#builder()}
*
*
* @param createNetworkRequest
* A {@link Consumer} that will call methods on {@link CreateNetworkInput.Builder} to create a request.
* @return A Java Future containing the result of the CreateNetwork operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InvalidRequestException The action or operation requested is invalid. Verify that the action is typed
* correctly.
* - AccessDeniedException You don't have sufficient access to perform this action.
* - ResourceAlreadyExistsException A resource request is issued for a resource that already exists.
* - ThrottlingException The request or operation couldn't be performed because a service is throttling
* requests. The most common source of throttling errors is creating resources that exceed your service
* limit for this resource type. Request a limit increase or delete unused resources if possible.
* - ResourceLimitExceededException The maximum number of resources of that type already exist. Ensure the
* resources requested are within the boundaries of the service edition and your account limits.
* - InternalServiceErrorException The request processing has failed because of an unknown error,
* exception or failure.
* - TooManyTagsException
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - ManagedBlockchainException Base class for all service exceptions. Unknown exceptions will be thrown
* as an instance of this type.
*
* @sample ManagedBlockchainAsyncClient.CreateNetwork
* @see AWS API Documentation
*/
default CompletableFuture createNetwork(Consumer createNetworkRequest) {
return createNetwork(CreateNetworkRequest.builder().applyMutation(createNetworkRequest).build());
}
/**
*
* Creates a node on the specified blockchain network.
*
*
* Applies to Hyperledger Fabric and Ethereum.
*
*
* @param createNodeRequest
* @return A Java Future containing the result of the CreateNode operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InvalidRequestException The action or operation requested is invalid. Verify that the action is typed
* correctly.
* - AccessDeniedException You don't have sufficient access to perform this action.
* - ResourceNotFoundException A requested resource doesn't exist. It may have been deleted or referenced
* incorrectly.
* - ResourceAlreadyExistsException A resource request is issued for a resource that already exists.
* - ResourceNotReadyException The requested resource exists but isn't in a status that can complete the
* operation.
* - ThrottlingException The request or operation couldn't be performed because a service is throttling
* requests. The most common source of throttling errors is creating resources that exceed your service
* limit for this resource type. Request a limit increase or delete unused resources if possible.
* - ResourceLimitExceededException The maximum number of resources of that type already exist. Ensure the
* resources requested are within the boundaries of the service edition and your account limits.
* - InternalServiceErrorException The request processing has failed because of an unknown error,
* exception or failure.
* - TooManyTagsException
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - ManagedBlockchainException Base class for all service exceptions. Unknown exceptions will be thrown
* as an instance of this type.
*
* @sample ManagedBlockchainAsyncClient.CreateNode
* @see AWS
* API Documentation
*/
default CompletableFuture createNode(CreateNodeRequest createNodeRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Creates a node on the specified blockchain network.
*
*
* Applies to Hyperledger Fabric and Ethereum.
*
*
*
* This is a convenience which creates an instance of the {@link CreateNodeRequest.Builder} avoiding the need to
* create one manually via {@link CreateNodeRequest#builder()}
*
*
* @param createNodeRequest
* A {@link Consumer} that will call methods on {@link CreateNodeInput.Builder} to create a request.
* @return A Java Future containing the result of the CreateNode operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InvalidRequestException The action or operation requested is invalid. Verify that the action is typed
* correctly.
* - AccessDeniedException You don't have sufficient access to perform this action.
* - ResourceNotFoundException A requested resource doesn't exist. It may have been deleted or referenced
* incorrectly.
* - ResourceAlreadyExistsException A resource request is issued for a resource that already exists.
* - ResourceNotReadyException The requested resource exists but isn't in a status that can complete the
* operation.
* - ThrottlingException The request or operation couldn't be performed because a service is throttling
* requests. The most common source of throttling errors is creating resources that exceed your service
* limit for this resource type. Request a limit increase or delete unused resources if possible.
* - ResourceLimitExceededException The maximum number of resources of that type already exist. Ensure the
* resources requested are within the boundaries of the service edition and your account limits.
* - InternalServiceErrorException The request processing has failed because of an unknown error,
* exception or failure.
* - TooManyTagsException
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - ManagedBlockchainException Base class for all service exceptions. Unknown exceptions will be thrown
* as an instance of this type.
*
* @sample ManagedBlockchainAsyncClient.CreateNode
* @see AWS
* API Documentation
*/
default CompletableFuture createNode(Consumer createNodeRequest) {
return createNode(CreateNodeRequest.builder().applyMutation(createNodeRequest).build());
}
/**
*
* Creates a proposal for a change to the network that other members of the network can vote on, for example, a
* proposal to add a new member to the network. Any member can create a proposal.
*
*
* Applies only to Hyperledger Fabric.
*
*
* @param createProposalRequest
* @return A Java Future containing the result of the CreateProposal operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InvalidRequestException The action or operation requested is invalid. Verify that the action is typed
* correctly.
* - AccessDeniedException You don't have sufficient access to perform this action.
* - ResourceNotFoundException A requested resource doesn't exist. It may have been deleted or referenced
* incorrectly.
* - ResourceNotReadyException The requested resource exists but isn't in a status that can complete the
* operation.
* - ThrottlingException The request or operation couldn't be performed because a service is throttling
* requests. The most common source of throttling errors is creating resources that exceed your service
* limit for this resource type. Request a limit increase or delete unused resources if possible.
* - InternalServiceErrorException The request processing has failed because of an unknown error,
* exception or failure.
* - TooManyTagsException
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - ManagedBlockchainException Base class for all service exceptions. Unknown exceptions will be thrown
* as an instance of this type.
*
* @sample ManagedBlockchainAsyncClient.CreateProposal
* @see AWS API Documentation
*/
default CompletableFuture createProposal(CreateProposalRequest createProposalRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Creates a proposal for a change to the network that other members of the network can vote on, for example, a
* proposal to add a new member to the network. Any member can create a proposal.
*
*
* Applies only to Hyperledger Fabric.
*
*
*
* This is a convenience which creates an instance of the {@link CreateProposalRequest.Builder} avoiding the need to
* create one manually via {@link CreateProposalRequest#builder()}
*
*
* @param createProposalRequest
* A {@link Consumer} that will call methods on {@link CreateProposalInput.Builder} to create a request.
* @return A Java Future containing the result of the CreateProposal operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InvalidRequestException The action or operation requested is invalid. Verify that the action is typed
* correctly.
* - AccessDeniedException You don't have sufficient access to perform this action.
* - ResourceNotFoundException A requested resource doesn't exist. It may have been deleted or referenced
* incorrectly.
* - ResourceNotReadyException The requested resource exists but isn't in a status that can complete the
* operation.
* - ThrottlingException The request or operation couldn't be performed because a service is throttling
* requests. The most common source of throttling errors is creating resources that exceed your service
* limit for this resource type. Request a limit increase or delete unused resources if possible.
* - InternalServiceErrorException The request processing has failed because of an unknown error,
* exception or failure.
* - TooManyTagsException
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - ManagedBlockchainException Base class for all service exceptions. Unknown exceptions will be thrown
* as an instance of this type.
*
* @sample ManagedBlockchainAsyncClient.CreateProposal
* @see AWS API Documentation
*/
default CompletableFuture createProposal(Consumer createProposalRequest) {
return createProposal(CreateProposalRequest.builder().applyMutation(createProposalRequest).build());
}
/**
*
*
* The token based access feature is in preview release for Ethereum on Amazon Managed Blockchain and is subject to
* change. We recommend that you use this feature only with test scenarios, and not in production environments.
*
*
*
* Deletes an accessor that your Amazon Web Services account owns. An accessor object is a container that has the
* information required for token based access to your Ethereum nodes including, the BILLING_TOKEN.
* After an accessor is deleted, the status of the accessor changes from AVAILABLE to
* PENDING_DELETION. An accessor in the PENDING_DELETION state can’t be used for new
* WebSocket requests or HTTP requests. However, WebSocket connections that were initiated while the accessor was in
* the AVAILABLE state remain open until they expire (up to 2 hours).
*
*
* @param deleteAccessorRequest
* @return A Java Future containing the result of the DeleteAccessor operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InvalidRequestException The action or operation requested is invalid. Verify that the action is typed
* correctly.
* - AccessDeniedException You don't have sufficient access to perform this action.
* - ResourceNotFoundException A requested resource doesn't exist. It may have been deleted or referenced
* incorrectly.
* - ThrottlingException The request or operation couldn't be performed because a service is throttling
* requests. The most common source of throttling errors is creating resources that exceed your service
* limit for this resource type. Request a limit increase or delete unused resources if possible.
* - InternalServiceErrorException The request processing has failed because of an unknown error,
* exception or failure.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - ManagedBlockchainException Base class for all service exceptions. Unknown exceptions will be thrown
* as an instance of this type.
*
* @sample ManagedBlockchainAsyncClient.DeleteAccessor
* @see AWS API Documentation
*/
default CompletableFuture deleteAccessor(DeleteAccessorRequest deleteAccessorRequest) {
throw new UnsupportedOperationException();
}
/**
*
*
* The token based access feature is in preview release for Ethereum on Amazon Managed Blockchain and is subject to
* change. We recommend that you use this feature only with test scenarios, and not in production environments.
*
*
*
* Deletes an accessor that your Amazon Web Services account owns. An accessor object is a container that has the
* information required for token based access to your Ethereum nodes including, the BILLING_TOKEN.
* After an accessor is deleted, the status of the accessor changes from AVAILABLE to
* PENDING_DELETION. An accessor in the PENDING_DELETION state can’t be used for new
* WebSocket requests or HTTP requests. However, WebSocket connections that were initiated while the accessor was in
* the AVAILABLE state remain open until they expire (up to 2 hours).
*
*
*
* This is a convenience which creates an instance of the {@link DeleteAccessorRequest.Builder} avoiding the need to
* create one manually via {@link DeleteAccessorRequest#builder()}
*
*
* @param deleteAccessorRequest
* A {@link Consumer} that will call methods on {@link DeleteAccessorInput.Builder} to create a request.
* @return A Java Future containing the result of the DeleteAccessor operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InvalidRequestException The action or operation requested is invalid. Verify that the action is typed
* correctly.
* - AccessDeniedException You don't have sufficient access to perform this action.
* - ResourceNotFoundException A requested resource doesn't exist. It may have been deleted or referenced
* incorrectly.
* - ThrottlingException The request or operation couldn't be performed because a service is throttling
* requests. The most common source of throttling errors is creating resources that exceed your service
* limit for this resource type. Request a limit increase or delete unused resources if possible.
* - InternalServiceErrorException The request processing has failed because of an unknown error,
* exception or failure.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - ManagedBlockchainException Base class for all service exceptions. Unknown exceptions will be thrown
* as an instance of this type.
*
* @sample ManagedBlockchainAsyncClient.DeleteAccessor
* @see AWS API Documentation
*/
default CompletableFuture deleteAccessor(Consumer deleteAccessorRequest) {
return deleteAccessor(DeleteAccessorRequest.builder().applyMutation(deleteAccessorRequest).build());
}
/**
*
* Deletes a member. Deleting a member removes the member and all associated resources from the network.
* DeleteMember can only be called for a specified MemberId if the principal performing
* the action is associated with the Amazon Web Services account that owns the member. In all other cases, the
* DeleteMember action is carried out as the result of an approved proposal to remove a member. If
* MemberId is the last member in a network specified by the last Amazon Web Services account, the
* network is deleted also.
*
*
* Applies only to Hyperledger Fabric.
*
*
* @param deleteMemberRequest
* @return A Java Future containing the result of the DeleteMember operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InvalidRequestException The action or operation requested is invalid. Verify that the action is typed
* correctly.
* - AccessDeniedException You don't have sufficient access to perform this action.
* - ResourceNotFoundException A requested resource doesn't exist. It may have been deleted or referenced
* incorrectly.
* - ResourceNotReadyException The requested resource exists but isn't in a status that can complete the
* operation.
* - ThrottlingException The request or operation couldn't be performed because a service is throttling
* requests. The most common source of throttling errors is creating resources that exceed your service
* limit for this resource type. Request a limit increase or delete unused resources if possible.
* - InternalServiceErrorException The request processing has failed because of an unknown error,
* exception or failure.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - ManagedBlockchainException Base class for all service exceptions. Unknown exceptions will be thrown
* as an instance of this type.
*
* @sample ManagedBlockchainAsyncClient.DeleteMember
* @see AWS API Documentation
*/
default CompletableFuture deleteMember(DeleteMemberRequest deleteMemberRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Deletes a member. Deleting a member removes the member and all associated resources from the network.
* DeleteMember can only be called for a specified MemberId if the principal performing
* the action is associated with the Amazon Web Services account that owns the member. In all other cases, the
* DeleteMember action is carried out as the result of an approved proposal to remove a member. If
* MemberId is the last member in a network specified by the last Amazon Web Services account, the
* network is deleted also.
*
*
* Applies only to Hyperledger Fabric.
*
*
*
* This is a convenience which creates an instance of the {@link DeleteMemberRequest.Builder} avoiding the need to
* create one manually via {@link DeleteMemberRequest#builder()}
*
*
* @param deleteMemberRequest
* A {@link Consumer} that will call methods on {@link DeleteMemberInput.Builder} to create a request.
* @return A Java Future containing the result of the DeleteMember operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InvalidRequestException The action or operation requested is invalid. Verify that the action is typed
* correctly.
* - AccessDeniedException You don't have sufficient access to perform this action.
* - ResourceNotFoundException A requested resource doesn't exist. It may have been deleted or referenced
* incorrectly.
* - ResourceNotReadyException The requested resource exists but isn't in a status that can complete the
* operation.
* - ThrottlingException The request or operation couldn't be performed because a service is throttling
* requests. The most common source of throttling errors is creating resources that exceed your service
* limit for this resource type. Request a limit increase or delete unused resources if possible.
* - InternalServiceErrorException The request processing has failed because of an unknown error,
* exception or failure.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - ManagedBlockchainException Base class for all service exceptions. Unknown exceptions will be thrown
* as an instance of this type.
*
* @sample ManagedBlockchainAsyncClient.DeleteMember
* @see AWS API Documentation
*/
default CompletableFuture deleteMember(Consumer deleteMemberRequest) {
return deleteMember(DeleteMemberRequest.builder().applyMutation(deleteMemberRequest).build());
}
/**
*
* Deletes a node that your Amazon Web Services account owns. All data on the node is lost and cannot be recovered.
*
*
* Applies to Hyperledger Fabric and Ethereum.
*
*
* @param deleteNodeRequest
* @return A Java Future containing the result of the DeleteNode operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InvalidRequestException The action or operation requested is invalid. Verify that the action is typed
* correctly.
* - AccessDeniedException You don't have sufficient access to perform this action.
* - ResourceNotFoundException A requested resource doesn't exist. It may have been deleted or referenced
* incorrectly.
* - ResourceNotReadyException The requested resource exists but isn't in a status that can complete the
* operation.
* - ThrottlingException The request or operation couldn't be performed because a service is throttling
* requests. The most common source of throttling errors is creating resources that exceed your service
* limit for this resource type. Request a limit increase or delete unused resources if possible.
* - InternalServiceErrorException The request processing has failed because of an unknown error,
* exception or failure.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - ManagedBlockchainException Base class for all service exceptions. Unknown exceptions will be thrown
* as an instance of this type.
*
* @sample ManagedBlockchainAsyncClient.DeleteNode
* @see AWS
* API Documentation
*/
default CompletableFuture deleteNode(DeleteNodeRequest deleteNodeRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Deletes a node that your Amazon Web Services account owns. All data on the node is lost and cannot be recovered.
*
*
* Applies to Hyperledger Fabric and Ethereum.
*
*
*
* This is a convenience which creates an instance of the {@link DeleteNodeRequest.Builder} avoiding the need to
* create one manually via {@link DeleteNodeRequest#builder()}
*
*
* @param deleteNodeRequest
* A {@link Consumer} that will call methods on {@link DeleteNodeInput.Builder} to create a request.
* @return A Java Future containing the result of the DeleteNode operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InvalidRequestException The action or operation requested is invalid. Verify that the action is typed
* correctly.
* - AccessDeniedException You don't have sufficient access to perform this action.
* - ResourceNotFoundException A requested resource doesn't exist. It may have been deleted or referenced
* incorrectly.
* - ResourceNotReadyException The requested resource exists but isn't in a status that can complete the
* operation.
* - ThrottlingException The request or operation couldn't be performed because a service is throttling
* requests. The most common source of throttling errors is creating resources that exceed your service
* limit for this resource type. Request a limit increase or delete unused resources if possible.
* - InternalServiceErrorException The request processing has failed because of an unknown error,
* exception or failure.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - ManagedBlockchainException Base class for all service exceptions. Unknown exceptions will be thrown
* as an instance of this type.
*
* @sample ManagedBlockchainAsyncClient.DeleteNode
* @see AWS
* API Documentation
*/
default CompletableFuture deleteNode(Consumer deleteNodeRequest) {
return deleteNode(DeleteNodeRequest.builder().applyMutation(deleteNodeRequest).build());
}
/**
*
*
* The token based access feature is in preview release for Ethereum on Amazon Managed Blockchain and is subject to
* change. We recommend that you use this feature only with test scenarios, and not in production environments.
*
*
*
* Returns detailed information about an accessor. An accessor object is a container that has the information
* required for token based access to your Ethereum nodes.
*
*
* @param getAccessorRequest
* @return A Java Future containing the result of the GetAccessor operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InvalidRequestException The action or operation requested is invalid. Verify that the action is typed
* correctly.
* - AccessDeniedException You don't have sufficient access to perform this action.
* - ResourceNotFoundException A requested resource doesn't exist. It may have been deleted or referenced
* incorrectly.
* - ThrottlingException The request or operation couldn't be performed because a service is throttling
* requests. The most common source of throttling errors is creating resources that exceed your service
* limit for this resource type. Request a limit increase or delete unused resources if possible.
* - InternalServiceErrorException The request processing has failed because of an unknown error,
* exception or failure.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - ManagedBlockchainException Base class for all service exceptions. Unknown exceptions will be thrown
* as an instance of this type.
*
* @sample ManagedBlockchainAsyncClient.GetAccessor
* @see AWS
* API Documentation
*/
default CompletableFuture getAccessor(GetAccessorRequest getAccessorRequest) {
throw new UnsupportedOperationException();
}
/**
*
*
* The token based access feature is in preview release for Ethereum on Amazon Managed Blockchain and is subject to
* change. We recommend that you use this feature only with test scenarios, and not in production environments.
*
*
*
* Returns detailed information about an accessor. An accessor object is a container that has the information
* required for token based access to your Ethereum nodes.
*
*
*
* This is a convenience which creates an instance of the {@link GetAccessorRequest.Builder} avoiding the need to
* create one manually via {@link GetAccessorRequest#builder()}
*
*
* @param getAccessorRequest
* A {@link Consumer} that will call methods on {@link GetAccessorInput.Builder} to create a request.
* @return A Java Future containing the result of the GetAccessor operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InvalidRequestException The action or operation requested is invalid. Verify that the action is typed
* correctly.
* - AccessDeniedException You don't have sufficient access to perform this action.
* - ResourceNotFoundException A requested resource doesn't exist. It may have been deleted or referenced
* incorrectly.
* - ThrottlingException The request or operation couldn't be performed because a service is throttling
* requests. The most common source of throttling errors is creating resources that exceed your service
* limit for this resource type. Request a limit increase or delete unused resources if possible.
* - InternalServiceErrorException The request processing has failed because of an unknown error,
* exception or failure.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - ManagedBlockchainException Base class for all service exceptions. Unknown exceptions will be thrown
* as an instance of this type.
*
* @sample ManagedBlockchainAsyncClient.GetAccessor
* @see AWS
* API Documentation
*/
default CompletableFuture getAccessor(Consumer getAccessorRequest) {
return getAccessor(GetAccessorRequest.builder().applyMutation(getAccessorRequest).build());
}
/**
*
* Returns detailed information about a member.
*
*
* Applies only to Hyperledger Fabric.
*
*
* @param getMemberRequest
* @return A Java Future containing the result of the GetMember operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InvalidRequestException The action or operation requested is invalid. Verify that the action is typed
* correctly.
* - AccessDeniedException You don't have sufficient access to perform this action.
* - ResourceNotFoundException A requested resource doesn't exist. It may have been deleted or referenced
* incorrectly.
* - ThrottlingException The request or operation couldn't be performed because a service is throttling
* requests. The most common source of throttling errors is creating resources that exceed your service
* limit for this resource type. Request a limit increase or delete unused resources if possible.
* - InternalServiceErrorException The request processing has failed because of an unknown error,
* exception or failure.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - ManagedBlockchainException Base class for all service exceptions. Unknown exceptions will be thrown
* as an instance of this type.
*
* @sample ManagedBlockchainAsyncClient.GetMember
* @see AWS
* API Documentation
*/
default CompletableFuture getMember(GetMemberRequest getMemberRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Returns detailed information about a member.
*
*
* Applies only to Hyperledger Fabric.
*
*
*
* This is a convenience which creates an instance of the {@link GetMemberRequest.Builder} avoiding the need to
* create one manually via {@link GetMemberRequest#builder()}
*
*
* @param getMemberRequest
* A {@link Consumer} that will call methods on {@link GetMemberInput.Builder} to create a request.
* @return A Java Future containing the result of the GetMember operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InvalidRequestException The action or operation requested is invalid. Verify that the action is typed
* correctly.
* - AccessDeniedException You don't have sufficient access to perform this action.
* - ResourceNotFoundException A requested resource doesn't exist. It may have been deleted or referenced
* incorrectly.
* - ThrottlingException The request or operation couldn't be performed because a service is throttling
* requests. The most common source of throttling errors is creating resources that exceed your service
* limit for this resource type. Request a limit increase or delete unused resources if possible.
* - InternalServiceErrorException The request processing has failed because of an unknown error,
* exception or failure.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - ManagedBlockchainException Base class for all service exceptions. Unknown exceptions will be thrown
* as an instance of this type.
*
* @sample ManagedBlockchainAsyncClient.GetMember
* @see AWS
* API Documentation
*/
default CompletableFuture getMember(Consumer getMemberRequest) {
return getMember(GetMemberRequest.builder().applyMutation(getMemberRequest).build());
}
/**
*
* Returns detailed information about a network.
*
*
* Applies to Hyperledger Fabric and Ethereum.
*
*
* @param getNetworkRequest
* @return A Java Future containing the result of the GetNetwork operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InvalidRequestException The action or operation requested is invalid. Verify that the action is typed
* correctly.
* - AccessDeniedException You don't have sufficient access to perform this action.
* - ResourceNotFoundException A requested resource doesn't exist. It may have been deleted or referenced
* incorrectly.
* - ThrottlingException The request or operation couldn't be performed because a service is throttling
* requests. The most common source of throttling errors is creating resources that exceed your service
* limit for this resource type. Request a limit increase or delete unused resources if possible.
* - InternalServiceErrorException The request processing has failed because of an unknown error,
* exception or failure.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - ManagedBlockchainException Base class for all service exceptions. Unknown exceptions will be thrown
* as an instance of this type.
*
* @sample ManagedBlockchainAsyncClient.GetNetwork
* @see AWS
* API Documentation
*/
default CompletableFuture getNetwork(GetNetworkRequest getNetworkRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Returns detailed information about a network.
*
*
* Applies to Hyperledger Fabric and Ethereum.
*
*
*
* This is a convenience which creates an instance of the {@link GetNetworkRequest.Builder} avoiding the need to
* create one manually via {@link GetNetworkRequest#builder()}
*
*
* @param getNetworkRequest
* A {@link Consumer} that will call methods on {@link GetNetworkInput.Builder} to create a request.
* @return A Java Future containing the result of the GetNetwork operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InvalidRequestException The action or operation requested is invalid. Verify that the action is typed
* correctly.
* - AccessDeniedException You don't have sufficient access to perform this action.
* - ResourceNotFoundException A requested resource doesn't exist. It may have been deleted or referenced
* incorrectly.
* - ThrottlingException The request or operation couldn't be performed because a service is throttling
* requests. The most common source of throttling errors is creating resources that exceed your service
* limit for this resource type. Request a limit increase or delete unused resources if possible.
* - InternalServiceErrorException The request processing has failed because of an unknown error,
* exception or failure.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - ManagedBlockchainException Base class for all service exceptions. Unknown exceptions will be thrown
* as an instance of this type.
*
* @sample ManagedBlockchainAsyncClient.GetNetwork
* @see AWS
* API Documentation
*/
default CompletableFuture getNetwork(Consumer getNetworkRequest) {
return getNetwork(GetNetworkRequest.builder().applyMutation(getNetworkRequest).build());
}
/**
*
* Returns detailed information about a node.
*
*
* Applies to Hyperledger Fabric and Ethereum.
*
*
* @param getNodeRequest
* @return A Java Future containing the result of the GetNode operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InvalidRequestException The action or operation requested is invalid. Verify that the action is typed
* correctly.
* - AccessDeniedException You don't have sufficient access to perform this action.
* - ResourceNotFoundException A requested resource doesn't exist. It may have been deleted or referenced
* incorrectly.
* - ThrottlingException The request or operation couldn't be performed because a service is throttling
* requests. The most common source of throttling errors is creating resources that exceed your service
* limit for this resource type. Request a limit increase or delete unused resources if possible.
* - InternalServiceErrorException The request processing has failed because of an unknown error,
* exception or failure.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - ManagedBlockchainException Base class for all service exceptions. Unknown exceptions will be thrown
* as an instance of this type.
*
* @sample ManagedBlockchainAsyncClient.GetNode
* @see AWS API
* Documentation
*/
default CompletableFuture getNode(GetNodeRequest getNodeRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Returns detailed information about a node.
*
*
* Applies to Hyperledger Fabric and Ethereum.
*
*
*
* This is a convenience which creates an instance of the {@link GetNodeRequest.Builder} avoiding the need to create
* one manually via {@link GetNodeRequest#builder()}
*
*
* @param getNodeRequest
* A {@link Consumer} that will call methods on {@link GetNodeInput.Builder} to create a request.
* @return A Java Future containing the result of the GetNode operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InvalidRequestException The action or operation requested is invalid. Verify that the action is typed
* correctly.
* - AccessDeniedException You don't have sufficient access to perform this action.
* - ResourceNotFoundException A requested resource doesn't exist. It may have been deleted or referenced
* incorrectly.
* - ThrottlingException The request or operation couldn't be performed because a service is throttling
* requests. The most common source of throttling errors is creating resources that exceed your service
* limit for this resource type. Request a limit increase or delete unused resources if possible.
* - InternalServiceErrorException The request processing has failed because of an unknown error,
* exception or failure.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - ManagedBlockchainException Base class for all service exceptions. Unknown exceptions will be thrown
* as an instance of this type.
*
* @sample ManagedBlockchainAsyncClient.GetNode
* @see AWS API
* Documentation
*/
default CompletableFuture getNode(Consumer getNodeRequest) {
return getNode(GetNodeRequest.builder().applyMutation(getNodeRequest).build());
}
/**
*
* Returns detailed information about a proposal.
*
*
* Applies only to Hyperledger Fabric.
*
*
* @param getProposalRequest
* @return A Java Future containing the result of the GetProposal operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InvalidRequestException The action or operation requested is invalid. Verify that the action is typed
* correctly.
* - AccessDeniedException You don't have sufficient access to perform this action.
* - ResourceNotFoundException A requested resource doesn't exist. It may have been deleted or referenced
* incorrectly.
* - ThrottlingException The request or operation couldn't be performed because a service is throttling
* requests. The most common source of throttling errors is creating resources that exceed your service
* limit for this resource type. Request a limit increase or delete unused resources if possible.
* - InternalServiceErrorException The request processing has failed because of an unknown error,
* exception or failure.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - ManagedBlockchainException Base class for all service exceptions. Unknown exceptions will be thrown
* as an instance of this type.
*
* @sample ManagedBlockchainAsyncClient.GetProposal
* @see AWS
* API Documentation
*/
default CompletableFuture getProposal(GetProposalRequest getProposalRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Returns detailed information about a proposal.
*
*
* Applies only to Hyperledger Fabric.
*
*
*
* This is a convenience which creates an instance of the {@link GetProposalRequest.Builder} avoiding the need to
* create one manually via {@link GetProposalRequest#builder()}
*
*
* @param getProposalRequest
* A {@link Consumer} that will call methods on {@link GetProposalInput.Builder} to create a request.
* @return A Java Future containing the result of the GetProposal operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InvalidRequestException The action or operation requested is invalid. Verify that the action is typed
* correctly.
* - AccessDeniedException You don't have sufficient access to perform this action.
* - ResourceNotFoundException A requested resource doesn't exist. It may have been deleted or referenced
* incorrectly.
* - ThrottlingException The request or operation couldn't be performed because a service is throttling
* requests. The most common source of throttling errors is creating resources that exceed your service
* limit for this resource type. Request a limit increase or delete unused resources if possible.
* - InternalServiceErrorException The request processing has failed because of an unknown error,
* exception or failure.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - ManagedBlockchainException Base class for all service exceptions. Unknown exceptions will be thrown
* as an instance of this type.
*
* @sample ManagedBlockchainAsyncClient.GetProposal
* @see AWS
* API Documentation
*/
default CompletableFuture getProposal(Consumer getProposalRequest) {
return getProposal(GetProposalRequest.builder().applyMutation(getProposalRequest).build());
}
/**
*
*
* The token based access feature is in preview release for Ethereum on Amazon Managed Blockchain and is subject to
* change. We recommend that you use this feature only with test scenarios, and not in production environments.
*
*
*
* Returns a list of the accessors and their properties. Accessor objects are containers that have the information
* required for token based access to your Ethereum nodes.
*
*
* @param listAccessorsRequest
* @return A Java Future containing the result of the ListAccessors operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InvalidRequestException The action or operation requested is invalid. Verify that the action is typed
* correctly.
* - AccessDeniedException You don't have sufficient access to perform this action.
* - ThrottlingException The request or operation couldn't be performed because a service is throttling
* requests. The most common source of throttling errors is creating resources that exceed your service
* limit for this resource type. Request a limit increase or delete unused resources if possible.
* - InternalServiceErrorException The request processing has failed because of an unknown error,
* exception or failure.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - ManagedBlockchainException Base class for all service exceptions. Unknown exceptions will be thrown
* as an instance of this type.
*
* @sample ManagedBlockchainAsyncClient.ListAccessors
* @see AWS API Documentation
*/
default CompletableFuture listAccessors(ListAccessorsRequest listAccessorsRequest) {
throw new UnsupportedOperationException();
}
/**
*
*
* The token based access feature is in preview release for Ethereum on Amazon Managed Blockchain and is subject to
* change. We recommend that you use this feature only with test scenarios, and not in production environments.
*
*
*
* Returns a list of the accessors and their properties. Accessor objects are containers that have the information
* required for token based access to your Ethereum nodes.
*
*
*
* This is a convenience which creates an instance of the {@link ListAccessorsRequest.Builder} avoiding the need to
* create one manually via {@link ListAccessorsRequest#builder()}
*
*
* @param listAccessorsRequest
* A {@link Consumer} that will call methods on {@link ListAccessorsInput.Builder} to create a request.
* @return A Java Future containing the result of the ListAccessors operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InvalidRequestException The action or operation requested is invalid. Verify that the action is typed
* correctly.
* - AccessDeniedException You don't have sufficient access to perform this action.
* - ThrottlingException The request or operation couldn't be performed because a service is throttling
* requests. The most common source of throttling errors is creating resources that exceed your service
* limit for this resource type. Request a limit increase or delete unused resources if possible.
* - InternalServiceErrorException The request processing has failed because of an unknown error,
* exception or failure.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - ManagedBlockchainException Base class for all service exceptions. Unknown exceptions will be thrown
* as an instance of this type.
*
* @sample ManagedBlockchainAsyncClient.ListAccessors
* @see AWS API Documentation
*/
default CompletableFuture listAccessors(Consumer listAccessorsRequest) {
return listAccessors(ListAccessorsRequest.builder().applyMutation(listAccessorsRequest).build());
}
/**
*
*
* The token based access feature is in preview release for Ethereum on Amazon Managed Blockchain and is subject to
* change. We recommend that you use this feature only with test scenarios, and not in production environments.
*
*
*
* Returns a list of the accessors and their properties. Accessor objects are containers that have the information
* required for token based access to your Ethereum nodes.
*
*
*
* This is a variant of
* {@link #listAccessors(software.amazon.awssdk.services.managedblockchain.model.ListAccessorsRequest)} operation.
* The return type is a custom publisher that can be subscribed to request a stream of response pages. SDK will
* internally handle making service calls for you.
*
*
* When the operation is called, an instance of this class is returned. At this point, no service calls are made yet
* and so there is no guarantee that the request is valid. If there are errors in your request, you will see the
* failures only after you start streaming the data. The subscribe method should be called as a request to start
* streaming data. For more info, see
* {@link org.reactivestreams.Publisher#subscribe(org.reactivestreams.Subscriber)}. Each call to the subscribe
* method will result in a new {@link org.reactivestreams.Subscription} i.e., a new contract to stream data from the
* starting request.
*
*
*
* The following are few ways to use the response class:
*
* 1) Using the subscribe helper method
*
*
* {@code
* software.amazon.awssdk.services.managedblockchain.paginators.ListAccessorsPublisher publisher = client.listAccessorsPaginator(request);
* CompletableFuture future = publisher.subscribe(res -> { // Do something with the response });
* future.get();
* }
*
*
* 2) Using a custom subscriber
*
*
* {@code
* software.amazon.awssdk.services.managedblockchain.paginators.ListAccessorsPublisher publisher = client.listAccessorsPaginator(request);
* publisher.subscribe(new Subscriber() {
*
* public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
*
*
* public void onNext(software.amazon.awssdk.services.managedblockchain.model.ListAccessorsResponse response) { //... };
* });}
*
*
* As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.
*
* Please notice that the configuration of MaxResults won't limit the number of results you get with the
* paginator. It only limits the number of results in each page.
*
*
* Note: If you prefer to have control on service calls, use the
* {@link #listAccessors(software.amazon.awssdk.services.managedblockchain.model.ListAccessorsRequest)}
* operation.
*
*
* @param listAccessorsRequest
* @return A custom publisher that can be subscribed to request a stream of response pages.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InvalidRequestException The action or operation requested is invalid. Verify that the action is typed
* correctly.
* - AccessDeniedException You don't have sufficient access to perform this action.
* - ThrottlingException The request or operation couldn't be performed because a service is throttling
* requests. The most common source of throttling errors is creating resources that exceed your service
* limit for this resource type. Request a limit increase or delete unused resources if possible.
* - InternalServiceErrorException The request processing has failed because of an unknown error,
* exception or failure.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - ManagedBlockchainException Base class for all service exceptions. Unknown exceptions will be thrown
* as an instance of this type.
*
* @sample ManagedBlockchainAsyncClient.ListAccessors
* @see AWS API Documentation
*/
default ListAccessorsPublisher listAccessorsPaginator(ListAccessorsRequest listAccessorsRequest) {
throw new UnsupportedOperationException();
}
/**
*
*
* The token based access feature is in preview release for Ethereum on Amazon Managed Blockchain and is subject to
* change. We recommend that you use this feature only with test scenarios, and not in production environments.
*
*
*
* Returns a list of the accessors and their properties. Accessor objects are containers that have the information
* required for token based access to your Ethereum nodes.
*
*
*
* This is a variant of
* {@link #listAccessors(software.amazon.awssdk.services.managedblockchain.model.ListAccessorsRequest)} operation.
* The return type is a custom publisher that can be subscribed to request a stream of response pages. SDK will
* internally handle making service calls for you.
*
*
* When the operation is called, an instance of this class is returned. At this point, no service calls are made yet
* and so there is no guarantee that the request is valid. If there are errors in your request, you will see the
* failures only after you start streaming the data. The subscribe method should be called as a request to start
* streaming data. For more info, see
* {@link org.reactivestreams.Publisher#subscribe(org.reactivestreams.Subscriber)}. Each call to the subscribe
* method will result in a new {@link org.reactivestreams.Subscription} i.e., a new contract to stream data from the
* starting request.
*
*
*
* The following are few ways to use the response class:
*
* 1) Using the subscribe helper method
*
*
* {@code
* software.amazon.awssdk.services.managedblockchain.paginators.ListAccessorsPublisher publisher = client.listAccessorsPaginator(request);
* CompletableFuture future = publisher.subscribe(res -> { // Do something with the response });
* future.get();
* }
*
*
* 2) Using a custom subscriber
*
*
* {@code
* software.amazon.awssdk.services.managedblockchain.paginators.ListAccessorsPublisher publisher = client.listAccessorsPaginator(request);
* publisher.subscribe(new Subscriber() {
*
* public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
*
*
* public void onNext(software.amazon.awssdk.services.managedblockchain.model.ListAccessorsResponse response) { //... };
* });}
*
*
* As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.
*
* Please notice that the configuration of MaxResults won't limit the number of results you get with the
* paginator. It only limits the number of results in each page.
*
*
* Note: If you prefer to have control on service calls, use the
* {@link #listAccessors(software.amazon.awssdk.services.managedblockchain.model.ListAccessorsRequest)}
* operation.
*
*
* This is a convenience which creates an instance of the {@link ListAccessorsRequest.Builder} avoiding the need to
* create one manually via {@link ListAccessorsRequest#builder()}
*
*
* @param listAccessorsRequest
* A {@link Consumer} that will call methods on {@link ListAccessorsInput.Builder} to create a request.
* @return A custom publisher that can be subscribed to request a stream of response pages.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InvalidRequestException The action or operation requested is invalid. Verify that the action is typed
* correctly.
* - AccessDeniedException You don't have sufficient access to perform this action.
* - ThrottlingException The request or operation couldn't be performed because a service is throttling
* requests. The most common source of throttling errors is creating resources that exceed your service
* limit for this resource type. Request a limit increase or delete unused resources if possible.
* - InternalServiceErrorException The request processing has failed because of an unknown error,
* exception or failure.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - ManagedBlockchainException Base class for all service exceptions. Unknown exceptions will be thrown
* as an instance of this type.
*
* @sample ManagedBlockchainAsyncClient.ListAccessors
* @see AWS API Documentation
*/
default ListAccessorsPublisher listAccessorsPaginator(Consumer listAccessorsRequest) {
return listAccessorsPaginator(ListAccessorsRequest.builder().applyMutation(listAccessorsRequest).build());
}
/**
*
* Returns a list of all invitations for the current Amazon Web Services account.
*
*
* Applies only to Hyperledger Fabric.
*
*
* @param listInvitationsRequest
* @return A Java Future containing the result of the ListInvitations operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InvalidRequestException The action or operation requested is invalid. Verify that the action is typed
* correctly.
* - AccessDeniedException You don't have sufficient access to perform this action.
* - ResourceNotFoundException A requested resource doesn't exist. It may have been deleted or referenced
* incorrectly.
* - ThrottlingException The request or operation couldn't be performed because a service is throttling
* requests. The most common source of throttling errors is creating resources that exceed your service
* limit for this resource type. Request a limit increase or delete unused resources if possible.
* - ResourceLimitExceededException The maximum number of resources of that type already exist. Ensure the
* resources requested are within the boundaries of the service edition and your account limits.
* - InternalServiceErrorException The request processing has failed because of an unknown error,
* exception or failure.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - ManagedBlockchainException Base class for all service exceptions. Unknown exceptions will be thrown
* as an instance of this type.
*
* @sample ManagedBlockchainAsyncClient.ListInvitations
* @see AWS API Documentation
*/
default CompletableFuture listInvitations(ListInvitationsRequest listInvitationsRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Returns a list of all invitations for the current Amazon Web Services account.
*
*
* Applies only to Hyperledger Fabric.
*
*
*
* This is a convenience which creates an instance of the {@link ListInvitationsRequest.Builder} avoiding the need
* to create one manually via {@link ListInvitationsRequest#builder()}
*
*
* @param listInvitationsRequest
* A {@link Consumer} that will call methods on {@link ListInvitationsInput.Builder} to create a request.
* @return A Java Future containing the result of the ListInvitations operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InvalidRequestException The action or operation requested is invalid. Verify that the action is typed
* correctly.
* - AccessDeniedException You don't have sufficient access to perform this action.
* - ResourceNotFoundException A requested resource doesn't exist. It may have been deleted or referenced
* incorrectly.
* - ThrottlingException The request or operation couldn't be performed because a service is throttling
* requests. The most common source of throttling errors is creating resources that exceed your service
* limit for this resource type. Request a limit increase or delete unused resources if possible.
* - ResourceLimitExceededException The maximum number of resources of that type already exist. Ensure the
* resources requested are within the boundaries of the service edition and your account limits.
* - InternalServiceErrorException The request processing has failed because of an unknown error,
* exception or failure.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - ManagedBlockchainException Base class for all service exceptions. Unknown exceptions will be thrown
* as an instance of this type.
*
* @sample ManagedBlockchainAsyncClient.ListInvitations
* @see AWS API Documentation
*/
default CompletableFuture listInvitations(
Consumer listInvitationsRequest) {
return listInvitations(ListInvitationsRequest.builder().applyMutation(listInvitationsRequest).build());
}
/**
*
* Returns a list of all invitations for the current Amazon Web Services account.
*
*
* Applies only to Hyperledger Fabric.
*
*
*
* This is a variant of
* {@link #listInvitations(software.amazon.awssdk.services.managedblockchain.model.ListInvitationsRequest)}
* operation. The return type is a custom publisher that can be subscribed to request a stream of response pages.
* SDK will internally handle making service calls for you.
*
*
* When the operation is called, an instance of this class is returned. At this point, no service calls are made yet
* and so there is no guarantee that the request is valid. If there are errors in your request, you will see the
* failures only after you start streaming the data. The subscribe method should be called as a request to start
* streaming data. For more info, see
* {@link org.reactivestreams.Publisher#subscribe(org.reactivestreams.Subscriber)}. Each call to the subscribe
* method will result in a new {@link org.reactivestreams.Subscription} i.e., a new contract to stream data from the
* starting request.
*
*
*
* The following are few ways to use the response class:
*
* 1) Using the subscribe helper method
*
*
* {@code
* software.amazon.awssdk.services.managedblockchain.paginators.ListInvitationsPublisher publisher = client.listInvitationsPaginator(request);
* CompletableFuture future = publisher.subscribe(res -> { // Do something with the response });
* future.get();
* }
*
*
* 2) Using a custom subscriber
*
*
* {@code
* software.amazon.awssdk.services.managedblockchain.paginators.ListInvitationsPublisher publisher = client.listInvitationsPaginator(request);
* publisher.subscribe(new Subscriber() {
*
* public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
*
*
* public void onNext(software.amazon.awssdk.services.managedblockchain.model.ListInvitationsResponse response) { //... };
* });}
*
*
* As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.
*
* Please notice that the configuration of MaxResults won't limit the number of results you get with the
* paginator. It only limits the number of results in each page.
*
*
* Note: If you prefer to have control on service calls, use the
* {@link #listInvitations(software.amazon.awssdk.services.managedblockchain.model.ListInvitationsRequest)}
* operation.
*
*
* @param listInvitationsRequest
* @return A custom publisher that can be subscribed to request a stream of response pages.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InvalidRequestException The action or operation requested is invalid. Verify that the action is typed
* correctly.
* - AccessDeniedException You don't have sufficient access to perform this action.
* - ResourceNotFoundException A requested resource doesn't exist. It may have been deleted or referenced
* incorrectly.
* - ThrottlingException The request or operation couldn't be performed because a service is throttling
* requests. The most common source of throttling errors is creating resources that exceed your service
* limit for this resource type. Request a limit increase or delete unused resources if possible.
* - ResourceLimitExceededException The maximum number of resources of that type already exist. Ensure the
* resources requested are within the boundaries of the service edition and your account limits.
* - InternalServiceErrorException The request processing has failed because of an unknown error,
* exception or failure.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - ManagedBlockchainException Base class for all service exceptions. Unknown exceptions will be thrown
* as an instance of this type.
*
* @sample ManagedBlockchainAsyncClient.ListInvitations
* @see AWS API Documentation
*/
default ListInvitationsPublisher listInvitationsPaginator(ListInvitationsRequest listInvitationsRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Returns a list of all invitations for the current Amazon Web Services account.
*
*
* Applies only to Hyperledger Fabric.
*
*
*
* This is a variant of
* {@link #listInvitations(software.amazon.awssdk.services.managedblockchain.model.ListInvitationsRequest)}
* operation. The return type is a custom publisher that can be subscribed to request a stream of response pages.
* SDK will internally handle making service calls for you.
*
*
* When the operation is called, an instance of this class is returned. At this point, no service calls are made yet
* and so there is no guarantee that the request is valid. If there are errors in your request, you will see the
* failures only after you start streaming the data. The subscribe method should be called as a request to start
* streaming data. For more info, see
* {@link org.reactivestreams.Publisher#subscribe(org.reactivestreams.Subscriber)}. Each call to the subscribe
* method will result in a new {@link org.reactivestreams.Subscription} i.e., a new contract to stream data from the
* starting request.
*
*
*
* The following are few ways to use the response class:
*
* 1) Using the subscribe helper method
*
*
* {@code
* software.amazon.awssdk.services.managedblockchain.paginators.ListInvitationsPublisher publisher = client.listInvitationsPaginator(request);
* CompletableFuture future = publisher.subscribe(res -> { // Do something with the response });
* future.get();
* }
*
*
* 2) Using a custom subscriber
*
*
* {@code
* software.amazon.awssdk.services.managedblockchain.paginators.ListInvitationsPublisher publisher = client.listInvitationsPaginator(request);
* publisher.subscribe(new Subscriber() {
*
* public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
*
*
* public void onNext(software.amazon.awssdk.services.managedblockchain.model.ListInvitationsResponse response) { //... };
* });}
*
*
* As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.
*
* Please notice that the configuration of MaxResults won't limit the number of results you get with the
* paginator. It only limits the number of results in each page.
*
*
* Note: If you prefer to have control on service calls, use the
* {@link #listInvitations(software.amazon.awssdk.services.managedblockchain.model.ListInvitationsRequest)}
* operation.
*
*
* This is a convenience which creates an instance of the {@link ListInvitationsRequest.Builder} avoiding the need
* to create one manually via {@link ListInvitationsRequest#builder()}
*
*
* @param listInvitationsRequest
* A {@link Consumer} that will call methods on {@link ListInvitationsInput.Builder} to create a request.
* @return A custom publisher that can be subscribed to request a stream of response pages.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InvalidRequestException The action or operation requested is invalid. Verify that the action is typed
* correctly.
* - AccessDeniedException You don't have sufficient access to perform this action.
* - ResourceNotFoundException A requested resource doesn't exist. It may have been deleted or referenced
* incorrectly.
* - ThrottlingException The request or operation couldn't be performed because a service is throttling
* requests. The most common source of throttling errors is creating resources that exceed your service
* limit for this resource type. Request a limit increase or delete unused resources if possible.
* - ResourceLimitExceededException The maximum number of resources of that type already exist. Ensure the
* resources requested are within the boundaries of the service edition and your account limits.
* - InternalServiceErrorException The request processing has failed because of an unknown error,
* exception or failure.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - ManagedBlockchainException Base class for all service exceptions. Unknown exceptions will be thrown
* as an instance of this type.
*
* @sample ManagedBlockchainAsyncClient.ListInvitations
* @see AWS API Documentation
*/
default ListInvitationsPublisher listInvitationsPaginator(Consumer listInvitationsRequest) {
return listInvitationsPaginator(ListInvitationsRequest.builder().applyMutation(listInvitationsRequest).build());
}
/**
*
* Returns a list of the members in a network and properties of their configurations.
*
*
* Applies only to Hyperledger Fabric.
*
*
* @param listMembersRequest
* @return A Java Future containing the result of the ListMembers operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InvalidRequestException The action or operation requested is invalid. Verify that the action is typed
* correctly.
* - AccessDeniedException You don't have sufficient access to perform this action.
* - ThrottlingException The request or operation couldn't be performed because a service is throttling
* requests. The most common source of throttling errors is creating resources that exceed your service
* limit for this resource type. Request a limit increase or delete unused resources if possible.
* - InternalServiceErrorException The request processing has failed because of an unknown error,
* exception or failure.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - ManagedBlockchainException Base class for all service exceptions. Unknown exceptions will be thrown
* as an instance of this type.
*
* @sample ManagedBlockchainAsyncClient.ListMembers
* @see AWS
* API Documentation
*/
default CompletableFuture listMembers(ListMembersRequest listMembersRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Returns a list of the members in a network and properties of their configurations.
*
*
* Applies only to Hyperledger Fabric.
*
*
*
* This is a convenience which creates an instance of the {@link ListMembersRequest.Builder} avoiding the need to
* create one manually via {@link ListMembersRequest#builder()}
*
*
* @param listMembersRequest
* A {@link Consumer} that will call methods on {@link ListMembersInput.Builder} to create a request.
* @return A Java Future containing the result of the ListMembers operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InvalidRequestException The action or operation requested is invalid. Verify that the action is typed
* correctly.
* - AccessDeniedException You don't have sufficient access to perform this action.
* - ThrottlingException The request or operation couldn't be performed because a service is throttling
* requests. The most common source of throttling errors is creating resources that exceed your service
* limit for this resource type. Request a limit increase or delete unused resources if possible.
* - InternalServiceErrorException The request processing has failed because of an unknown error,
* exception or failure.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - ManagedBlockchainException Base class for all service exceptions. Unknown exceptions will be thrown
* as an instance of this type.
*
* @sample ManagedBlockchainAsyncClient.ListMembers
* @see AWS
* API Documentation
*/
default CompletableFuture listMembers(Consumer listMembersRequest) {
return listMembers(ListMembersRequest.builder().applyMutation(listMembersRequest).build());
}
/**
*
* Returns a list of the members in a network and properties of their configurations.
*
*
* Applies only to Hyperledger Fabric.
*
*
*
* This is a variant of
* {@link #listMembers(software.amazon.awssdk.services.managedblockchain.model.ListMembersRequest)} operation. The
* return type is a custom publisher that can be subscribed to request a stream of response pages. SDK will
* internally handle making service calls for you.
*
*
* When the operation is called, an instance of this class is returned. At this point, no service calls are made yet
* and so there is no guarantee that the request is valid. If there are errors in your request, you will see the
* failures only after you start streaming the data. The subscribe method should be called as a request to start
* streaming data. For more info, see
* {@link org.reactivestreams.Publisher#subscribe(org.reactivestreams.Subscriber)}. Each call to the subscribe
* method will result in a new {@link org.reactivestreams.Subscription} i.e., a new contract to stream data from the
* starting request.
*
*
*
* The following are few ways to use the response class:
*
* 1) Using the subscribe helper method
*
*
* {@code
* software.amazon.awssdk.services.managedblockchain.paginators.ListMembersPublisher publisher = client.listMembersPaginator(request);
* CompletableFuture future = publisher.subscribe(res -> { // Do something with the response });
* future.get();
* }
*
*
* 2) Using a custom subscriber
*
*
* {@code
* software.amazon.awssdk.services.managedblockchain.paginators.ListMembersPublisher publisher = client.listMembersPaginator(request);
* publisher.subscribe(new Subscriber() {
*
* public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
*
*
* public void onNext(software.amazon.awssdk.services.managedblockchain.model.ListMembersResponse response) { //... };
* });}
*
*
* As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.
*
* Please notice that the configuration of MaxResults won't limit the number of results you get with the
* paginator. It only limits the number of results in each page.
*
*
* Note: If you prefer to have control on service calls, use the
* {@link #listMembers(software.amazon.awssdk.services.managedblockchain.model.ListMembersRequest)} operation.
*
*
* @param listMembersRequest
* @return A custom publisher that can be subscribed to request a stream of response pages.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InvalidRequestException The action or operation requested is invalid. Verify that the action is typed
* correctly.
* - AccessDeniedException You don't have sufficient access to perform this action.
* - ThrottlingException The request or operation couldn't be performed because a service is throttling
* requests. The most common source of throttling errors is creating resources that exceed your service
* limit for this resource type. Request a limit increase or delete unused resources if possible.
* - InternalServiceErrorException The request processing has failed because of an unknown error,
* exception or failure.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - ManagedBlockchainException Base class for all service exceptions. Unknown exceptions will be thrown
* as an instance of this type.
*
* @sample ManagedBlockchainAsyncClient.ListMembers
* @see AWS
* API Documentation
*/
default ListMembersPublisher listMembersPaginator(ListMembersRequest listMembersRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Returns a list of the members in a network and properties of their configurations.
*
*
* Applies only to Hyperledger Fabric.
*
*
*
* This is a variant of
* {@link #listMembers(software.amazon.awssdk.services.managedblockchain.model.ListMembersRequest)} operation. The
* return type is a custom publisher that can be subscribed to request a stream of response pages. SDK will
* internally handle making service calls for you.
*
*
* When the operation is called, an instance of this class is returned. At this point, no service calls are made yet
* and so there is no guarantee that the request is valid. If there are errors in your request, you will see the
* failures only after you start streaming the data. The subscribe method should be called as a request to start
* streaming data. For more info, see
* {@link org.reactivestreams.Publisher#subscribe(org.reactivestreams.Subscriber)}. Each call to the subscribe
* method will result in a new {@link org.reactivestreams.Subscription} i.e., a new contract to stream data from the
* starting request.
*
*
*
* The following are few ways to use the response class:
*
* 1) Using the subscribe helper method
*
*
* {@code
* software.amazon.awssdk.services.managedblockchain.paginators.ListMembersPublisher publisher = client.listMembersPaginator(request);
* CompletableFuture future = publisher.subscribe(res -> { // Do something with the response });
* future.get();
* }
*
*
* 2) Using a custom subscriber
*
*
* {@code
* software.amazon.awssdk.services.managedblockchain.paginators.ListMembersPublisher publisher = client.listMembersPaginator(request);
* publisher.subscribe(new Subscriber() {
*
* public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
*
*
* public void onNext(software.amazon.awssdk.services.managedblockchain.model.ListMembersResponse response) { //... };
* });}
*
*
* As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.
*
* Please notice that the configuration of MaxResults won't limit the number of results you get with the
* paginator. It only limits the number of results in each page.
*
*
* Note: If you prefer to have control on service calls, use the
* {@link #listMembers(software.amazon.awssdk.services.managedblockchain.model.ListMembersRequest)} operation.
*
*
* This is a convenience which creates an instance of the {@link ListMembersRequest.Builder} avoiding the need to
* create one manually via {@link ListMembersRequest#builder()}
*
*
* @param listMembersRequest
* A {@link Consumer} that will call methods on {@link ListMembersInput.Builder} to create a request.
* @return A custom publisher that can be subscribed to request a stream of response pages.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InvalidRequestException The action or operation requested is invalid. Verify that the action is typed
* correctly.
* - AccessDeniedException You don't have sufficient access to perform this action.
* - ThrottlingException The request or operation couldn't be performed because a service is throttling
* requests. The most common source of throttling errors is creating resources that exceed your service
* limit for this resource type. Request a limit increase or delete unused resources if possible.
* - InternalServiceErrorException The request processing has failed because of an unknown error,
* exception or failure.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - ManagedBlockchainException Base class for all service exceptions. Unknown exceptions will be thrown
* as an instance of this type.
*
* @sample ManagedBlockchainAsyncClient.ListMembers
* @see AWS
* API Documentation
*/
default ListMembersPublisher listMembersPaginator(Consumer listMembersRequest) {
return listMembersPaginator(ListMembersRequest.builder().applyMutation(listMembersRequest).build());
}
/**
*
* Returns information about the networks in which the current Amazon Web Services account participates.
*
*
* Applies to Hyperledger Fabric and Ethereum.
*
*
* @param listNetworksRequest
* @return A Java Future containing the result of the ListNetworks operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InvalidRequestException The action or operation requested is invalid. Verify that the action is typed
* correctly.
* - AccessDeniedException You don't have sufficient access to perform this action.
* - ThrottlingException The request or operation couldn't be performed because a service is throttling
* requests. The most common source of throttling errors is creating resources that exceed your service
* limit for this resource type. Request a limit increase or delete unused resources if possible.
* - InternalServiceErrorException The request processing has failed because of an unknown error,
* exception or failure.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - ManagedBlockchainException Base class for all service exceptions. Unknown exceptions will be thrown
* as an instance of this type.
*
* @sample ManagedBlockchainAsyncClient.ListNetworks
* @see AWS API Documentation
*/
default CompletableFuture listNetworks(ListNetworksRequest listNetworksRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Returns information about the networks in which the current Amazon Web Services account participates.
*
*
* Applies to Hyperledger Fabric and Ethereum.
*
*
*
* This is a convenience which creates an instance of the {@link ListNetworksRequest.Builder} avoiding the need to
* create one manually via {@link ListNetworksRequest#builder()}
*
*
* @param listNetworksRequest
* A {@link Consumer} that will call methods on {@link ListNetworksInput.Builder} to create a request.
* @return A Java Future containing the result of the ListNetworks operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InvalidRequestException The action or operation requested is invalid. Verify that the action is typed
* correctly.
* - AccessDeniedException You don't have sufficient access to perform this action.
* - ThrottlingException The request or operation couldn't be performed because a service is throttling
* requests. The most common source of throttling errors is creating resources that exceed your service
* limit for this resource type. Request a limit increase or delete unused resources if possible.
* - InternalServiceErrorException The request processing has failed because of an unknown error,
* exception or failure.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - ManagedBlockchainException Base class for all service exceptions. Unknown exceptions will be thrown
* as an instance of this type.
*
* @sample ManagedBlockchainAsyncClient.ListNetworks
* @see AWS API Documentation
*/
default CompletableFuture listNetworks(Consumer listNetworksRequest) {
return listNetworks(ListNetworksRequest.builder().applyMutation(listNetworksRequest).build());
}
/**
*
* Returns information about the networks in which the current Amazon Web Services account participates.
*
*
* Applies to Hyperledger Fabric and Ethereum.
*
*
*
* This is a variant of
* {@link #listNetworks(software.amazon.awssdk.services.managedblockchain.model.ListNetworksRequest)} operation. The
* return type is a custom publisher that can be subscribed to request a stream of response pages. SDK will
* internally handle making service calls for you.
*
*
* When the operation is called, an instance of this class is returned. At this point, no service calls are made yet
* and so there is no guarantee that the request is valid. If there are errors in your request, you will see the
* failures only after you start streaming the data. The subscribe method should be called as a request to start
* streaming data. For more info, see
* {@link org.reactivestreams.Publisher#subscribe(org.reactivestreams.Subscriber)}. Each call to the subscribe
* method will result in a new {@link org.reactivestreams.Subscription} i.e., a new contract to stream data from the
* starting request.
*
*
*
* The following are few ways to use the response class:
*
* 1) Using the subscribe helper method
*
*
* {@code
* software.amazon.awssdk.services.managedblockchain.paginators.ListNetworksPublisher publisher = client.listNetworksPaginator(request);
* CompletableFuture future = publisher.subscribe(res -> { // Do something with the response });
* future.get();
* }
*
*
* 2) Using a custom subscriber
*
*
* {@code
* software.amazon.awssdk.services.managedblockchain.paginators.ListNetworksPublisher publisher = client.listNetworksPaginator(request);
* publisher.subscribe(new Subscriber() {
*
* public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
*
*
* public void onNext(software.amazon.awssdk.services.managedblockchain.model.ListNetworksResponse response) { //... };
* });}
*
*
* As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.
*
* Please notice that the configuration of MaxResults won't limit the number of results you get with the
* paginator. It only limits the number of results in each page.
*
*
* Note: If you prefer to have control on service calls, use the
* {@link #listNetworks(software.amazon.awssdk.services.managedblockchain.model.ListNetworksRequest)} operation.
*
*
* @param listNetworksRequest
* @return A custom publisher that can be subscribed to request a stream of response pages.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InvalidRequestException The action or operation requested is invalid. Verify that the action is typed
* correctly.
* - AccessDeniedException You don't have sufficient access to perform this action.
* - ThrottlingException The request or operation couldn't be performed because a service is throttling
* requests. The most common source of throttling errors is creating resources that exceed your service
* limit for this resource type. Request a limit increase or delete unused resources if possible.
* - InternalServiceErrorException The request processing has failed because of an unknown error,
* exception or failure.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - ManagedBlockchainException Base class for all service exceptions. Unknown exceptions will be thrown
* as an instance of this type.
*
* @sample ManagedBlockchainAsyncClient.ListNetworks
* @see AWS API Documentation
*/
default ListNetworksPublisher listNetworksPaginator(ListNetworksRequest listNetworksRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Returns information about the networks in which the current Amazon Web Services account participates.
*
*
* Applies to Hyperledger Fabric and Ethereum.
*
*
*
* This is a variant of
* {@link #listNetworks(software.amazon.awssdk.services.managedblockchain.model.ListNetworksRequest)} operation. The
* return type is a custom publisher that can be subscribed to request a stream of response pages. SDK will
* internally handle making service calls for you.
*
*
* When the operation is called, an instance of this class is returned. At this point, no service calls are made yet
* and so there is no guarantee that the request is valid. If there are errors in your request, you will see the
* failures only after you start streaming the data. The subscribe method should be called as a request to start
* streaming data. For more info, see
* {@link org.reactivestreams.Publisher#subscribe(org.reactivestreams.Subscriber)}. Each call to the subscribe
* method will result in a new {@link org.reactivestreams.Subscription} i.e., a new contract to stream data from the
* starting request.
*
*
*
* The following are few ways to use the response class:
*
* 1) Using the subscribe helper method
*
*
* {@code
* software.amazon.awssdk.services.managedblockchain.paginators.ListNetworksPublisher publisher = client.listNetworksPaginator(request);
* CompletableFuture future = publisher.subscribe(res -> { // Do something with the response });
* future.get();
* }
*
*
* 2) Using a custom subscriber
*
*
* {@code
* software.amazon.awssdk.services.managedblockchain.paginators.ListNetworksPublisher publisher = client.listNetworksPaginator(request);
* publisher.subscribe(new Subscriber() {
*
* public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
*
*
* public void onNext(software.amazon.awssdk.services.managedblockchain.model.ListNetworksResponse response) { //... };
* });}
*
*
* As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.
*
* Please notice that the configuration of MaxResults won't limit the number of results you get with the
* paginator. It only limits the number of results in each page.
*
*
* Note: If you prefer to have control on service calls, use the
* {@link #listNetworks(software.amazon.awssdk.services.managedblockchain.model.ListNetworksRequest)} operation.
*
*
* This is a convenience which creates an instance of the {@link ListNetworksRequest.Builder} avoiding the need to
* create one manually via {@link ListNetworksRequest#builder()}
*
*
* @param listNetworksRequest
* A {@link Consumer} that will call methods on {@link ListNetworksInput.Builder} to create a request.
* @return A custom publisher that can be subscribed to request a stream of response pages.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InvalidRequestException The action or operation requested is invalid. Verify that the action is typed
* correctly.
* - AccessDeniedException You don't have sufficient access to perform this action.
* - ThrottlingException The request or operation couldn't be performed because a service is throttling
* requests. The most common source of throttling errors is creating resources that exceed your service
* limit for this resource type. Request a limit increase or delete unused resources if possible.
* - InternalServiceErrorException The request processing has failed because of an unknown error,
* exception or failure.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - ManagedBlockchainException Base class for all service exceptions. Unknown exceptions will be thrown
* as an instance of this type.
*
* @sample ManagedBlockchainAsyncClient.ListNetworks
* @see AWS API Documentation
*/
default ListNetworksPublisher listNetworksPaginator(Consumer listNetworksRequest) {
return listNetworksPaginator(ListNetworksRequest.builder().applyMutation(listNetworksRequest).build());
}
/**
*
* Returns information about the nodes within a network.
*
*
* Applies to Hyperledger Fabric and Ethereum.
*
*
* @param listNodesRequest
* @return A Java Future containing the result of the ListNodes operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InvalidRequestException The action or operation requested is invalid. Verify that the action is typed
* correctly.
* - AccessDeniedException You don't have sufficient access to perform this action.
* - ThrottlingException The request or operation couldn't be performed because a service is throttling
* requests. The most common source of throttling errors is creating resources that exceed your service
* limit for this resource type. Request a limit increase or delete unused resources if possible.
* - InternalServiceErrorException The request processing has failed because of an unknown error,
* exception or failure.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - ManagedBlockchainException Base class for all service exceptions. Unknown exceptions will be thrown
* as an instance of this type.
*
* @sample ManagedBlockchainAsyncClient.ListNodes
* @see AWS
* API Documentation
*/
default CompletableFuture listNodes(ListNodesRequest listNodesRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Returns information about the nodes within a network.
*
*
* Applies to Hyperledger Fabric and Ethereum.
*
*
*
* This is a convenience which creates an instance of the {@link ListNodesRequest.Builder} avoiding the need to
* create one manually via {@link ListNodesRequest#builder()}
*
*
* @param listNodesRequest
* A {@link Consumer} that will call methods on {@link ListNodesInput.Builder} to create a request.
* @return A Java Future containing the result of the ListNodes operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InvalidRequestException The action or operation requested is invalid. Verify that the action is typed
* correctly.
* - AccessDeniedException You don't have sufficient access to perform this action.
* - ThrottlingException The request or operation couldn't be performed because a service is throttling
* requests. The most common source of throttling errors is creating resources that exceed your service
* limit for this resource type. Request a limit increase or delete unused resources if possible.
* - InternalServiceErrorException The request processing has failed because of an unknown error,
* exception or failure.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - ManagedBlockchainException Base class for all service exceptions. Unknown exceptions will be thrown
* as an instance of this type.
*
* @sample ManagedBlockchainAsyncClient.ListNodes
* @see AWS
* API Documentation
*/
default CompletableFuture listNodes(Consumer listNodesRequest) {
return listNodes(ListNodesRequest.builder().applyMutation(listNodesRequest).build());
}
/**
*
* Returns information about the nodes within a network.
*
*
* Applies to Hyperledger Fabric and Ethereum.
*
*
*
* This is a variant of {@link #listNodes(software.amazon.awssdk.services.managedblockchain.model.ListNodesRequest)}
* operation. The return type is a custom publisher that can be subscribed to request a stream of response pages.
* SDK will internally handle making service calls for you.
*
*
* When the operation is called, an instance of this class is returned. At this point, no service calls are made yet
* and so there is no guarantee that the request is valid. If there are errors in your request, you will see the
* failures only after you start streaming the data. The subscribe method should be called as a request to start
* streaming data. For more info, see
* {@link org.reactivestreams.Publisher#subscribe(org.reactivestreams.Subscriber)}. Each call to the subscribe
* method will result in a new {@link org.reactivestreams.Subscription} i.e., a new contract to stream data from the
* starting request.
*
*
*
* The following are few ways to use the response class:
*
* 1) Using the subscribe helper method
*
*
* {@code
* software.amazon.awssdk.services.managedblockchain.paginators.ListNodesPublisher publisher = client.listNodesPaginator(request);
* CompletableFuture future = publisher.subscribe(res -> { // Do something with the response });
* future.get();
* }
*
*
* 2) Using a custom subscriber
*
*
* {@code
* software.amazon.awssdk.services.managedblockchain.paginators.ListNodesPublisher publisher = client.listNodesPaginator(request);
* publisher.subscribe(new Subscriber() {
*
* public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
*
*
* public void onNext(software.amazon.awssdk.services.managedblockchain.model.ListNodesResponse response) { //... };
* });}
*
*
* As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.
*
* Please notice that the configuration of MaxResults won't limit the number of results you get with the
* paginator. It only limits the number of results in each page.
*
*
* Note: If you prefer to have control on service calls, use the
* {@link #listNodes(software.amazon.awssdk.services.managedblockchain.model.ListNodesRequest)} operation.
*
*
* @param listNodesRequest
* @return A custom publisher that can be subscribed to request a stream of response pages.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InvalidRequestException The action or operation requested is invalid. Verify that the action is typed
* correctly.
* - AccessDeniedException You don't have sufficient access to perform this action.
* - ThrottlingException The request or operation couldn't be performed because a service is throttling
* requests. The most common source of throttling errors is creating resources that exceed your service
* limit for this resource type. Request a limit increase or delete unused resources if possible.
* - InternalServiceErrorException The request processing has failed because of an unknown error,
* exception or failure.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - ManagedBlockchainException Base class for all service exceptions. Unknown exceptions will be thrown
* as an instance of this type.
*
* @sample ManagedBlockchainAsyncClient.ListNodes
* @see AWS
* API Documentation
*/
default ListNodesPublisher listNodesPaginator(ListNodesRequest listNodesRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Returns information about the nodes within a network.
*
*
* Applies to Hyperledger Fabric and Ethereum.
*
*
*
* This is a variant of {@link #listNodes(software.amazon.awssdk.services.managedblockchain.model.ListNodesRequest)}
* operation. The return type is a custom publisher that can be subscribed to request a stream of response pages.
* SDK will internally handle making service calls for you.
*
*
* When the operation is called, an instance of this class is returned. At this point, no service calls are made yet
* and so there is no guarantee that the request is valid. If there are errors in your request, you will see the
* failures only after you start streaming the data. The subscribe method should be called as a request to start
* streaming data. For more info, see
* {@link org.reactivestreams.Publisher#subscribe(org.reactivestreams.Subscriber)}. Each call to the subscribe
* method will result in a new {@link org.reactivestreams.Subscription} i.e., a new contract to stream data from the
* starting request.
*
*
*
* The following are few ways to use the response class:
*
* 1) Using the subscribe helper method
*
*
* {@code
* software.amazon.awssdk.services.managedblockchain.paginators.ListNodesPublisher publisher = client.listNodesPaginator(request);
* CompletableFuture future = publisher.subscribe(res -> { // Do something with the response });
* future.get();
* }
*
*
* 2) Using a custom subscriber
*
*
* {@code
* software.amazon.awssdk.services.managedblockchain.paginators.ListNodesPublisher publisher = client.listNodesPaginator(request);
* publisher.subscribe(new Subscriber() {
*
* public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
*
*
* public void onNext(software.amazon.awssdk.services.managedblockchain.model.ListNodesResponse response) { //... };
* });}
*
*
* As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.
*
* Please notice that the configuration of MaxResults won't limit the number of results you get with the
* paginator. It only limits the number of results in each page.
*
*
* Note: If you prefer to have control on service calls, use the
* {@link #listNodes(software.amazon.awssdk.services.managedblockchain.model.ListNodesRequest)} operation.
*
*
* This is a convenience which creates an instance of the {@link ListNodesRequest.Builder} avoiding the need to
* create one manually via {@link ListNodesRequest#builder()}
*
*
* @param listNodesRequest
* A {@link Consumer} that will call methods on {@link ListNodesInput.Builder} to create a request.
* @return A custom publisher that can be subscribed to request a stream of response pages.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InvalidRequestException The action or operation requested is invalid. Verify that the action is typed
* correctly.
* - AccessDeniedException You don't have sufficient access to perform this action.
* - ThrottlingException The request or operation couldn't be performed because a service is throttling
* requests. The most common source of throttling errors is creating resources that exceed your service
* limit for this resource type. Request a limit increase or delete unused resources if possible.
* - InternalServiceErrorException The request processing has failed because of an unknown error,
* exception or failure.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - ManagedBlockchainException Base class for all service exceptions. Unknown exceptions will be thrown
* as an instance of this type.
*
* @sample ManagedBlockchainAsyncClient.ListNodes
* @see AWS
* API Documentation
*/
default ListNodesPublisher listNodesPaginator(Consumer listNodesRequest) {
return listNodesPaginator(ListNodesRequest.builder().applyMutation(listNodesRequest).build());
}
/**
*
* Returns the list of votes for a specified proposal, including the value of each vote and the unique identifier of
* the member that cast the vote.
*
*
* Applies only to Hyperledger Fabric.
*
*
* @param listProposalVotesRequest
* @return A Java Future containing the result of the ListProposalVotes operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InvalidRequestException The action or operation requested is invalid. Verify that the action is typed
* correctly.
* - AccessDeniedException You don't have sufficient access to perform this action.
* - ThrottlingException The request or operation couldn't be performed because a service is throttling
* requests. The most common source of throttling errors is creating resources that exceed your service
* limit for this resource type. Request a limit increase or delete unused resources if possible.
* - InternalServiceErrorException The request processing has failed because of an unknown error,
* exception or failure.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - ManagedBlockchainException Base class for all service exceptions. Unknown exceptions will be thrown
* as an instance of this type.
*
* @sample ManagedBlockchainAsyncClient.ListProposalVotes
* @see AWS API Documentation
*/
default CompletableFuture listProposalVotes(ListProposalVotesRequest listProposalVotesRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Returns the list of votes for a specified proposal, including the value of each vote and the unique identifier of
* the member that cast the vote.
*
*
* Applies only to Hyperledger Fabric.
*
*
*
* This is a convenience which creates an instance of the {@link ListProposalVotesRequest.Builder} avoiding the need
* to create one manually via {@link ListProposalVotesRequest#builder()}
*
*
* @param listProposalVotesRequest
* A {@link Consumer} that will call methods on {@link ListProposalVotesInput.Builder} to create a request.
* @return A Java Future containing the result of the ListProposalVotes operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InvalidRequestException The action or operation requested is invalid. Verify that the action is typed
* correctly.
* - AccessDeniedException You don't have sufficient access to perform this action.
* - ThrottlingException The request or operation couldn't be performed because a service is throttling
* requests. The most common source of throttling errors is creating resources that exceed your service
* limit for this resource type. Request a limit increase or delete unused resources if possible.
* - InternalServiceErrorException The request processing has failed because of an unknown error,
* exception or failure.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - ManagedBlockchainException Base class for all service exceptions. Unknown exceptions will be thrown
* as an instance of this type.
*
* @sample ManagedBlockchainAsyncClient.ListProposalVotes
* @see AWS API Documentation
*/
default CompletableFuture listProposalVotes(
Consumer listProposalVotesRequest) {
return listProposalVotes(ListProposalVotesRequest.builder().applyMutation(listProposalVotesRequest).build());
}
/**
*
* Returns the list of votes for a specified proposal, including the value of each vote and the unique identifier of
* the member that cast the vote.
*
*
* Applies only to Hyperledger Fabric.
*
*
*
* This is a variant of
* {@link #listProposalVotes(software.amazon.awssdk.services.managedblockchain.model.ListProposalVotesRequest)}
* operation. The return type is a custom publisher that can be subscribed to request a stream of response pages.
* SDK will internally handle making service calls for you.
*
*
* When the operation is called, an instance of this class is returned. At this point, no service calls are made yet
* and so there is no guarantee that the request is valid. If there are errors in your request, you will see the
* failures only after you start streaming the data. The subscribe method should be called as a request to start
* streaming data. For more info, see
* {@link org.reactivestreams.Publisher#subscribe(org.reactivestreams.Subscriber)}. Each call to the subscribe
* method will result in a new {@link org.reactivestreams.Subscription} i.e., a new contract to stream data from the
* starting request.
*
*
*
* The following are few ways to use the response class:
*
* 1) Using the subscribe helper method
*
*
* {@code
* software.amazon.awssdk.services.managedblockchain.paginators.ListProposalVotesPublisher publisher = client.listProposalVotesPaginator(request);
* CompletableFuture future = publisher.subscribe(res -> { // Do something with the response });
* future.get();
* }
*
*
* 2) Using a custom subscriber
*
*
* {@code
* software.amazon.awssdk.services.managedblockchain.paginators.ListProposalVotesPublisher publisher = client.listProposalVotesPaginator(request);
* publisher.subscribe(new Subscriber() {
*
* public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
*
*
* public void onNext(software.amazon.awssdk.services.managedblockchain.model.ListProposalVotesResponse response) { //... };
* });}
*
*
* As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.
*
* Please notice that the configuration of MaxResults won't limit the number of results you get with the
* paginator. It only limits the number of results in each page.
*
*
* Note: If you prefer to have control on service calls, use the
* {@link #listProposalVotes(software.amazon.awssdk.services.managedblockchain.model.ListProposalVotesRequest)}
* operation.
*
*
* @param listProposalVotesRequest
* @return A custom publisher that can be subscribed to request a stream of response pages.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InvalidRequestException The action or operation requested is invalid. Verify that the action is typed
* correctly.
* - AccessDeniedException You don't have sufficient access to perform this action.
* - ThrottlingException The request or operation couldn't be performed because a service is throttling
* requests. The most common source of throttling errors is creating resources that exceed your service
* limit for this resource type. Request a limit increase or delete unused resources if possible.
* - InternalServiceErrorException The request processing has failed because of an unknown error,
* exception or failure.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - ManagedBlockchainException Base class for all service exceptions. Unknown exceptions will be thrown
* as an instance of this type.
*
* @sample ManagedBlockchainAsyncClient.ListProposalVotes
* @see AWS API Documentation
*/
default ListProposalVotesPublisher listProposalVotesPaginator(ListProposalVotesRequest listProposalVotesRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Returns the list of votes for a specified proposal, including the value of each vote and the unique identifier of
* the member that cast the vote.
*
*
* Applies only to Hyperledger Fabric.
*
*
*
* This is a variant of
* {@link #listProposalVotes(software.amazon.awssdk.services.managedblockchain.model.ListProposalVotesRequest)}
* operation. The return type is a custom publisher that can be subscribed to request a stream of response pages.
* SDK will internally handle making service calls for you.
*
*
* When the operation is called, an instance of this class is returned. At this point, no service calls are made yet
* and so there is no guarantee that the request is valid. If there are errors in your request, you will see the
* failures only after you start streaming the data. The subscribe method should be called as a request to start
* streaming data. For more info, see
* {@link org.reactivestreams.Publisher#subscribe(org.reactivestreams.Subscriber)}. Each call to the subscribe
* method will result in a new {@link org.reactivestreams.Subscription} i.e., a new contract to stream data from the
* starting request.
*
*
*
* The following are few ways to use the response class:
*
* 1) Using the subscribe helper method
*
*
* {@code
* software.amazon.awssdk.services.managedblockchain.paginators.ListProposalVotesPublisher publisher = client.listProposalVotesPaginator(request);
* CompletableFuture future = publisher.subscribe(res -> { // Do something with the response });
* future.get();
* }
*
*
* 2) Using a custom subscriber
*
*
* {@code
* software.amazon.awssdk.services.managedblockchain.paginators.ListProposalVotesPublisher publisher = client.listProposalVotesPaginator(request);
* publisher.subscribe(new Subscriber() {
*
* public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
*
*
* public void onNext(software.amazon.awssdk.services.managedblockchain.model.ListProposalVotesResponse response) { //... };
* });}
*
*
* As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.
*
* Please notice that the configuration of MaxResults won't limit the number of results you get with the
* paginator. It only limits the number of results in each page.
*
*
* Note: If you prefer to have control on service calls, use the
* {@link #listProposalVotes(software.amazon.awssdk.services.managedblockchain.model.ListProposalVotesRequest)}
* operation.
*
*
* This is a convenience which creates an instance of the {@link ListProposalVotesRequest.Builder} avoiding the need
* to create one manually via {@link ListProposalVotesRequest#builder()}
*
*
* @param listProposalVotesRequest
* A {@link Consumer} that will call methods on {@link ListProposalVotesInput.Builder} to create a request.
* @return A custom publisher that can be subscribed to request a stream of response pages.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InvalidRequestException The action or operation requested is invalid. Verify that the action is typed
* correctly.
* - AccessDeniedException You don't have sufficient access to perform this action.
* - ThrottlingException The request or operation couldn't be performed because a service is throttling
* requests. The most common source of throttling errors is creating resources that exceed your service
* limit for this resource type. Request a limit increase or delete unused resources if possible.
* - InternalServiceErrorException The request processing has failed because of an unknown error,
* exception or failure.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - ManagedBlockchainException Base class for all service exceptions. Unknown exceptions will be thrown
* as an instance of this type.
*
* @sample ManagedBlockchainAsyncClient.ListProposalVotes
* @see AWS API Documentation
*/
default ListProposalVotesPublisher listProposalVotesPaginator(
Consumer listProposalVotesRequest) {
return listProposalVotesPaginator(ListProposalVotesRequest.builder().applyMutation(listProposalVotesRequest).build());
}
/**
*
* Returns a list of proposals for the network.
*
*
* Applies only to Hyperledger Fabric.
*
*
* @param listProposalsRequest
* @return A Java Future containing the result of the ListProposals operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InvalidRequestException The action or operation requested is invalid. Verify that the action is typed
* correctly.
* - ResourceNotFoundException A requested resource doesn't exist. It may have been deleted or referenced
* incorrectly.
* - AccessDeniedException You don't have sufficient access to perform this action.
* - ThrottlingException The request or operation couldn't be performed because a service is throttling
* requests. The most common source of throttling errors is creating resources that exceed your service
* limit for this resource type. Request a limit increase or delete unused resources if possible.
* - InternalServiceErrorException The request processing has failed because of an unknown error,
* exception or failure.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - ManagedBlockchainException Base class for all service exceptions. Unknown exceptions will be thrown
* as an instance of this type.
*
* @sample ManagedBlockchainAsyncClient.ListProposals
* @see AWS API Documentation
*/
default CompletableFuture listProposals(ListProposalsRequest listProposalsRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Returns a list of proposals for the network.
*
*
* Applies only to Hyperledger Fabric.
*
*
*
* This is a convenience which creates an instance of the {@link ListProposalsRequest.Builder} avoiding the need to
* create one manually via {@link ListProposalsRequest#builder()}
*
*
* @param listProposalsRequest
* A {@link Consumer} that will call methods on {@link ListProposalsInput.Builder} to create a request.
* @return A Java Future containing the result of the ListProposals operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InvalidRequestException The action or operation requested is invalid. Verify that the action is typed
* correctly.
* - ResourceNotFoundException A requested resource doesn't exist. It may have been deleted or referenced
* incorrectly.
* - AccessDeniedException You don't have sufficient access to perform this action.
* - ThrottlingException The request or operation couldn't be performed because a service is throttling
* requests. The most common source of throttling errors is creating resources that exceed your service
* limit for this resource type. Request a limit increase or delete unused resources if possible.
* - InternalServiceErrorException The request processing has failed because of an unknown error,
* exception or failure.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - ManagedBlockchainException Base class for all service exceptions. Unknown exceptions will be thrown
* as an instance of this type.
*
* @sample ManagedBlockchainAsyncClient.ListProposals
* @see AWS API Documentation
*/
default CompletableFuture listProposals(Consumer listProposalsRequest) {
return listProposals(ListProposalsRequest.builder().applyMutation(listProposalsRequest).build());
}
/**
*
* Returns a list of proposals for the network.
*
*
* Applies only to Hyperledger Fabric.
*
*
*
* This is a variant of
* {@link #listProposals(software.amazon.awssdk.services.managedblockchain.model.ListProposalsRequest)} operation.
* The return type is a custom publisher that can be subscribed to request a stream of response pages. SDK will
* internally handle making service calls for you.
*
*
* When the operation is called, an instance of this class is returned. At this point, no service calls are made yet
* and so there is no guarantee that the request is valid. If there are errors in your request, you will see the
* failures only after you start streaming the data. The subscribe method should be called as a request to start
* streaming data. For more info, see
* {@link org.reactivestreams.Publisher#subscribe(org.reactivestreams.Subscriber)}. Each call to the subscribe
* method will result in a new {@link org.reactivestreams.Subscription} i.e., a new contract to stream data from the
* starting request.
*
*
*
* The following are few ways to use the response class:
*
* 1) Using the subscribe helper method
*
*
* {@code
* software.amazon.awssdk.services.managedblockchain.paginators.ListProposalsPublisher publisher = client.listProposalsPaginator(request);
* CompletableFuture future = publisher.subscribe(res -> { // Do something with the response });
* future.get();
* }
*
*
* 2) Using a custom subscriber
*
*
* {@code
* software.amazon.awssdk.services.managedblockchain.paginators.ListProposalsPublisher publisher = client.listProposalsPaginator(request);
* publisher.subscribe(new Subscriber() {
*
* public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
*
*
* public void onNext(software.amazon.awssdk.services.managedblockchain.model.ListProposalsResponse response) { //... };
* });}
*
*
* As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.
*
* Please notice that the configuration of MaxResults won't limit the number of results you get with the
* paginator. It only limits the number of results in each page.
*
*
* Note: If you prefer to have control on service calls, use the
* {@link #listProposals(software.amazon.awssdk.services.managedblockchain.model.ListProposalsRequest)}
* operation.
*
*
* @param listProposalsRequest
* @return A custom publisher that can be subscribed to request a stream of response pages.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InvalidRequestException The action or operation requested is invalid. Verify that the action is typed
* correctly.
* - ResourceNotFoundException A requested resource doesn't exist. It may have been deleted or referenced
* incorrectly.
* - AccessDeniedException You don't have sufficient access to perform this action.
* - ThrottlingException The request or operation couldn't be performed because a service is throttling
* requests. The most common source of throttling errors is creating resources that exceed your service
* limit for this resource type. Request a limit increase or delete unused resources if possible.
* - InternalServiceErrorException The request processing has failed because of an unknown error,
* exception or failure.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - ManagedBlockchainException Base class for all service exceptions. Unknown exceptions will be thrown
* as an instance of this type.
*
* @sample ManagedBlockchainAsyncClient.ListProposals
* @see AWS API Documentation
*/
default ListProposalsPublisher listProposalsPaginator(ListProposalsRequest listProposalsRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Returns a list of proposals for the network.
*
*
* Applies only to Hyperledger Fabric.
*
*
*
* This is a variant of
* {@link #listProposals(software.amazon.awssdk.services.managedblockchain.model.ListProposalsRequest)} operation.
* The return type is a custom publisher that can be subscribed to request a stream of response pages. SDK will
* internally handle making service calls for you.
*
*
* When the operation is called, an instance of this class is returned. At this point, no service calls are made yet
* and so there is no guarantee that the request is valid. If there are errors in your request, you will see the
* failures only after you start streaming the data. The subscribe method should be called as a request to start
* streaming data. For more info, see
* {@link org.reactivestreams.Publisher#subscribe(org.reactivestreams.Subscriber)}. Each call to the subscribe
* method will result in a new {@link org.reactivestreams.Subscription} i.e., a new contract to stream data from the
* starting request.
*
*
*
* The following are few ways to use the response class:
*
* 1) Using the subscribe helper method
*
*
* {@code
* software.amazon.awssdk.services.managedblockchain.paginators.ListProposalsPublisher publisher = client.listProposalsPaginator(request);
* CompletableFuture future = publisher.subscribe(res -> { // Do something with the response });
* future.get();
* }
*
*
* 2) Using a custom subscriber
*
*
* {@code
* software.amazon.awssdk.services.managedblockchain.paginators.ListProposalsPublisher publisher = client.listProposalsPaginator(request);
* publisher.subscribe(new Subscriber() {
*
* public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
*
*
* public void onNext(software.amazon.awssdk.services.managedblockchain.model.ListProposalsResponse response) { //... };
* });}
*
*
* As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.
*
* Please notice that the configuration of MaxResults won't limit the number of results you get with the
* paginator. It only limits the number of results in each page.
*
*
* Note: If you prefer to have control on service calls, use the
* {@link #listProposals(software.amazon.awssdk.services.managedblockchain.model.ListProposalsRequest)}
* operation.
*
*
* This is a convenience which creates an instance of the {@link ListProposalsRequest.Builder} avoiding the need to
* create one manually via {@link ListProposalsRequest#builder()}
*
*
* @param listProposalsRequest
* A {@link Consumer} that will call methods on {@link ListProposalsInput.Builder} to create a request.
* @return A custom publisher that can be subscribed to request a stream of response pages.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InvalidRequestException The action or operation requested is invalid. Verify that the action is typed
* correctly.
* - ResourceNotFoundException A requested resource doesn't exist. It may have been deleted or referenced
* incorrectly.
* - AccessDeniedException You don't have sufficient access to perform this action.
* - ThrottlingException The request or operation couldn't be performed because a service is throttling
* requests. The most common source of throttling errors is creating resources that exceed your service
* limit for this resource type. Request a limit increase or delete unused resources if possible.
* - InternalServiceErrorException The request processing has failed because of an unknown error,
* exception or failure.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - ManagedBlockchainException Base class for all service exceptions. Unknown exceptions will be thrown
* as an instance of this type.
*
* @sample ManagedBlockchainAsyncClient.ListProposals
* @see AWS API Documentation
*/
default ListProposalsPublisher listProposalsPaginator(Consumer listProposalsRequest) {
return listProposalsPaginator(ListProposalsRequest.builder().applyMutation(listProposalsRequest).build());
}
/**
*
* Returns a list of tags for the specified resource. Each tag consists of a key and optional value.
*
*
* For more information about tags, see Tagging
* Resources in the Amazon Managed Blockchain Ethereum Developer Guide, or Tagging Resources in the Amazon Managed Blockchain Hyperledger Fabric Developer Guide.
*
*
* @param listTagsForResourceRequest
* @return A Java Future containing the result of the ListTagsForResource operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InternalServiceErrorException The request processing has failed because of an unknown error,
* exception or failure.
* - InvalidRequestException The action or operation requested is invalid. Verify that the action is typed
* correctly.
* - ResourceNotFoundException A requested resource doesn't exist. It may have been deleted or referenced
* incorrectly.
* - ResourceNotReadyException The requested resource exists but isn't in a status that can complete the
* operation.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - ManagedBlockchainException Base class for all service exceptions. Unknown exceptions will be thrown
* as an instance of this type.
*
* @sample ManagedBlockchainAsyncClient.ListTagsForResource
* @see AWS API Documentation
*/
default CompletableFuture listTagsForResource(
ListTagsForResourceRequest listTagsForResourceRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Returns a list of tags for the specified resource. Each tag consists of a key and optional value.
*
*
* For more information about tags, see Tagging
* Resources in the Amazon Managed Blockchain Ethereum Developer Guide, or Tagging Resources in the Amazon Managed Blockchain Hyperledger Fabric Developer Guide.
*
*
*
* This is a convenience which creates an instance of the {@link ListTagsForResourceRequest.Builder} avoiding the
* need to create one manually via {@link ListTagsForResourceRequest#builder()}
*
*
* @param listTagsForResourceRequest
* A {@link Consumer} that will call methods on {@link ListTagsForResourceRequest.Builder} to create a
* request.
* @return A Java Future containing the result of the ListTagsForResource operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InternalServiceErrorException The request processing has failed because of an unknown error,
* exception or failure.
* - InvalidRequestException The action or operation requested is invalid. Verify that the action is typed
* correctly.
* - ResourceNotFoundException A requested resource doesn't exist. It may have been deleted or referenced
* incorrectly.
* - ResourceNotReadyException The requested resource exists but isn't in a status that can complete the
* operation.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - ManagedBlockchainException Base class for all service exceptions. Unknown exceptions will be thrown
* as an instance of this type.
*
* @sample ManagedBlockchainAsyncClient.ListTagsForResource
* @see AWS API Documentation
*/
default CompletableFuture listTagsForResource(
Consumer listTagsForResourceRequest) {
return listTagsForResource(ListTagsForResourceRequest.builder().applyMutation(listTagsForResourceRequest).build());
}
/**
*
* Rejects an invitation to join a network. This action can be called by a principal in an Amazon Web Services
* account that has received an invitation to create a member and join a network.
*
*
* Applies only to Hyperledger Fabric.
*
*
* @param rejectInvitationRequest
* @return A Java Future containing the result of the RejectInvitation operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InvalidRequestException The action or operation requested is invalid. Verify that the action is typed
* correctly.
* - IllegalActionException
* - AccessDeniedException You don't have sufficient access to perform this action.
* - ResourceNotFoundException A requested resource doesn't exist. It may have been deleted or referenced
* incorrectly.
* - ThrottlingException The request or operation couldn't be performed because a service is throttling
* requests. The most common source of throttling errors is creating resources that exceed your service
* limit for this resource type. Request a limit increase or delete unused resources if possible.
* - InternalServiceErrorException The request processing has failed because of an unknown error,
* exception or failure.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - ManagedBlockchainException Base class for all service exceptions. Unknown exceptions will be thrown
* as an instance of this type.
*
* @sample ManagedBlockchainAsyncClient.RejectInvitation
* @see AWS API Documentation
*/
default CompletableFuture rejectInvitation(RejectInvitationRequest rejectInvitationRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Rejects an invitation to join a network. This action can be called by a principal in an Amazon Web Services
* account that has received an invitation to create a member and join a network.
*
*
* Applies only to Hyperledger Fabric.
*
*
*
* This is a convenience which creates an instance of the {@link RejectInvitationRequest.Builder} avoiding the need
* to create one manually via {@link RejectInvitationRequest#builder()}
*
*
* @param rejectInvitationRequest
* A {@link Consumer} that will call methods on {@link RejectInvitationInput.Builder} to create a request.
* @return A Java Future containing the result of the RejectInvitation operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InvalidRequestException The action or operation requested is invalid. Verify that the action is typed
* correctly.
* - IllegalActionException
* - AccessDeniedException You don't have sufficient access to perform this action.
* - ResourceNotFoundException A requested resource doesn't exist. It may have been deleted or referenced
* incorrectly.
* - ThrottlingException The request or operation couldn't be performed because a service is throttling
* requests. The most common source of throttling errors is creating resources that exceed your service
* limit for this resource type. Request a limit increase or delete unused resources if possible.
* - InternalServiceErrorException The request processing has failed because of an unknown error,
* exception or failure.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - ManagedBlockchainException Base class for all service exceptions. Unknown exceptions will be thrown
* as an instance of this type.
*
* @sample ManagedBlockchainAsyncClient.RejectInvitation
* @see AWS API Documentation
*/
default CompletableFuture rejectInvitation(
Consumer rejectInvitationRequest) {
return rejectInvitation(RejectInvitationRequest.builder().applyMutation(rejectInvitationRequest).build());
}
/**
*
* Adds or overwrites the specified tags for the specified Amazon Managed Blockchain resource. Each tag consists of
* a key and optional value.
*
*
* When you specify a tag key that already exists, the tag value is overwritten with the new value. Use
* UntagResource to remove tag keys.
*
*
* A resource can have up to 50 tags. If you try to create more than 50 tags for a resource, your request fails and
* returns an error.
*
*
* For more information about tags, see Tagging
* Resources in the Amazon Managed Blockchain Ethereum Developer Guide, or Tagging Resources in the Amazon Managed Blockchain Hyperledger Fabric Developer Guide.
*
*
* @param tagResourceRequest
* @return A Java Future containing the result of the TagResource operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InternalServiceErrorException The request processing has failed because of an unknown error,
* exception or failure.
* - InvalidRequestException The action or operation requested is invalid. Verify that the action is typed
* correctly.
* - ResourceNotFoundException A requested resource doesn't exist. It may have been deleted or referenced
* incorrectly.
* - TooManyTagsException
* - ResourceNotReadyException The requested resource exists but isn't in a status that can complete the
* operation.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - ManagedBlockchainException Base class for all service exceptions. Unknown exceptions will be thrown
* as an instance of this type.
*
* @sample ManagedBlockchainAsyncClient.TagResource
* @see AWS
* API Documentation
*/
default CompletableFuture tagResource(TagResourceRequest tagResourceRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Adds or overwrites the specified tags for the specified Amazon Managed Blockchain resource. Each tag consists of
* a key and optional value.
*
*
* When you specify a tag key that already exists, the tag value is overwritten with the new value. Use
* UntagResource to remove tag keys.
*
*
* A resource can have up to 50 tags. If you try to create more than 50 tags for a resource, your request fails and
* returns an error.
*
*
* For more information about tags, see Tagging
* Resources in the Amazon Managed Blockchain Ethereum Developer Guide, or Tagging Resources in the Amazon Managed Blockchain Hyperledger Fabric Developer Guide.
*
*
*
* This is a convenience which creates an instance of the {@link TagResourceRequest.Builder} avoiding the need to
* create one manually via {@link TagResourceRequest#builder()}
*
*
* @param tagResourceRequest
* A {@link Consumer} that will call methods on {@link TagResourceRequest.Builder} to create a request.
* @return A Java Future containing the result of the TagResource operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InternalServiceErrorException The request processing has failed because of an unknown error,
* exception or failure.
* - InvalidRequestException The action or operation requested is invalid. Verify that the action is typed
* correctly.
* - ResourceNotFoundException A requested resource doesn't exist. It may have been deleted or referenced
* incorrectly.
* - TooManyTagsException
* - ResourceNotReadyException The requested resource exists but isn't in a status that can complete the
* operation.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - ManagedBlockchainException Base class for all service exceptions. Unknown exceptions will be thrown
* as an instance of this type.
*
* @sample ManagedBlockchainAsyncClient.TagResource
* @see AWS
* API Documentation
*/
default CompletableFuture tagResource(Consumer tagResourceRequest) {
return tagResource(TagResourceRequest.builder().applyMutation(tagResourceRequest).build());
}
/**
*
* Removes the specified tags from the Amazon Managed Blockchain resource.
*
*
* For more information about tags, see Tagging
* Resources in the Amazon Managed Blockchain Ethereum Developer Guide, or Tagging Resources in the Amazon Managed Blockchain Hyperledger Fabric Developer Guide.
*
*
* @param untagResourceRequest
* @return A Java Future containing the result of the UntagResource operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InternalServiceErrorException The request processing has failed because of an unknown error,
* exception or failure.
* - InvalidRequestException The action or operation requested is invalid. Verify that the action is typed
* correctly.
* - ResourceNotFoundException A requested resource doesn't exist. It may have been deleted or referenced
* incorrectly.
* - ResourceNotReadyException The requested resource exists but isn't in a status that can complete the
* operation.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - ManagedBlockchainException Base class for all service exceptions. Unknown exceptions will be thrown
* as an instance of this type.
*
* @sample ManagedBlockchainAsyncClient.UntagResource
* @see AWS API Documentation
*/
default CompletableFuture untagResource(UntagResourceRequest untagResourceRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Removes the specified tags from the Amazon Managed Blockchain resource.
*
*
* For more information about tags, see Tagging
* Resources in the Amazon Managed Blockchain Ethereum Developer Guide, or Tagging Resources in the Amazon Managed Blockchain Hyperledger Fabric Developer Guide.
*
*
*
* This is a convenience which creates an instance of the {@link UntagResourceRequest.Builder} avoiding the need to
* create one manually via {@link UntagResourceRequest#builder()}
*
*
* @param untagResourceRequest
* A {@link Consumer} that will call methods on {@link UntagResourceRequest.Builder} to create a request.
* @return A Java Future containing the result of the UntagResource operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InternalServiceErrorException The request processing has failed because of an unknown error,
* exception or failure.
* - InvalidRequestException The action or operation requested is invalid. Verify that the action is typed
* correctly.
* - ResourceNotFoundException A requested resource doesn't exist. It may have been deleted or referenced
* incorrectly.
* - ResourceNotReadyException The requested resource exists but isn't in a status that can complete the
* operation.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - ManagedBlockchainException Base class for all service exceptions. Unknown exceptions will be thrown
* as an instance of this type.
*
* @sample ManagedBlockchainAsyncClient.UntagResource
* @see AWS API Documentation
*/
default CompletableFuture untagResource(Consumer untagResourceRequest) {
return untagResource(UntagResourceRequest.builder().applyMutation(untagResourceRequest).build());
}
/**
*
* Updates a member configuration with new parameters.
*
*
* Applies only to Hyperledger Fabric.
*
*
* @param updateMemberRequest
* @return A Java Future containing the result of the UpdateMember operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InvalidRequestException The action or operation requested is invalid. Verify that the action is typed
* correctly.
* - AccessDeniedException You don't have sufficient access to perform this action.
* - ResourceNotFoundException A requested resource doesn't exist. It may have been deleted or referenced
* incorrectly.
* - ThrottlingException The request or operation couldn't be performed because a service is throttling
* requests. The most common source of throttling errors is creating resources that exceed your service
* limit for this resource type. Request a limit increase or delete unused resources if possible.
* - InternalServiceErrorException The request processing has failed because of an unknown error,
* exception or failure.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - ManagedBlockchainException Base class for all service exceptions. Unknown exceptions will be thrown
* as an instance of this type.
*
* @sample ManagedBlockchainAsyncClient.UpdateMember
* @see AWS API Documentation
*/
default CompletableFuture updateMember(UpdateMemberRequest updateMemberRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Updates a member configuration with new parameters.
*
*
* Applies only to Hyperledger Fabric.
*
*
*
* This is a convenience which creates an instance of the {@link UpdateMemberRequest.Builder} avoiding the need to
* create one manually via {@link UpdateMemberRequest#builder()}
*
*
* @param updateMemberRequest
* A {@link Consumer} that will call methods on {@link UpdateMemberInput.Builder} to create a request.
* @return A Java Future containing the result of the UpdateMember operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InvalidRequestException The action or operation requested is invalid. Verify that the action is typed
* correctly.
* - AccessDeniedException You don't have sufficient access to perform this action.
* - ResourceNotFoundException A requested resource doesn't exist. It may have been deleted or referenced
* incorrectly.
* - ThrottlingException The request or operation couldn't be performed because a service is throttling
* requests. The most common source of throttling errors is creating resources that exceed your service
* limit for this resource type. Request a limit increase or delete unused resources if possible.
* - InternalServiceErrorException The request processing has failed because of an unknown error,
* exception or failure.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - ManagedBlockchainException Base class for all service exceptions. Unknown exceptions will be thrown
* as an instance of this type.
*
* @sample ManagedBlockchainAsyncClient.UpdateMember
* @see AWS API Documentation
*/
default CompletableFuture updateMember(Consumer updateMemberRequest) {
return updateMember(UpdateMemberRequest.builder().applyMutation(updateMemberRequest).build());
}
/**
*
* Updates a node configuration with new parameters.
*
*
* Applies only to Hyperledger Fabric.
*
*
* @param updateNodeRequest
* @return A Java Future containing the result of the UpdateNode operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InvalidRequestException The action or operation requested is invalid. Verify that the action is typed
* correctly.
* - AccessDeniedException You don't have sufficient access to perform this action.
* - ResourceNotFoundException A requested resource doesn't exist. It may have been deleted or referenced
* incorrectly.
* - ThrottlingException The request or operation couldn't be performed because a service is throttling
* requests. The most common source of throttling errors is creating resources that exceed your service
* limit for this resource type. Request a limit increase or delete unused resources if possible.
* - InternalServiceErrorException The request processing has failed because of an unknown error,
* exception or failure.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - ManagedBlockchainException Base class for all service exceptions. Unknown exceptions will be thrown
* as an instance of this type.
*
* @sample ManagedBlockchainAsyncClient.UpdateNode
* @see AWS
* API Documentation
*/
default CompletableFuture updateNode(UpdateNodeRequest updateNodeRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Updates a node configuration with new parameters.
*
*
* Applies only to Hyperledger Fabric.
*
*
*
* This is a convenience which creates an instance of the {@link UpdateNodeRequest.Builder} avoiding the need to
* create one manually via {@link UpdateNodeRequest#builder()}
*
*
* @param updateNodeRequest
* A {@link Consumer} that will call methods on {@link UpdateNodeInput.Builder} to create a request.
* @return A Java Future containing the result of the UpdateNode operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InvalidRequestException The action or operation requested is invalid. Verify that the action is typed
* correctly.
* - AccessDeniedException You don't have sufficient access to perform this action.
* - ResourceNotFoundException A requested resource doesn't exist. It may have been deleted or referenced
* incorrectly.
* - ThrottlingException The request or operation couldn't be performed because a service is throttling
* requests. The most common source of throttling errors is creating resources that exceed your service
* limit for this resource type. Request a limit increase or delete unused resources if possible.
* - InternalServiceErrorException The request processing has failed because of an unknown error,
* exception or failure.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - ManagedBlockchainException Base class for all service exceptions. Unknown exceptions will be thrown
* as an instance of this type.
*
* @sample ManagedBlockchainAsyncClient.UpdateNode
* @see AWS
* API Documentation
*/
default CompletableFuture updateNode(Consumer updateNodeRequest) {
return updateNode(UpdateNodeRequest.builder().applyMutation(updateNodeRequest).build());
}
/**
*
* Casts a vote for a specified ProposalId on behalf of a member. The member to vote as, specified by
* VoterMemberId, must be in the same Amazon Web Services account as the principal that calls the
* action.
*
*
* Applies only to Hyperledger Fabric.
*
*
* @param voteOnProposalRequest
* @return A Java Future containing the result of the VoteOnProposal operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InvalidRequestException The action or operation requested is invalid. Verify that the action is typed
* correctly.
* - IllegalActionException
* - AccessDeniedException You don't have sufficient access to perform this action.
* - ResourceNotFoundException A requested resource doesn't exist. It may have been deleted or referenced
* incorrectly.
* - ThrottlingException The request or operation couldn't be performed because a service is throttling
* requests. The most common source of throttling errors is creating resources that exceed your service
* limit for this resource type. Request a limit increase or delete unused resources if possible.
* - InternalServiceErrorException The request processing has failed because of an unknown error,
* exception or failure.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - ManagedBlockchainException Base class for all service exceptions. Unknown exceptions will be thrown
* as an instance of this type.
*
* @sample ManagedBlockchainAsyncClient.VoteOnProposal
* @see AWS API Documentation
*/
default CompletableFuture voteOnProposal(VoteOnProposalRequest voteOnProposalRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Casts a vote for a specified ProposalId on behalf of a member. The member to vote as, specified by
* VoterMemberId, must be in the same Amazon Web Services account as the principal that calls the
* action.
*
*
* Applies only to Hyperledger Fabric.
*
*
*
* This is a convenience which creates an instance of the {@link VoteOnProposalRequest.Builder} avoiding the need to
* create one manually via {@link VoteOnProposalRequest#builder()}
*
*
* @param voteOnProposalRequest
* A {@link Consumer} that will call methods on {@link VoteOnProposalInput.Builder} to create a request.
* @return A Java Future containing the result of the VoteOnProposal operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InvalidRequestException The action or operation requested is invalid. Verify that the action is typed
* correctly.
* - IllegalActionException
* - AccessDeniedException You don't have sufficient access to perform this action.
* - ResourceNotFoundException A requested resource doesn't exist. It may have been deleted or referenced
* incorrectly.
* - ThrottlingException The request or operation couldn't be performed because a service is throttling
* requests. The most common source of throttling errors is creating resources that exceed your service
* limit for this resource type. Request a limit increase or delete unused resources if possible.
* - InternalServiceErrorException The request processing has failed because of an unknown error,
* exception or failure.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - ManagedBlockchainException Base class for all service exceptions. Unknown exceptions will be thrown
* as an instance of this type.
*
* @sample ManagedBlockchainAsyncClient.VoteOnProposal
* @see AWS API Documentation
*/
default CompletableFuture voteOnProposal(Consumer voteOnProposalRequest) {
return voteOnProposal(VoteOnProposalRequest.builder().applyMutation(voteOnProposalRequest).build());
}
}