Documentation

Overview

    Package managedblockchain provides the API client, operations, and parameter types for Amazon Managed Blockchain.

    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 do not 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.

    Index

    Constants

    View Source
    const ServiceAPIVersion = "2018-09-24"
    View Source
    const ServiceID = "ManagedBlockchain"

    Variables

    This section is empty.

    Functions

    func NewDefaultEndpointResolver

    func NewDefaultEndpointResolver() *internalendpoints.Resolver

      NewDefaultEndpointResolver constructs a new service endpoint resolver

      func WithAPIOptions

      func WithAPIOptions(optFns ...func(*middleware.Stack) error) func(*Options)

        WithAPIOptions returns a functional option for setting the Client's APIOptions option.

        func WithEndpointResolver

        func WithEndpointResolver(v EndpointResolver) func(*Options)

          WithEndpointResolver returns a functional option for setting the Client's EndpointResolver option.

          Types

          type Client

          type Client struct {
          	// contains filtered or unexported fields
          }

            Client provides the API client to make operations call for Amazon Managed Blockchain.

            func New

            func New(options Options, optFns ...func(*Options)) *Client

              New returns an initialized Client based on the functional options. Provide additional functional options to further configure the behavior of the client, such as changing the client's endpoint or adding custom middleware behavior.

              func NewFromConfig

              func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client

                NewFromConfig returns a new client from the provided config.

                func (*Client) CreateMember

                func (c *Client) CreateMember(ctx context.Context, params *CreateMemberInput, optFns ...func(*Options)) (*CreateMemberOutput, error)

                  Creates a member within a Managed Blockchain network. Applies only to Hyperledger Fabric.

                  func (*Client) CreateNetwork

                  func (c *Client) CreateNetwork(ctx context.Context, params *CreateNetworkInput, optFns ...func(*Options)) (*CreateNetworkOutput, error)

                    Creates a new blockchain network using Amazon Managed Blockchain. Applies only to Hyperledger Fabric.

                    func (*Client) CreateNode

                    func (c *Client) CreateNode(ctx context.Context, params *CreateNodeInput, optFns ...func(*Options)) (*CreateNodeOutput, error)

                      Creates a node on the specified blockchain network. Applies to Hyperledger Fabric and Ethereum.

                      func (*Client) CreateProposal

                      func (c *Client) CreateProposal(ctx context.Context, params *CreateProposalInput, optFns ...func(*Options)) (*CreateProposalOutput, error)

                        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.

                        func (*Client) DeleteMember

                        func (c *Client) DeleteMember(ctx context.Context, params *DeleteMemberInput, optFns ...func(*Options)) (*DeleteMemberOutput, error)

                          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 AWS 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 AWS account, the network is deleted also. Applies only to Hyperledger Fabric.

                          func (*Client) DeleteNode

                          func (c *Client) DeleteNode(ctx context.Context, params *DeleteNodeInput, optFns ...func(*Options)) (*DeleteNodeOutput, error)

                            Deletes a node that your AWS account owns. All data on the node is lost and cannot be recovered. Applies to Hyperledger Fabric and Ethereum.

                            func (*Client) GetMember

                            func (c *Client) GetMember(ctx context.Context, params *GetMemberInput, optFns ...func(*Options)) (*GetMemberOutput, error)

                              Returns detailed information about a member. Applies only to Hyperledger Fabric.

                              func (*Client) GetNetwork

                              func (c *Client) GetNetwork(ctx context.Context, params *GetNetworkInput, optFns ...func(*Options)) (*GetNetworkOutput, error)

                                Returns detailed information about a network. Applies to Hyperledger Fabric and Ethereum.

                                func (*Client) GetNode

                                func (c *Client) GetNode(ctx context.Context, params *GetNodeInput, optFns ...func(*Options)) (*GetNodeOutput, error)

                                  Returns detailed information about a node. Applies to Hyperledger Fabric and Ethereum.

                                  func (*Client) GetProposal

                                  func (c *Client) GetProposal(ctx context.Context, params *GetProposalInput, optFns ...func(*Options)) (*GetProposalOutput, error)

                                    Returns detailed information about a proposal. Applies only to Hyperledger Fabric.

                                    func (*Client) ListInvitations

                                    func (c *Client) ListInvitations(ctx context.Context, params *ListInvitationsInput, optFns ...func(*Options)) (*ListInvitationsOutput, error)

                                      Returns a list of all invitations for the current AWS account. Applies only to Hyperledger Fabric.

                                      func (*Client) ListMembers

                                      func (c *Client) ListMembers(ctx context.Context, params *ListMembersInput, optFns ...func(*Options)) (*ListMembersOutput, error)

                                        Returns a list of the members in a network and properties of their configurations. Applies only to Hyperledger Fabric.

                                        func (*Client) ListNetworks

                                        func (c *Client) ListNetworks(ctx context.Context, params *ListNetworksInput, optFns ...func(*Options)) (*ListNetworksOutput, error)

                                          Returns information about the networks in which the current AWS account participates. Applies to Hyperledger Fabric and Ethereum.

                                          func (*Client) ListNodes

                                          func (c *Client) ListNodes(ctx context.Context, params *ListNodesInput, optFns ...func(*Options)) (*ListNodesOutput, error)

                                            Returns information about the nodes within a network. Applies to Hyperledger Fabric and Ethereum.

                                            func (*Client) ListProposalVotes

                                            func (c *Client) ListProposalVotes(ctx context.Context, params *ListProposalVotesInput, optFns ...func(*Options)) (*ListProposalVotesOutput, error)

                                              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.

                                              func (*Client) ListProposals

                                              func (c *Client) ListProposals(ctx context.Context, params *ListProposalsInput, optFns ...func(*Options)) (*ListProposalsOutput, error)

                                                Returns a list of proposals for the network. Applies only to Hyperledger Fabric.

                                                func (*Client) RejectInvitation

                                                func (c *Client) RejectInvitation(ctx context.Context, params *RejectInvitationInput, optFns ...func(*Options)) (*RejectInvitationOutput, error)

                                                  Rejects an invitation to join a network. This action can be called by a principal in an AWS account that has received an invitation to create a member and join a network. Applies only to Hyperledger Fabric.

                                                  func (*Client) UpdateMember

                                                  func (c *Client) UpdateMember(ctx context.Context, params *UpdateMemberInput, optFns ...func(*Options)) (*UpdateMemberOutput, error)

                                                    Updates a member configuration with new parameters. Applies only to Hyperledger Fabric.

                                                    func (*Client) UpdateNode

                                                    func (c *Client) UpdateNode(ctx context.Context, params *UpdateNodeInput, optFns ...func(*Options)) (*UpdateNodeOutput, error)

                                                      Updates a node configuration with new parameters. Applies only to Hyperledger Fabric.

                                                      func (*Client) VoteOnProposal

                                                      func (c *Client) VoteOnProposal(ctx context.Context, params *VoteOnProposalInput, optFns ...func(*Options)) (*VoteOnProposalOutput, error)

                                                        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 AWS account as the principal that calls the action. Applies only to Hyperledger Fabric.

                                                        type CreateMemberInput

                                                        type CreateMemberInput struct {
                                                        
                                                        	// A unique, case-sensitive identifier that you provide to ensure the idempotency
                                                        	// of the operation. An idempotent operation completes no more than one time. This
                                                        	// identifier is required only if you make a service request directly using an HTTP
                                                        	// client. It is generated automatically if you use an AWS SDK or the AWS CLI.
                                                        	//
                                                        	// This member is required.
                                                        	ClientRequestToken *string
                                                        
                                                        	// The unique identifier of the invitation that is sent to the member to join the
                                                        	// network.
                                                        	//
                                                        	// This member is required.
                                                        	InvitationId *string
                                                        
                                                        	// Member configuration parameters.
                                                        	//
                                                        	// This member is required.
                                                        	MemberConfiguration *types.MemberConfiguration
                                                        
                                                        	// The unique identifier of the network in which the member is created.
                                                        	//
                                                        	// This member is required.
                                                        	NetworkId *string
                                                        }

                                                        type CreateMemberOutput

                                                        type CreateMemberOutput struct {
                                                        
                                                        	// The unique identifier of the member.
                                                        	MemberId *string
                                                        
                                                        	// Metadata pertaining to the operation's result.
                                                        	ResultMetadata middleware.Metadata
                                                        }

                                                        type CreateNetworkInput

                                                        type CreateNetworkInput struct {
                                                        
                                                        	// A unique, case-sensitive identifier that you provide to ensure the idempotency
                                                        	// of the operation. An idempotent operation completes no more than one time. This
                                                        	// identifier is required only if you make a service request directly using an HTTP
                                                        	// client. It is generated automatically if you use an AWS SDK or the AWS CLI.
                                                        	//
                                                        	// This member is required.
                                                        	ClientRequestToken *string
                                                        
                                                        	// The blockchain framework that the network uses.
                                                        	//
                                                        	// This member is required.
                                                        	Framework types.Framework
                                                        
                                                        	// The version of the blockchain framework that the network uses.
                                                        	//
                                                        	// This member is required.
                                                        	FrameworkVersion *string
                                                        
                                                        	// Configuration properties for the first member within the network.
                                                        	//
                                                        	// This member is required.
                                                        	MemberConfiguration *types.MemberConfiguration
                                                        
                                                        	// The name of the network.
                                                        	//
                                                        	// This member is required.
                                                        	Name *string
                                                        
                                                        	// The voting rules used by the network to determine if a proposal is approved.
                                                        	//
                                                        	// This member is required.
                                                        	VotingPolicy *types.VotingPolicy
                                                        
                                                        	// An optional description for the network.
                                                        	Description *string
                                                        
                                                        	// Configuration properties of the blockchain framework relevant to the network
                                                        	// configuration.
                                                        	FrameworkConfiguration *types.NetworkFrameworkConfiguration
                                                        }

                                                        type CreateNetworkOutput

                                                        type CreateNetworkOutput struct {
                                                        
                                                        	// The unique identifier for the first member within the network.
                                                        	MemberId *string
                                                        
                                                        	// The unique identifier for the network.
                                                        	NetworkId *string
                                                        
                                                        	// Metadata pertaining to the operation's result.
                                                        	ResultMetadata middleware.Metadata
                                                        }

                                                        type CreateNodeInput

                                                        type CreateNodeInput struct {
                                                        
                                                        	// A unique, case-sensitive identifier that you provide to ensure the idempotency
                                                        	// of the operation. An idempotent operation completes no more than one time. This
                                                        	// identifier is required only if you make a service request directly using an HTTP
                                                        	// client. It is generated automatically if you use an AWS SDK or the AWS CLI.
                                                        	//
                                                        	// This member is required.
                                                        	ClientRequestToken *string
                                                        
                                                        	// The unique identifier of the network for the node. Ethereum public networks have
                                                        	// the following NetworkIds:
                                                        	//
                                                        	// * n-ethereum-mainnet
                                                        	//
                                                        	// * n-ethereum-rinkeby
                                                        	//
                                                        	// *
                                                        	// n-ethereum-ropsten
                                                        	//
                                                        	// This member is required.
                                                        	NetworkId *string
                                                        
                                                        	// The properties of a node configuration.
                                                        	//
                                                        	// This member is required.
                                                        	NodeConfiguration *types.NodeConfiguration
                                                        
                                                        	// The unique identifier of the member that owns this node. Applies only to
                                                        	// Hyperledger Fabric.
                                                        	MemberId *string
                                                        }

                                                        type CreateNodeOutput

                                                        type CreateNodeOutput struct {
                                                        
                                                        	// The unique identifier of the node.
                                                        	NodeId *string
                                                        
                                                        	// Metadata pertaining to the operation's result.
                                                        	ResultMetadata middleware.Metadata
                                                        }

                                                        type CreateProposalInput

                                                        type CreateProposalInput struct {
                                                        
                                                        	// The type of actions proposed, such as inviting a member or removing a member.
                                                        	// The types of Actions in a proposal are mutually exclusive. For example, a
                                                        	// proposal with Invitations actions cannot also contain Removals actions.
                                                        	//
                                                        	// This member is required.
                                                        	Actions *types.ProposalActions
                                                        
                                                        	// A unique, case-sensitive identifier that you provide to ensure the idempotency
                                                        	// of the operation. An idempotent operation completes no more than one time. This
                                                        	// identifier is required only if you make a service request directly using an HTTP
                                                        	// client. It is generated automatically if you use an AWS SDK or the AWS CLI.
                                                        	//
                                                        	// This member is required.
                                                        	ClientRequestToken *string
                                                        
                                                        	// The unique identifier of the member that is creating the proposal. This
                                                        	// identifier is especially useful for identifying the member making the proposal
                                                        	// when multiple members exist in a single AWS account.
                                                        	//
                                                        	// This member is required.
                                                        	MemberId *string
                                                        
                                                        	// The unique identifier of the network for which the proposal is made.
                                                        	//
                                                        	// This member is required.
                                                        	NetworkId *string
                                                        
                                                        	// A description for the proposal that is visible to voting members, for example,
                                                        	// "Proposal to add Example Corp. as member."
                                                        	Description *string
                                                        }

                                                        type CreateProposalOutput

                                                        type CreateProposalOutput struct {
                                                        
                                                        	// The unique identifier of the proposal.
                                                        	ProposalId *string
                                                        
                                                        	// Metadata pertaining to the operation's result.
                                                        	ResultMetadata middleware.Metadata
                                                        }

                                                        type DeleteMemberInput

                                                        type DeleteMemberInput struct {
                                                        
                                                        	// The unique identifier of the member to remove.
                                                        	//
                                                        	// This member is required.
                                                        	MemberId *string
                                                        
                                                        	// The unique identifier of the network from which the member is removed.
                                                        	//
                                                        	// This member is required.
                                                        	NetworkId *string
                                                        }

                                                        type DeleteMemberOutput

                                                        type DeleteMemberOutput struct {
                                                        	// Metadata pertaining to the operation's result.
                                                        	ResultMetadata middleware.Metadata
                                                        }

                                                        type DeleteNodeInput

                                                        type DeleteNodeInput struct {
                                                        
                                                        	// The unique identifier of the network that the node is on. Ethereum public
                                                        	// networks have the following NetworkIds:
                                                        	//
                                                        	// * n-ethereum-mainnet
                                                        	//
                                                        	// *
                                                        	// n-ethereum-rinkeby
                                                        	//
                                                        	// * n-ethereum-ropsten
                                                        	//
                                                        	// This member is required.
                                                        	NetworkId *string
                                                        
                                                        	// The unique identifier of the node.
                                                        	//
                                                        	// This member is required.
                                                        	NodeId *string
                                                        
                                                        	// The unique identifier of the member that owns this node. Applies only to
                                                        	// Hyperledger Fabric and is required for Hyperledger Fabric.
                                                        	MemberId *string
                                                        }

                                                        type DeleteNodeOutput

                                                        type DeleteNodeOutput struct {
                                                        	// Metadata pertaining to the operation's result.
                                                        	ResultMetadata middleware.Metadata
                                                        }

                                                        type EndpointResolver

                                                        type EndpointResolver interface {
                                                        	ResolveEndpoint(region string, options EndpointResolverOptions) (aws.Endpoint, error)
                                                        }

                                                          EndpointResolver interface for resolving service endpoints.

                                                          func EndpointResolverFromURL

                                                          func EndpointResolverFromURL(url string, optFns ...func(*aws.Endpoint)) EndpointResolver

                                                            EndpointResolverFromURL returns an EndpointResolver configured using the provided endpoint url. By default, the resolved endpoint resolver uses the client region as signing region, and the endpoint source is set to EndpointSourceCustom.You can provide functional options to configure endpoint values for the resolved endpoint.

                                                            type EndpointResolverFunc

                                                            type EndpointResolverFunc func(region string, options EndpointResolverOptions) (aws.Endpoint, error)

                                                              EndpointResolverFunc is a helper utility that wraps a function so it satisfies the EndpointResolver interface. This is useful when you want to add additional endpoint resolving logic, or stub out specific endpoints with custom values.

                                                              func (EndpointResolverFunc) ResolveEndpoint

                                                              func (fn EndpointResolverFunc) ResolveEndpoint(region string, options EndpointResolverOptions) (endpoint aws.Endpoint, err error)

                                                              type EndpointResolverOptions

                                                              type EndpointResolverOptions = internalendpoints.Options

                                                                EndpointResolverOptions is the service endpoint resolver options

                                                                type GetMemberInput

                                                                type GetMemberInput struct {
                                                                
                                                                	// The unique identifier of the member.
                                                                	//
                                                                	// This member is required.
                                                                	MemberId *string
                                                                
                                                                	// The unique identifier of the network to which the member belongs.
                                                                	//
                                                                	// This member is required.
                                                                	NetworkId *string
                                                                }

                                                                type GetMemberOutput

                                                                type GetMemberOutput struct {
                                                                
                                                                	// The properties of a member.
                                                                	Member *types.Member
                                                                
                                                                	// Metadata pertaining to the operation's result.
                                                                	ResultMetadata middleware.Metadata
                                                                }

                                                                type GetNetworkInput

                                                                type GetNetworkInput struct {
                                                                
                                                                	// The unique identifier of the network to get information about.
                                                                	//
                                                                	// This member is required.
                                                                	NetworkId *string
                                                                }

                                                                type GetNetworkOutput

                                                                type GetNetworkOutput struct {
                                                                
                                                                	// An object containing network configuration parameters.
                                                                	Network *types.Network
                                                                
                                                                	// Metadata pertaining to the operation's result.
                                                                	ResultMetadata middleware.Metadata
                                                                }

                                                                type GetNodeInput

                                                                type GetNodeInput struct {
                                                                
                                                                	// The unique identifier of the network that the node is on.
                                                                	//
                                                                	// This member is required.
                                                                	NetworkId *string
                                                                
                                                                	// The unique identifier of the node.
                                                                	//
                                                                	// This member is required.
                                                                	NodeId *string
                                                                
                                                                	// The unique identifier of the member that owns the node. Applies only to
                                                                	// Hyperledger Fabric and is required for Hyperledger Fabric.
                                                                	MemberId *string
                                                                }

                                                                type GetNodeOutput

                                                                type GetNodeOutput struct {
                                                                
                                                                	// Properties of the node configuration.
                                                                	Node *types.Node
                                                                
                                                                	// Metadata pertaining to the operation's result.
                                                                	ResultMetadata middleware.Metadata
                                                                }

                                                                type GetProposalInput

                                                                type GetProposalInput struct {
                                                                
                                                                	// The unique identifier of the network for which the proposal is made.
                                                                	//
                                                                	// This member is required.
                                                                	NetworkId *string
                                                                
                                                                	// The unique identifier of the proposal.
                                                                	//
                                                                	// This member is required.
                                                                	ProposalId *string
                                                                }

                                                                type GetProposalOutput

                                                                type GetProposalOutput struct {
                                                                
                                                                	// Information about a proposal.
                                                                	Proposal *types.Proposal
                                                                
                                                                	// Metadata pertaining to the operation's result.
                                                                	ResultMetadata middleware.Metadata
                                                                }

                                                                type HTTPClient

                                                                type HTTPClient interface {
                                                                	Do(*http.Request) (*http.Response, error)
                                                                }

                                                                type HTTPSignerV4

                                                                type HTTPSignerV4 interface {
                                                                	SignHTTP(ctx context.Context, credentials aws.Credentials, r *http.Request, payloadHash string, service string, region string, signingTime time.Time, optFns ...func(*v4.SignerOptions)) error
                                                                }

                                                                type IdempotencyTokenProvider

                                                                type IdempotencyTokenProvider interface {
                                                                	GetIdempotencyToken() (string, error)
                                                                }

                                                                  IdempotencyTokenProvider interface for providing idempotency token

                                                                  type ListInvitationsAPIClient

                                                                  type ListInvitationsAPIClient interface {
                                                                  	ListInvitations(context.Context, *ListInvitationsInput, ...func(*Options)) (*ListInvitationsOutput, error)
                                                                  }

                                                                    ListInvitationsAPIClient is a client that implements the ListInvitations operation.

                                                                    type ListInvitationsInput

                                                                    type ListInvitationsInput struct {
                                                                    
                                                                    	// The maximum number of invitations to return.
                                                                    	MaxResults *int32
                                                                    
                                                                    	// The pagination token that indicates the next set of results to retrieve.
                                                                    	NextToken *string
                                                                    }

                                                                    type ListInvitationsOutput

                                                                    type ListInvitationsOutput struct {
                                                                    
                                                                    	// The invitations for the network.
                                                                    	Invitations []types.Invitation
                                                                    
                                                                    	// The pagination token that indicates the next set of results to retrieve.
                                                                    	NextToken *string
                                                                    
                                                                    	// Metadata pertaining to the operation's result.
                                                                    	ResultMetadata middleware.Metadata
                                                                    }

                                                                    type ListInvitationsPaginator

                                                                    type ListInvitationsPaginator struct {
                                                                    	// contains filtered or unexported fields
                                                                    }

                                                                      ListInvitationsPaginator is a paginator for ListInvitations

                                                                      func NewListInvitationsPaginator

                                                                      func NewListInvitationsPaginator(client ListInvitationsAPIClient, params *ListInvitationsInput, optFns ...func(*ListInvitationsPaginatorOptions)) *ListInvitationsPaginator

                                                                        NewListInvitationsPaginator returns a new ListInvitationsPaginator

                                                                        func (*ListInvitationsPaginator) HasMorePages

                                                                        func (p *ListInvitationsPaginator) HasMorePages() bool

                                                                          HasMorePages returns a boolean indicating whether more pages are available

                                                                          func (*ListInvitationsPaginator) NextPage

                                                                          func (p *ListInvitationsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListInvitationsOutput, error)

                                                                            NextPage retrieves the next ListInvitations page.

                                                                            type ListInvitationsPaginatorOptions

                                                                            type ListInvitationsPaginatorOptions struct {
                                                                            	// The maximum number of invitations to return.
                                                                            	Limit int32
                                                                            
                                                                            	// Set to true if pagination should stop if the service returns a pagination token
                                                                            	// that matches the most recent token provided to the service.
                                                                            	StopOnDuplicateToken bool
                                                                            }

                                                                              ListInvitationsPaginatorOptions is the paginator options for ListInvitations

                                                                              type ListMembersAPIClient

                                                                              type ListMembersAPIClient interface {
                                                                              	ListMembers(context.Context, *ListMembersInput, ...func(*Options)) (*ListMembersOutput, error)
                                                                              }

                                                                                ListMembersAPIClient is a client that implements the ListMembers operation.

                                                                                type ListMembersInput

                                                                                type ListMembersInput struct {
                                                                                
                                                                                	// The unique identifier of the network for which to list members.
                                                                                	//
                                                                                	// This member is required.
                                                                                	NetworkId *string
                                                                                
                                                                                	// An optional Boolean value. If provided, the request is limited either to members
                                                                                	// that the current AWS account owns (true) or that other AWS accounts own (false).
                                                                                	// If omitted, all members are listed.
                                                                                	IsOwned *bool
                                                                                
                                                                                	// The maximum number of members to return in the request.
                                                                                	MaxResults *int32
                                                                                
                                                                                	// The optional name of the member to list.
                                                                                	Name *string
                                                                                
                                                                                	// The pagination token that indicates the next set of results to retrieve.
                                                                                	NextToken *string
                                                                                
                                                                                	// An optional status specifier. If provided, only members currently in this status
                                                                                	// are listed.
                                                                                	Status types.MemberStatus
                                                                                }

                                                                                type ListMembersOutput

                                                                                type ListMembersOutput struct {
                                                                                
                                                                                	// An array of MemberSummary objects. Each object contains details about a network
                                                                                	// member.
                                                                                	Members []types.MemberSummary
                                                                                
                                                                                	// The pagination token that indicates the next set of results to retrieve.
                                                                                	NextToken *string
                                                                                
                                                                                	// Metadata pertaining to the operation's result.
                                                                                	ResultMetadata middleware.Metadata
                                                                                }

                                                                                type ListMembersPaginator

                                                                                type ListMembersPaginator struct {
                                                                                	// contains filtered or unexported fields
                                                                                }

                                                                                  ListMembersPaginator is a paginator for ListMembers

                                                                                  func NewListMembersPaginator

                                                                                  func NewListMembersPaginator(client ListMembersAPIClient, params *ListMembersInput, optFns ...func(*ListMembersPaginatorOptions)) *ListMembersPaginator

                                                                                    NewListMembersPaginator returns a new ListMembersPaginator

                                                                                    func (*ListMembersPaginator) HasMorePages

                                                                                    func (p *ListMembersPaginator) HasMorePages() bool

                                                                                      HasMorePages returns a boolean indicating whether more pages are available

                                                                                      func (*ListMembersPaginator) NextPage

                                                                                      func (p *ListMembersPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListMembersOutput, error)

                                                                                        NextPage retrieves the next ListMembers page.

                                                                                        type ListMembersPaginatorOptions

                                                                                        type ListMembersPaginatorOptions struct {
                                                                                        	// The maximum number of members to return in the request.
                                                                                        	Limit int32
                                                                                        
                                                                                        	// Set to true if pagination should stop if the service returns a pagination token
                                                                                        	// that matches the most recent token provided to the service.
                                                                                        	StopOnDuplicateToken bool
                                                                                        }

                                                                                          ListMembersPaginatorOptions is the paginator options for ListMembers

                                                                                          type ListNetworksAPIClient

                                                                                          type ListNetworksAPIClient interface {
                                                                                          	ListNetworks(context.Context, *ListNetworksInput, ...func(*Options)) (*ListNetworksOutput, error)
                                                                                          }

                                                                                            ListNetworksAPIClient is a client that implements the ListNetworks operation.

                                                                                            type ListNetworksInput

                                                                                            type ListNetworksInput struct {
                                                                                            
                                                                                            	// An optional framework specifier. If provided, only networks of this framework
                                                                                            	// type are listed.
                                                                                            	Framework types.Framework
                                                                                            
                                                                                            	// The maximum number of networks to list.
                                                                                            	MaxResults *int32
                                                                                            
                                                                                            	// The name of the network.
                                                                                            	Name *string
                                                                                            
                                                                                            	// The pagination token that indicates the next set of results to retrieve.
                                                                                            	NextToken *string
                                                                                            
                                                                                            	// An optional status specifier. If provided, only networks currently in this
                                                                                            	// status are listed. Applies only to Hyperledger Fabric.
                                                                                            	Status types.NetworkStatus
                                                                                            }

                                                                                            type ListNetworksOutput

                                                                                            type ListNetworksOutput struct {
                                                                                            
                                                                                            	// An array of NetworkSummary objects that contain configuration properties for
                                                                                            	// each network.
                                                                                            	Networks []types.NetworkSummary
                                                                                            
                                                                                            	// The pagination token that indicates the next set of results to retrieve.
                                                                                            	NextToken *string
                                                                                            
                                                                                            	// Metadata pertaining to the operation's result.
                                                                                            	ResultMetadata middleware.Metadata
                                                                                            }

                                                                                            type ListNetworksPaginator

                                                                                            type ListNetworksPaginator struct {
                                                                                            	// contains filtered or unexported fields
                                                                                            }

                                                                                              ListNetworksPaginator is a paginator for ListNetworks

                                                                                              func NewListNetworksPaginator

                                                                                              func NewListNetworksPaginator(client ListNetworksAPIClient, params *ListNetworksInput, optFns ...func(*ListNetworksPaginatorOptions)) *ListNetworksPaginator

                                                                                                NewListNetworksPaginator returns a new ListNetworksPaginator

                                                                                                func (*ListNetworksPaginator) HasMorePages

                                                                                                func (p *ListNetworksPaginator) HasMorePages() bool

                                                                                                  HasMorePages returns a boolean indicating whether more pages are available

                                                                                                  func (*ListNetworksPaginator) NextPage

                                                                                                  func (p *ListNetworksPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListNetworksOutput, error)

                                                                                                    NextPage retrieves the next ListNetworks page.

                                                                                                    type ListNetworksPaginatorOptions

                                                                                                    type ListNetworksPaginatorOptions struct {
                                                                                                    	// The maximum number of networks to list.
                                                                                                    	Limit int32
                                                                                                    
                                                                                                    	// Set to true if pagination should stop if the service returns a pagination token
                                                                                                    	// that matches the most recent token provided to the service.
                                                                                                    	StopOnDuplicateToken bool
                                                                                                    }

                                                                                                      ListNetworksPaginatorOptions is the paginator options for ListNetworks

                                                                                                      type ListNodesAPIClient

                                                                                                      type ListNodesAPIClient interface {
                                                                                                      	ListNodes(context.Context, *ListNodesInput, ...func(*Options)) (*ListNodesOutput, error)
                                                                                                      }

                                                                                                        ListNodesAPIClient is a client that implements the ListNodes operation.

                                                                                                        type ListNodesInput

                                                                                                        type ListNodesInput struct {
                                                                                                        
                                                                                                        	// The unique identifier of the network for which to list nodes.
                                                                                                        	//
                                                                                                        	// This member is required.
                                                                                                        	NetworkId *string
                                                                                                        
                                                                                                        	// The maximum number of nodes to list.
                                                                                                        	MaxResults *int32
                                                                                                        
                                                                                                        	// The unique identifier of the member who owns the nodes to list. Applies only to
                                                                                                        	// Hyperledger Fabric and is required for Hyperledger Fabric.
                                                                                                        	MemberId *string
                                                                                                        
                                                                                                        	// The pagination token that indicates the next set of results to retrieve.
                                                                                                        	NextToken *string
                                                                                                        
                                                                                                        	// An optional status specifier. If provided, only nodes currently in this status
                                                                                                        	// are listed.
                                                                                                        	Status types.NodeStatus
                                                                                                        }

                                                                                                        type ListNodesOutput

                                                                                                        type ListNodesOutput struct {
                                                                                                        
                                                                                                        	// The pagination token that indicates the next set of results to retrieve.
                                                                                                        	NextToken *string
                                                                                                        
                                                                                                        	// An array of NodeSummary objects that contain configuration properties for each
                                                                                                        	// node.
                                                                                                        	Nodes []types.NodeSummary
                                                                                                        
                                                                                                        	// Metadata pertaining to the operation's result.
                                                                                                        	ResultMetadata middleware.Metadata
                                                                                                        }

                                                                                                        type ListNodesPaginator

                                                                                                        type ListNodesPaginator struct {
                                                                                                        	// contains filtered or unexported fields
                                                                                                        }

                                                                                                          ListNodesPaginator is a paginator for ListNodes

                                                                                                          func NewListNodesPaginator

                                                                                                          func NewListNodesPaginator(client ListNodesAPIClient, params *ListNodesInput, optFns ...func(*ListNodesPaginatorOptions)) *ListNodesPaginator

                                                                                                            NewListNodesPaginator returns a new ListNodesPaginator

                                                                                                            func (*ListNodesPaginator) HasMorePages

                                                                                                            func (p *ListNodesPaginator) HasMorePages() bool

                                                                                                              HasMorePages returns a boolean indicating whether more pages are available

                                                                                                              func (*ListNodesPaginator) NextPage

                                                                                                              func (p *ListNodesPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListNodesOutput, error)

                                                                                                                NextPage retrieves the next ListNodes page.

                                                                                                                type ListNodesPaginatorOptions

                                                                                                                type ListNodesPaginatorOptions struct {
                                                                                                                	// The maximum number of nodes to list.
                                                                                                                	Limit int32
                                                                                                                
                                                                                                                	// Set to true if pagination should stop if the service returns a pagination token
                                                                                                                	// that matches the most recent token provided to the service.
                                                                                                                	StopOnDuplicateToken bool
                                                                                                                }

                                                                                                                  ListNodesPaginatorOptions is the paginator options for ListNodes

                                                                                                                  type ListProposalVotesAPIClient

                                                                                                                  type ListProposalVotesAPIClient interface {
                                                                                                                  	ListProposalVotes(context.Context, *ListProposalVotesInput, ...func(*Options)) (*ListProposalVotesOutput, error)
                                                                                                                  }

                                                                                                                    ListProposalVotesAPIClient is a client that implements the ListProposalVotes operation.

                                                                                                                    type ListProposalVotesInput

                                                                                                                    type ListProposalVotesInput struct {
                                                                                                                    
                                                                                                                    	// The unique identifier of the network.
                                                                                                                    	//
                                                                                                                    	// This member is required.
                                                                                                                    	NetworkId *string
                                                                                                                    
                                                                                                                    	// The unique identifier of the proposal.
                                                                                                                    	//
                                                                                                                    	// This member is required.
                                                                                                                    	ProposalId *string
                                                                                                                    
                                                                                                                    	// The maximum number of votes to return.
                                                                                                                    	MaxResults *int32
                                                                                                                    
                                                                                                                    	// The pagination token that indicates the next set of results to retrieve.
                                                                                                                    	NextToken *string
                                                                                                                    }

                                                                                                                    type ListProposalVotesOutput

                                                                                                                    type ListProposalVotesOutput struct {
                                                                                                                    
                                                                                                                    	// The pagination token that indicates the next set of results to retrieve.
                                                                                                                    	NextToken *string
                                                                                                                    
                                                                                                                    	// The list of votes.
                                                                                                                    	ProposalVotes []types.VoteSummary
                                                                                                                    
                                                                                                                    	// Metadata pertaining to the operation's result.
                                                                                                                    	ResultMetadata middleware.Metadata
                                                                                                                    }

                                                                                                                    type ListProposalVotesPaginator

                                                                                                                    type ListProposalVotesPaginator struct {
                                                                                                                    	// contains filtered or unexported fields
                                                                                                                    }

                                                                                                                      ListProposalVotesPaginator is a paginator for ListProposalVotes

                                                                                                                      func NewListProposalVotesPaginator

                                                                                                                      func NewListProposalVotesPaginator(client ListProposalVotesAPIClient, params *ListProposalVotesInput, optFns ...func(*ListProposalVotesPaginatorOptions)) *ListProposalVotesPaginator

                                                                                                                        NewListProposalVotesPaginator returns a new ListProposalVotesPaginator

                                                                                                                        func (*ListProposalVotesPaginator) HasMorePages

                                                                                                                        func (p *ListProposalVotesPaginator) HasMorePages() bool

                                                                                                                          HasMorePages returns a boolean indicating whether more pages are available

                                                                                                                          func (*ListProposalVotesPaginator) NextPage

                                                                                                                          func (p *ListProposalVotesPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListProposalVotesOutput, error)

                                                                                                                            NextPage retrieves the next ListProposalVotes page.

                                                                                                                            type ListProposalVotesPaginatorOptions

                                                                                                                            type ListProposalVotesPaginatorOptions struct {
                                                                                                                            	// The maximum number of votes to return.
                                                                                                                            	Limit int32
                                                                                                                            
                                                                                                                            	// Set to true if pagination should stop if the service returns a pagination token
                                                                                                                            	// that matches the most recent token provided to the service.
                                                                                                                            	StopOnDuplicateToken bool
                                                                                                                            }

                                                                                                                              ListProposalVotesPaginatorOptions is the paginator options for ListProposalVotes

                                                                                                                              type ListProposalsAPIClient

                                                                                                                              type ListProposalsAPIClient interface {
                                                                                                                              	ListProposals(context.Context, *ListProposalsInput, ...func(*Options)) (*ListProposalsOutput, error)
                                                                                                                              }

                                                                                                                                ListProposalsAPIClient is a client that implements the ListProposals operation.

                                                                                                                                type ListProposalsInput

                                                                                                                                type ListProposalsInput struct {
                                                                                                                                
                                                                                                                                	// The unique identifier of the network.
                                                                                                                                	//
                                                                                                                                	// This member is required.
                                                                                                                                	NetworkId *string
                                                                                                                                
                                                                                                                                	// The maximum number of proposals to return.
                                                                                                                                	MaxResults *int32
                                                                                                                                
                                                                                                                                	// The pagination token that indicates the next set of results to retrieve.
                                                                                                                                	NextToken *string
                                                                                                                                }

                                                                                                                                type ListProposalsOutput

                                                                                                                                type ListProposalsOutput struct {
                                                                                                                                
                                                                                                                                	// The pagination token that indicates the next set of results to retrieve.
                                                                                                                                	NextToken *string
                                                                                                                                
                                                                                                                                	// The summary of each proposal made on the network.
                                                                                                                                	Proposals []types.ProposalSummary
                                                                                                                                
                                                                                                                                	// Metadata pertaining to the operation's result.
                                                                                                                                	ResultMetadata middleware.Metadata
                                                                                                                                }

                                                                                                                                type ListProposalsPaginator

                                                                                                                                type ListProposalsPaginator struct {
                                                                                                                                	// contains filtered or unexported fields
                                                                                                                                }

                                                                                                                                  ListProposalsPaginator is a paginator for ListProposals

                                                                                                                                  func NewListProposalsPaginator

                                                                                                                                  func NewListProposalsPaginator(client ListProposalsAPIClient, params *ListProposalsInput, optFns ...func(*ListProposalsPaginatorOptions)) *ListProposalsPaginator

                                                                                                                                    NewListProposalsPaginator returns a new ListProposalsPaginator

                                                                                                                                    func (*ListProposalsPaginator) HasMorePages

                                                                                                                                    func (p *ListProposalsPaginator) HasMorePages() bool

                                                                                                                                      HasMorePages returns a boolean indicating whether more pages are available

                                                                                                                                      func (*ListProposalsPaginator) NextPage

                                                                                                                                      func (p *ListProposalsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListProposalsOutput, error)

                                                                                                                                        NextPage retrieves the next ListProposals page.

                                                                                                                                        type ListProposalsPaginatorOptions

                                                                                                                                        type ListProposalsPaginatorOptions struct {
                                                                                                                                        	// The maximum number of proposals to return.
                                                                                                                                        	Limit int32
                                                                                                                                        
                                                                                                                                        	// Set to true if pagination should stop if the service returns a pagination token
                                                                                                                                        	// that matches the most recent token provided to the service.
                                                                                                                                        	StopOnDuplicateToken bool
                                                                                                                                        }

                                                                                                                                          ListProposalsPaginatorOptions is the paginator options for ListProposals

                                                                                                                                          type Options

                                                                                                                                          type Options struct {
                                                                                                                                          	// Set of options to modify how an operation is invoked. These apply to all
                                                                                                                                          	// operations invoked for this client. Use functional options on operation call to
                                                                                                                                          	// modify this list for per operation behavior.
                                                                                                                                          	APIOptions []func(*middleware.Stack) error
                                                                                                                                          
                                                                                                                                          	// Configures the events that will be sent to the configured logger.
                                                                                                                                          	ClientLogMode aws.ClientLogMode
                                                                                                                                          
                                                                                                                                          	// The credentials object to use when signing requests.
                                                                                                                                          	Credentials aws.CredentialsProvider
                                                                                                                                          
                                                                                                                                          	// The endpoint options to be used when attempting to resolve an endpoint.
                                                                                                                                          	EndpointOptions EndpointResolverOptions
                                                                                                                                          
                                                                                                                                          	// The service endpoint resolver.
                                                                                                                                          	EndpointResolver EndpointResolver
                                                                                                                                          
                                                                                                                                          	// Signature Version 4 (SigV4) Signer
                                                                                                                                          	HTTPSignerV4 HTTPSignerV4
                                                                                                                                          
                                                                                                                                          	// Provides idempotency tokens values that will be automatically populated into
                                                                                                                                          	// idempotent API operations.
                                                                                                                                          	IdempotencyTokenProvider IdempotencyTokenProvider
                                                                                                                                          
                                                                                                                                          	// The logger writer interface to write logging messages to.
                                                                                                                                          	Logger logging.Logger
                                                                                                                                          
                                                                                                                                          	// The region to send requests to. (Required)
                                                                                                                                          	Region string
                                                                                                                                          
                                                                                                                                          	// Retryer guides how HTTP requests should be retried in case of recoverable
                                                                                                                                          	// failures. When nil the API client will use a default retryer.
                                                                                                                                          	Retryer aws.Retryer
                                                                                                                                          
                                                                                                                                          	// The HTTP client to invoke API calls with. Defaults to client's default HTTP
                                                                                                                                          	// implementation if nil.
                                                                                                                                          	HTTPClient HTTPClient
                                                                                                                                          }

                                                                                                                                          func (Options) Copy

                                                                                                                                          func (o Options) Copy() Options

                                                                                                                                            Copy creates a clone where the APIOptions list is deep copied.

                                                                                                                                            type RejectInvitationInput

                                                                                                                                            type RejectInvitationInput struct {
                                                                                                                                            
                                                                                                                                            	// The unique identifier of the invitation to reject.
                                                                                                                                            	//
                                                                                                                                            	// This member is required.
                                                                                                                                            	InvitationId *string
                                                                                                                                            }

                                                                                                                                            type RejectInvitationOutput

                                                                                                                                            type RejectInvitationOutput struct {
                                                                                                                                            	// Metadata pertaining to the operation's result.
                                                                                                                                            	ResultMetadata middleware.Metadata
                                                                                                                                            }

                                                                                                                                            type ResolveEndpoint

                                                                                                                                            type ResolveEndpoint struct {
                                                                                                                                            	Resolver EndpointResolver
                                                                                                                                            	Options  EndpointResolverOptions
                                                                                                                                            }

                                                                                                                                            func (*ResolveEndpoint) HandleSerialize

                                                                                                                                            func (*ResolveEndpoint) ID

                                                                                                                                            func (*ResolveEndpoint) ID() string

                                                                                                                                            type UpdateMemberInput

                                                                                                                                            type UpdateMemberInput struct {
                                                                                                                                            
                                                                                                                                            	// The unique identifier of the member.
                                                                                                                                            	//
                                                                                                                                            	// This member is required.
                                                                                                                                            	MemberId *string
                                                                                                                                            
                                                                                                                                            	// The unique identifier of the Managed Blockchain network to which the member
                                                                                                                                            	// belongs.
                                                                                                                                            	//
                                                                                                                                            	// This member is required.
                                                                                                                                            	NetworkId *string
                                                                                                                                            
                                                                                                                                            	// Configuration properties for publishing to Amazon CloudWatch Logs.
                                                                                                                                            	LogPublishingConfiguration *types.MemberLogPublishingConfiguration
                                                                                                                                            }

                                                                                                                                            type UpdateMemberOutput

                                                                                                                                            type UpdateMemberOutput struct {
                                                                                                                                            	// Metadata pertaining to the operation's result.
                                                                                                                                            	ResultMetadata middleware.Metadata
                                                                                                                                            }

                                                                                                                                            type UpdateNodeInput

                                                                                                                                            type UpdateNodeInput struct {
                                                                                                                                            
                                                                                                                                            	// The unique identifier of the network that the node is on.
                                                                                                                                            	//
                                                                                                                                            	// This member is required.
                                                                                                                                            	NetworkId *string
                                                                                                                                            
                                                                                                                                            	// The unique identifier of the node.
                                                                                                                                            	//
                                                                                                                                            	// This member is required.
                                                                                                                                            	NodeId *string
                                                                                                                                            
                                                                                                                                            	// Configuration properties for publishing to Amazon CloudWatch Logs.
                                                                                                                                            	LogPublishingConfiguration *types.NodeLogPublishingConfiguration
                                                                                                                                            
                                                                                                                                            	// The unique identifier of the member that owns the node. Applies only to
                                                                                                                                            	// Hyperledger Fabric.
                                                                                                                                            	MemberId *string
                                                                                                                                            }

                                                                                                                                            type UpdateNodeOutput

                                                                                                                                            type UpdateNodeOutput struct {
                                                                                                                                            	// Metadata pertaining to the operation's result.
                                                                                                                                            	ResultMetadata middleware.Metadata
                                                                                                                                            }

                                                                                                                                            type VoteOnProposalInput

                                                                                                                                            type VoteOnProposalInput struct {
                                                                                                                                            
                                                                                                                                            	// The unique identifier of the network.
                                                                                                                                            	//
                                                                                                                                            	// This member is required.
                                                                                                                                            	NetworkId *string
                                                                                                                                            
                                                                                                                                            	// The unique identifier of the proposal.
                                                                                                                                            	//
                                                                                                                                            	// This member is required.
                                                                                                                                            	ProposalId *string
                                                                                                                                            
                                                                                                                                            	// The value of the vote.
                                                                                                                                            	//
                                                                                                                                            	// This member is required.
                                                                                                                                            	Vote types.VoteValue
                                                                                                                                            
                                                                                                                                            	// The unique identifier of the member casting the vote.
                                                                                                                                            	//
                                                                                                                                            	// This member is required.
                                                                                                                                            	VoterMemberId *string
                                                                                                                                            }

                                                                                                                                            type VoteOnProposalOutput

                                                                                                                                            type VoteOnProposalOutput struct {
                                                                                                                                            	// Metadata pertaining to the operation's result.
                                                                                                                                            	ResultMetadata middleware.Metadata
                                                                                                                                            }

                                                                                                                                            Directories

                                                                                                                                            Path Synopsis
                                                                                                                                            internal